connectivity/source/drivers/postgresql/pq_tools.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  Effective License of whole file:
   5  *
   6  *    This library is free software; you can redistribute it and/or
   7  *    modify it under the terms of the GNU Lesser General Public
   8  *    License version 2.1, as published by the Free Software Foundation.
   9  *
  10  *    This library is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *    Lesser General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU Lesser General Public
  16  *    License along with this library; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  *    MA  02111-1307  USA
  19  *
  20  *  Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
  21  *
  22  *    The Contents of this file are made available subject to the terms of
  23  *    the GNU Lesser General Public License Version 2.1
  24  *
  25  *    Copyright: 2000 by Sun Microsystems, Inc.
  26  *
  27  *    Contributor(s): Joerg Budischewski
  28  *
  29  *  All parts contributed on or after August 2011:
  30  *
  31  *    This Source Code Form is subject to the terms of the Mozilla Public
  32  *    License, v. 2.0. If a copy of the MPL was not distributed with this
  33  *    file, You can obtain one at http://mozilla.org/MPL/2.0/.
  34  *
  35  ************************************************************************/
  36
  37 #include <sal/config.h>
  38
  39 #include <o3tl/any.hxx>
  40 #include <rtl/strbuf.hxx>
  41 #include <rtl/ustrbuf.hxx>
  42 #include <sal/log.hxx>
  43
  44 #include <com/sun/star/beans/XPropertySet.hpp>
  45 #include <com/sun/star/container/XEnumerationAccess.hpp>
  46 #include <com/sun/star/lang/XComponent.hpp>
  47 #include <com/sun/star/sdbc/SQLException.hpp>
  48 #include <com/sun/star/sdbc/XRow.hpp>
  49 #include <com/sun/star/sdbc/XParameters.hpp>
  50 #include <com/sun/star/sdbc/DataType.hpp>
  51 #include <com/sun/star/sdbc/KeyRule.hpp>
  52 #include <com/sun/star/sdbcx/KeyType.hpp>
  53 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  54
  55 #include "pq_tools.hxx"
  56 #include "pq_statics.hxx"
  57
  58 #include <libpq-fe.h>
  59 #include <string.h>
  60
  61 using com::sun::star::beans::XPropertySet;
  62
  63 using com::sun::star::lang::XComponent;
  64
  65 using com::sun::star::sdbc::SQLException;
  66 using com::sun::star::sdbc::XStatement;
  67 using com::sun::star::sdbc::XConnection;
  68 using com::sun::star::sdbc::XPreparedStatement;
  69 using com::sun::star::sdbc::XParameters;
  70 using com::sun::star::sdbc::XResultSet;
  71 using com::sun::star::sdbc::XRow;
  72
  73 using com::sun::star::sdbcx::XColumnsSupplier;
  74
  75 using com::sun::star::uno::UNO_QUERY;
  76 using com::sun::star::uno::UNO_QUERY_THROW;
  77 using com::sun::star::uno::Reference;
  78 using com::sun::star::uno::Sequence;
  79 using com::sun::star::uno::XInterface;
  80 using com::sun::star::uno::Any;
  81 using com::sun::star::uno::makeAny;
  82
  83 using com::sun::star::container::XEnumeration;
  84 using com::sun::star::container::XEnumerationAccess;
  85
  86 namespace pq_sdbc_driver
  87 {
  88
  89 OUString concatQualified( const OUString & a, const OUString &b)
  90 {
  91     return a + "." + b;
  92 }
  93
  94 static OString iOUStringToOString( const OUString& str, ConnectionSettings const *settings) {
  95     OSL_ENSURE(settings, "pgsql-sdbc: OUStringToOString got NULL settings");
  96     return OUStringToOString( str, ConnectionSettings::encoding );
  97 }
  98
  99 OString OUStringToOString( const OUString& str, ConnectionSettings const *settings) {
 100     return iOUStringToOString( str, settings );
 101 }
 102
 103 void bufferEscapeConstant( OUStringBuffer & buf, const OUString & value, ConnectionSettings *settings )
 104 {
 105
 106     OString y = iOUStringToOString( value, settings );
 107     OStringBuffer strbuf( y.getLength() * 2 + 2 );
 108     int error;
 109     int len = PQescapeStringConn(settings->pConnection, const_cast<char*>(strbuf.getStr()), y.getStr() , y.getLength(), &error );
 110     if ( error )
 111     {
 112         char *errstr = PQerrorMessage(settings->pConnection);
 113         // As of PostgreSQL 9.1, the only possible errors "involve invalid multibyte encoding"
 114         // According to https://www2.opengroup.org/ogsys/jsp/publications/PublicationDetails.jsp?publicationid=11216
 115         // (X/Open SQL CLI, March 1995, ISBN: 1-85912-081-4, X/Open Document Number: C451)
 116         // 22018 is for "Invalid character value" and seems to be the best match.
 117         // We have no good XInterface Reference to pass here, so just give NULL
 118         throw SQLException(OUString(errstr, strlen(errstr), ConnectionSettings::encoding),
 119                            nullptr,
 120                            "22018",
 121                            -1,
 122                            Any());
 123     }
 124     strbuf.setLength( len );
 125     // Previously here RTL_TEXTENCODING_ASCII_US; as we set the PostgreSQL client_encoding to UTF8,
 126     // we get UTF8 here, too. I'm not sure why it worked well before...
 127     buf.append( OStringToOUString( strbuf.makeStringAndClear(), RTL_TEXTENCODING_UTF8 ) );
 128 }
 129
 130 static void ibufferQuoteConstant( OUStringBuffer & buf, const OUString & value, ConnectionSettings *settings )
 131 {
 132     buf.append( "'" );
 133     bufferEscapeConstant( buf, value, settings );
 134     buf.append( "'" );
 135 }
 136
 137 void bufferQuoteConstant( OUStringBuffer & buf, const OUString & value, ConnectionSettings *settings )
 138 {
 139     return ibufferQuoteConstant( buf, value, settings );
 140 }
 141
 142 void bufferQuoteAnyConstant( OUStringBuffer & buf, const Any &val, ConnectionSettings *settings )
 143 {
 144     if( val.hasValue() )
 145     {
 146         OUString str;
 147         val >>= str;
 148         bufferQuoteConstant( buf, str, settings );
 149     }
 150     else
 151         buf.append( "NULL" );
 152 }
 153
 154 static void ibufferQuoteIdentifier( OUStringBuffer & buf, const OUString &toQuote, ConnectionSettings *settings )
 155 {
 156     OSL_ENSURE(settings, "pgsql-sdbc: bufferQuoteIdentifier got NULL settings");
 157
 158     OString y = iOUStringToOString( toQuote, settings );
 159     char *cstr = PQescapeIdentifier(settings->pConnection, y.getStr(), y.getLength());
 160     if ( cstr == nullptr )
 161     {
 162         char *errstr = PQerrorMessage(settings->pConnection);
 163         // Implementation-defined SQLACCESS error
 164         throw SQLException(OUString(errstr, strlen(errstr), ConnectionSettings::encoding),
 165                            nullptr,
 166                            "22018",
 167                            -1,
 168                            Any());
 169     }
 170     buf.append( OStringToOUString( cstr, RTL_TEXTENCODING_UTF8 ) );
 171     PQfreemem( cstr );
 172 }
 173
 174 void bufferQuoteIdentifier( OUStringBuffer & buf, const OUString &toQuote, ConnectionSettings *settings )
 175 {
 176     return ibufferQuoteIdentifier(buf, toQuote, settings);
 177 }
 178
 179
 180 void bufferQuoteQualifiedIdentifier(
 181     OUStringBuffer & buf, const OUString &schema, const OUString &table, ConnectionSettings *settings )
 182 {
 183     ibufferQuoteIdentifier(buf, schema, settings);
 184     buf.append( "." );
 185     ibufferQuoteIdentifier(buf, table, settings);
 186 }
 187
 188 void bufferQuoteQualifiedIdentifier(
 189     OUStringBuffer & buf,
 190     const OUString &schema,
 191     const OUString &table,
 192     const OUString &col,
 193     ConnectionSettings *settings)
 194 {
 195     ibufferQuoteIdentifier(buf, schema, settings);
 196     buf.append( "." );
 197     ibufferQuoteIdentifier(buf, table, settings);
 198     buf.append( "." );
 199     ibufferQuoteIdentifier(buf, col, settings);
 200 }
 201
 202
 203 OUString extractStringProperty(
 204     const Reference< XPropertySet > & descriptor, const OUString &name )
 205 {
 206     OUString value;
 207     descriptor->getPropertyValue( name ) >>= value;
 208     return value;
 209 }
 210
 211 bool extractBoolProperty(
 212     const Reference< XPropertySet > & descriptor, const OUString &name )
 213 {
 214     bool value = false;
 215     descriptor->getPropertyValue( name ) >>= value;
 216     return value;
 217 }
 218
 219 sal_Int32 extractIntProperty(
 220     const Reference< XPropertySet > & descriptor, const OUString &name )
 221 {
 222     sal_Int32 ret = 0;
 223     descriptor->getPropertyValue( name ) >>= ret;
 224     return ret;
 225 }
 226
 227 void disposeObject( const css::uno::Reference< css::uno::XInterface > & r )
 228 {
 229     Reference< XComponent > comp( r, UNO_QUERY );
 230     if( comp.is() )
 231         comp->dispose();
 232 }
 233
 234 void disposeNoThrow( const css::uno::Reference< css::uno::XInterface > & r )
 235 {
 236     try
 237     {
 238         disposeObject( r );
 239     }
 240     catch( SQLException & )
 241     {
 242         // ignore this
 243     }
 244
 245 }
 246
 247 Reference< XConnection > extractConnectionFromStatement( const Reference< XInterface > & stmt )
 248 {
 249     Reference< XConnection > ret;
 250
 251     Reference< css::sdbc::XStatement > owner( stmt, UNO_QUERY );
 252     if( owner.is() )
 253         ret = owner->getConnection();
 254     else
 255     {
 256         Reference< css::sdbc::XPreparedStatement > myowner( stmt, UNO_QUERY );
 257         if( myowner.is() )
 258             ret = myowner->getConnection();
 259         if( ! ret.is() )
 260             throw SQLException(
 261                 "PQSDBC: Couldn't retrieve connection from statement",
 262                 Reference< XInterface > () , OUString(), 0 , css::uno::Any()  );
 263     }
 264
 265     return ret;
 266
 267 }
 268
 269 DisposeGuard::DisposeGuard( const Reference< XInterface > & r )
 270     : d( r )
 271 {}
 272
 273 DisposeGuard::~DisposeGuard()
 274 {
 275     disposeNoThrow( d );
 276 }
 277
 278 TransactionGuard::TransactionGuard( const Reference< XStatement > &stmt )
 279     : m_stmt( stmt ),
 280       m_commited( false )
 281 {
 282     m_stmt->executeUpdate( getStatics().BEGIN );
 283 }
 284
 285 void TransactionGuard::commit()
 286 {
 287     m_stmt->executeUpdate( getStatics().COMMIT );
 288     m_commited = true;
 289 }
 290
 291 void TransactionGuard::executeUpdate( const OUString & sql )
 292 {
 293     m_stmt->executeUpdate( sql );
 294 }
 295
 296 TransactionGuard::~TransactionGuard()
 297 {
 298     try
 299     {
 300         if( ! m_commited )
 301             m_stmt->executeUpdate( getStatics().ROLLBACK );
 302     }
 303     catch( css::uno::Exception & )
 304     {
 305         // ignore, we are within a dtor
 306     }
 307
 308     disposeNoThrow( m_stmt );
 309 }
 310
 311
 312 bool isWhitespace( sal_Unicode c )
 313 {
 314     return ' ' == c || 9 == c || 10 == c || 13 == c;
 315 }
 316
 317 OUString extractTableFromInsert( const OUString & sql )
 318 {
 319     OUString ret;
 320     int i = 0;
 321     while (i < sql.getLength() && isWhitespace(sql[i])) { i++; }
 322
 323     if( sql.matchIgnoreAsciiCase("insert", i) )
 324     {
 325         i += 6;
 326         while (i < sql.getLength() && isWhitespace(sql[i])) { i++; }
 327         if( sql.matchIgnoreAsciiCase("into", i) )
 328         {
 329             i +=4;
 330             while (i < sql.getLength() && isWhitespace(sql[i])) { i++; }
 331             int start = i;
 332             bool quote = (sql[i] == '"');
 333             for( i++ ; i < sql.getLength() ; i ++ )
 334             {
 335                 if( quote && sql[i] == '"' )
 336                 {
 337                     while (i < sql.getLength() && isWhitespace(sql[i])) { i++; }
 338                     if( '.' == sql[i] )
 339                     {
 340                         while (i < sql.getLength() && isWhitespace(sql[i])) { i++; }
 341                         if( '"' == sql[i] )
 342                         {
 343                             // the second part of the table name does not use quotes
 344                             // parse on
 345                             quote = false;
 346                         }
 347                     }
 348                     else
 349                     {
 350                         // end quoted name, ok
 351                         break;
 352                     }
 353                 }
 354                 else
 355                 {
 356                     if( isWhitespace( sql[i] ) )
 357                     {
 358                         // found the end of an unquoted name
 359                         break;
 360                     }
 361                 }
 362             }
 363             ret = sql.copy(start, i - start ).trim();
 364 //             printf( "pq_statement: parsed table name %s from insert\n" ,
 365 //                     OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US).getStr() );
 366         }
 367     }
 368     return ret;
 369 }
 370
 371
 372 static bool isOperator( char c )
 373 {
 374     bool ret;
 375     switch(c)
 376     {
 377     case '+':
 378     case '-':
 379     case '*':
 380     case '/':
 381     case '<':
 382     case '>':
 383     case '=':
 384     case '~':
 385     case '!':
 386     case '@':
 387     case '#':
 388     case '%':
 389     case '^':
 390     case '&':
 391     case '|':
 392     case '`':
 393     case '?':
 394     case '$':
 395         ret = true;
 396         break;
 397     default:
 398         ret = false;
 399     }
 400     return ret;
 401 }
 402
 403 void splitSQL( const OString & sql, std::vector< OString > &vec )
 404 {
 405     int length = sql.getLength();
 406
 407     int i = 0;
 408     bool singleQuote = false;
 409     bool doubleQuote = false;
 410     int start = 0;
 411     for( ; i < length ; i ++ )
 412     {
 413         char c = sql[i];
 414         if( doubleQuote  )
 415         {
 416             if( '"' == c )
 417             {
 418                 vec.push_back( OString( &sql.getStr()[start], i-start+1  ) );
 419                 start = i + 1;
 420                 doubleQuote = false;
 421             }
 422         }
 423         else if( singleQuote )
 424         {
 425             if( '\'' == c && (i+1) < length && '\'' == sql[i+1] )
 426             {
 427                 // two subsequent single quotes within a quoted string
 428                 // mean a single quote within the string
 429                 i ++;
 430             }
 431             else if( '\'' == c )
 432             {
 433                 vec.push_back( OString( &sql.getStr()[start], i - start +1 ) );
 434                 start = i + 1; // leave single quotes !
 435                 singleQuote = false;
 436             }
 437         }
 438         else
 439         {
 440             if( '"' == c )
 441             {
 442                 vec.push_back( OString( &sql.getStr()[start], i - start ) );
 443                 doubleQuote = true;
 444                 start = i;
 445             }
 446             else if( '\'' == c )
 447             {
 448                 vec.push_back( OString( &sql.getStr()[start], i - start ) );
 449                 singleQuote = true;
 450                 start = i;
 451             }
 452         }
 453     }
 454     if( start < i )
 455         vec.push_back( OString( &sql.getStr()[start] , i - start ) );
 456
 457 //     for( i = 0 ; i < vec.size() ; i ++ )
 458 //         printf( "%s!" , vec[i].getStr() );
 459 //     printf( "\n" );
 460
 461 }
 462
 463 void tokenizeSQL( const OString & sql, std::vector< OString > &vec  )
 464 {
 465     int length = sql.getLength();
 466
 467     int i = 0;
 468     bool singleQuote = false;
 469     bool doubleQuote = false;
 470     int start = 0;
 471     for( ; i < length ; i ++ )
 472     {
 473         char c = sql[i];
 474         if( doubleQuote  )
 475         {
 476             if( '"' == c )
 477             {
 478                 vec.push_back( OString( &sql.getStr()[start], i-start  ) );
 479                 start = i + 1;
 480                 doubleQuote = false;
 481             }
 482         }
 483         else if( singleQuote )
 484         {
 485             if( '\'' == c )
 486             {
 487                 vec.push_back( OString( &sql.getStr()[start], i - start +1 ) );
 488                 start = i + 1; // leave single quotes !
 489                 singleQuote = false;
 490             }
 491         }
 492         else
 493         {
 494             if( '"' == c )
 495             {
 496                 doubleQuote = true;
 497                 start = i +1; // skip double quotes !
 498             }
 499             else if( '\'' == c )
 500             {
 501                 singleQuote = true;
 502                 start = i; // leave single quotes
 503             }
 504             else if( isWhitespace( c ) )
 505             {
 506                 if( i == start )
 507                     start ++;   // skip additional whitespace
 508                 else
 509                 {
 510                     vec.push_back( OString( &sql.getStr()[start], i - start  ) );
 511                     start = i +1;
 512                 }
 513             }
 514             else if( ',' == c || isOperator( c ) || '(' == c || ')' == c )
 515             {
 516                 if( i - start )
 517                     vec.push_back( OString( &sql.getStr()[start], i - start ) );
 518                 vec.push_back( OString( &sql.getStr()[i], 1 ) );
 519                 start = i + 1;
 520             }
 521             else if( '.' == c )
 522             {
 523                 if( ( i > start && sql[start] >= '0' && sql[start] <= '9' ) ||
 524                     ( i == start && i > 1 && isWhitespace( sql[i-1] ) ) )
 525                 {
 526                     // ignore, is a literal
 527                 }
 528                 else
 529                 {
 530                     if( i - start )
 531                         vec.push_back( OString( &sql.getStr()[start], i - start ) );
 532                     vec.push_back( OString( "." ) );
 533                     start = i + 1;
 534                 }
 535             }
 536         }
 537     }
 538     if( start < i )
 539         vec.push_back( OString( &sql.getStr()[start] , i - start ) );
 540
 541 //     for( i = 0 ; i < vec.size() ; i ++ )
 542 //         printf( "%s!" , vec[i].getStr() );
 543 //     printf( "\n" );
 544 }
 545
 546
 547 void splitConcatenatedIdentifier( const OUString & source, OUString *first, OUString *second)
 548 {
 549     std::vector< OString > vec;
 550     tokenizeSQL( OUStringToOString( source, RTL_TEXTENCODING_UTF8 ), vec );
 551     switch (vec.size())
 552     {
 553     case 1:
 554         first->clear();
 555         *second = OStringToOUString( vec[0], RTL_TEXTENCODING_UTF8 );
 556         break;
 557     case 3:
 558         *first  = OStringToOUString( vec[0], RTL_TEXTENCODING_UTF8 );
 559         *second = OStringToOUString( vec[2], RTL_TEXTENCODING_UTF8 );
 560         break;
 561     default:
 562          SAL_WARN("connectivity.postgresql",
 563                   "pq_tools::splitConcatenatedIdentifier unexpected number of tokens in identifier: "
 564                   << vec.size());
 565     }
 566 }
 567
 568 OUString array2String( const css::uno::Sequence< Any > &seq )
 569 {
 570     OUStringBuffer buf(128);
 571     int len = seq.getLength();
 572     buf.append( "{" );
 573     for( int i = 0 ; i < len ; i ++ )
 574     {
 575         OUString element;
 576         seq[i] >>= element;
 577
 578         if( i > 0 )
 579             buf.append( "," );
 580         int strLength = element.getLength();
 581         buf.append( "\"" );
 582         for( int j = 0 ; j < strLength ; j ++ )
 583         {
 584             sal_Unicode c = element[j];
 585             if( c == '\\' || c == '"' || c == '{' || c == '}' )
 586             {
 587                 buf.append( "\\" );
 588             }
 589             buf.append( c );
 590         }
 591         buf.append( "\"" );
 592     }
 593     buf.append( "}" );
 594     return buf.makeStringAndClear();
 595 }
 596
 597
 598 std::vector< Any > parseArray( const OUString & str )
 599 {
 600     int len = str.getLength();
 601     bool doubleQuote = false;
 602     int brackets = 0;
 603     int i = 0;
 604
 605     OUStringBuffer current;
 606     std::vector<Any> elements;
 607     bool doubleQuotedValue = false;
 608     while( i < len )
 609     {
 610         sal_Unicode c = str[i];
 611         sal_Unicode cnext = str[i+1];
 612         if( doubleQuote )
 613         {
 614             if( '\\' == c )
 615             {
 616                 i ++;
 617                 current.append( cnext );
 618             }
 619             else if( '"' == c )
 620             {
 621                 doubleQuote = false;
 622                 doubleQuotedValue = true; // signal, that there was an empty element
 623             }
 624             else
 625             {
 626                 current.append( c );
 627             }
 628         }
 629         else if ( '{' == c )
 630         {
 631             brackets ++;
 632         }
 633         else if( '}' == c )
 634         {
 635             brackets --;
 636             if( brackets < 0 )
 637             {
 638                 throw SQLException(
 639                     "error during array parsing, didn't expect a } at position "
 640                     + OUString::number(i) + " ('" + str + "')",
 641                     Reference< XInterface > (), OUString(), 1, Any() );
 642             }
 643             if( brackets == 0 )
 644             {
 645                 if( !current.isEmpty() || doubleQuotedValue )
 646                     elements.push_back( makeAny( current.makeStringAndClear() ) );
 647             }
 648             else
 649             {
 650                 current.append( c );
 651             }
 652         }
 653         else if( '"' == c )
 654         {
 655 //                 if( current.getLength() != 0 )
 656 //                 {
 657 //                     OUStringBuffer buf;
 658 //                     buf.appendAscii( "error during array parsing, didn't expect a \" at position " );
 659 //                     buf.append( i );
 660 //                     buf.append( " ('" );
 661 //                     buf.append( str );
 662 //                     buf.append( "')" );
 663 //                     throw SDBCException(
 664 //                         buf.makeStringAndClear(),
 665 //                         Reference< XInterface > (), 1, Any() );
 666 //                 }
 667 //                 else
 668 //                 {
 669             doubleQuote = true;
 670 //                 }
 671         }
 672         else if( ',' == c && brackets == 1)
 673         {
 674             doubleQuotedValue = false;
 675             elements.push_back( makeAny( current.makeStringAndClear() ) );
 676         }
 677         else if( isWhitespace( c ) )
 678         {
 679             // ignore whitespace without quotes
 680         }
 681         else
 682         {
 683             current.append( c );
 684         }
 685         i++;
 686     }
 687     return elements;
 688 }
 689
 690 std::vector< sal_Int32 > parseIntArray( const OUString & str )
 691 {
 692     sal_Int32 start = 0;
 693     std::vector<sal_Int32> vec;
 694 //     printf( ">%s<\n" , OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() );
 695     for( sal_Int32 i = str.indexOf( ' ' ) ; i != -1 ; i = str.indexOf( ' ', start) )
 696     {
 697         vec.push_back( rtl_ustr_toInt32( &str.pData->buffer[start], 10 ) );
 698 //         printf( "found %d\n" , rtl_ustr_toInt32( &str.pData->buffer[start], 10 ));
 699         start = i + 1;
 700     }
 701     vec.push_back( rtl_ustr_toInt32( &str.pData->buffer[start], 10 ) );
 702 //     printf( "found %d\n" , rtl_ustr_toInt32( &str.pData->buffer[start], 10 ));
 703     return vec;
 704 }
 705
 706 void fillAttnum2attnameMap(
 707     Int2StringMap &map,
 708     const Reference< css::sdbc::XConnection > &conn,
 709     const OUString &schema,
 710     const OUString &table )
 711 {
 712     Reference< XPreparedStatement > prep = conn->prepareStatement(
 713                    "SELECT attname,attnum "
 714                    "FROM pg_attribute "
 715                          "INNER JOIN pg_class ON attrelid = pg_class.oid "
 716                          "INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid "
 717                    "WHERE relname=? AND nspname=?" );
 718
 719     Reference< XParameters > paras( prep, UNO_QUERY_THROW );
 720     paras->setString( 1 , table );
 721     paras->setString( 2 , schema );
 722     Reference< XResultSet > rs = prep->executeQuery();
 723
 724     Reference< XRow > xRow( rs , UNO_QUERY_THROW );
 725     while( rs->next() )
 726     {
 727         map[ xRow->getInt(2) ] = xRow->getString(1);
 728     }
 729 }
 730
 731 OString extractSingleTableFromSelect( const std::vector< OString > &vec )
 732 {
 733     OString ret;
 734
 735     if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
 736             vec[0].pData->buffer, vec[0].pData->length, "select" , 6 , 6 ) )
 737     {
 738         size_t token = 0;
 739
 740         for( token = 1; token < vec.size() ; token ++ )
 741         {
 742             if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
 743                     vec[token].getStr(), vec[token].getLength(), "from" , 4 , 4 ) )
 744             {
 745                 // found from
 746                 break;
 747             }
 748         }
 749         token ++;
 750
 751         if( token < vec.size() && 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
 752                 vec[token].pData->buffer, vec[token].pData->length, "only " , 4 , 4 ) )
 753         {
 754             token ++;
 755         }
 756
 757         if( token < vec.size() && vec[token] != "(" )
 758         {
 759             // it is a table or a function name
 760             OStringBuffer buf(128);
 761             if( '"' == vec[token][0] )
 762                 buf.append( &(vec[token].getStr()[1]) , vec[token].getLength() -2 );
 763             else
 764                 buf.append( vec[token] );
 765             token ++;
 766
 767             if( token < vec.size() )
 768             {
 769                 if( vec[token] == "." )
 770                 {
 771                     buf.append( vec[token] );
 772                     token ++;
 773                     if( token < vec.size() )
 774                     {
 775                         if( '"' == vec[token][0] )
 776                             buf.append( &(vec[token].getStr()[1]) , vec[token].getLength() -2 );
 777                         else
 778                             buf.append( vec[token] );
 779                         token ++;
 780                     }
 781                 }
 782             }
 783
 784             ret = buf.makeStringAndClear();
 785             // now got my table candidate
 786
 787             if( token < vec.size() && vec[token] == "(" )
 788             {
 789                 // whoops, it is a function
 790                 ret.clear();
 791             }
 792             else
 793             {
 794                 if( token < vec.size() )
 795                 {
 796                     if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
 797                             vec[token].pData->buffer, vec[token].pData->length, "as" , 2, 2 ) )
 798                     {
 799                         token += 2; // skip alias
 800                     }
 801                 }
 802
 803                 if( token < vec.size() )
 804                 {
 805                     if( vec[token] == "," )
 806                     {
 807                         // whoops, multiple tables are used
 808                         ret.clear();
 809                     }
 810                     else
 811                     {
 812                         static const char * forbiddenKeywords[] =
 813                             { "join", "natural", "outer", "inner", "left", "right", "full" , nullptr };
 814                         for( int i = 0 ; forbiddenKeywords[i] ; i ++ )
 815                         {
 816                             size_t nKeywordLen = strlen(forbiddenKeywords[i]);
 817                             if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
 818                                  vec[token].pData->buffer, vec[token].pData->length,
 819                                  forbiddenKeywords[i], nKeywordLen,
 820                                  nKeywordLen ) )
 821                             {
 822                                 // whoops, it is a join
 823                                 ret.clear();
 824                             }
 825                         }
 826                     }
 827                 }
 828             }
 829         }
 830     }
 831     return ret;
 832
 833 }
 834
 835 OUString getColExprForDefaultSettingVal(ConnectionSettings const *settings)
 836 {
 837     return (PQserverVersion( settings->pConnection ) < 80000)?
 838                OUString("pg_attrdef.adsrc"):
 839                OUString("pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid, true)");
 840 }
 841
 842 css::uno::Sequence< sal_Int32 > string2intarray( const OUString & str )
 843 {
 844     css::uno::Sequence< sal_Int32 > ret;
 845     const sal_Int32 strlen = str.getLength();
 846     if( str.getLength() > 1 )
 847     {
 848         sal_Int32 start = 0;
 849         sal_uInt32 c;
 850         for (;;)
 851         {
 852             c = str.iterateCodePoints(&start);
 853             if (!iswspace(c))
 854                 break;
 855             if ( start == strlen)
 856                 return ret;
 857         }
 858         if ( c != L'{' )
 859             return ret;
 860         for (;;)
 861         {
 862             c = str.iterateCodePoints(&start);
 863             if ( !iswspace(c) )
 864                 break;
 865             if ( start == strlen)
 866                 return ret;
 867         }
 868         if ( c == L'}' )
 869             return ret;
 870
 871         std::vector< sal_Int32 > vec;
 872         do
 873         {
 874             OUStringBuffer digits;
 875             do
 876             {
 877                 if(!iswspace(c))
 878                     break;
 879                 if ( start == strlen)
 880                     return ret;
 881                 c=str.iterateCodePoints(&start);
 882             } while ( c );
 883             do
 884             {
 885                 if (!iswdigit(c))
 886                     break;
 887                 if ( start == strlen)
 888                     return ret;
 889                 digits.append(OUString(&c, 1));
 890                 c = str.iterateCodePoints(&start);
 891             } while ( c );
 892             vec.push_back( digits.makeStringAndClear().toInt32() );
 893             do
 894             {
 895                 if(!iswspace(c))
 896                     break;
 897                 if ( start == strlen)
 898                     return ret;
 899                 c = str.iterateCodePoints(&start);
 900             } while ( c );
 901             if ( c == L'}' )
 902                 break;
 903             if ( str.iterateCodePoints(&start) != L',' )
 904                 return ret;
 905             if ( start == strlen)
 906                 return ret;
 907         } while( true );
 908         // vec is guaranteed non-empty
 909         assert(vec.size() > 0);
 910         ret = css::uno::Sequence< sal_Int32 > ( vec.data() , vec.size() );
 911     }
 912     return ret;
 913 }
 914
 915
 916 Sequence< OUString > convertMappedIntArray2StringArray(
 917     const Int2StringMap &map, const Sequence< sal_Int32 > &intArray )
 918 {
 919     Sequence< OUString > ret( intArray.getLength() );
 920     for( int i = 0; i < intArray.getLength() ; i ++ )
 921     {
 922         Int2StringMap::const_iterator ii = map.find( intArray[i] );
 923         if( ii != map.end() )
 924             ret[i] = ii->second;
 925     }
 926     return ret;
 927 }
 928
 929
 930 OUString sqltype2string( const Reference< XPropertySet > & desc )
 931 {
 932     OUStringBuffer typeName;
 933     typeName.append( extractStringProperty( desc, getStatics().TYPE_NAME ) );
 934     sal_Int32 precision = extractIntProperty( desc, getStatics().PRECISION );
 935
 936     if( precision )
 937     {
 938         switch( extractIntProperty( desc, getStatics().TYPE ) )
 939         {
 940         case css::sdbc::DataType::VARBINARY:
 941         case css::sdbc::DataType::VARCHAR:
 942         case css::sdbc::DataType::CHAR:
 943         {
 944             typeName.append( "(" );
 945             typeName.append( precision );
 946             typeName.append( ")" );
 947             break;
 948         }
 949         case css::sdbc::DataType::DECIMAL:
 950         case css::sdbc::DataType::NUMERIC:
 951         {
 952             typeName.append( "(" );
 953             typeName.append( precision );
 954             typeName.append( "," );
 955             typeName.append( extractIntProperty( desc, getStatics().SCALE ) );
 956             typeName.append( ")" );
 957             break;
 958         }
 959         default:
 960             ((void)0);
 961         }
 962     }
 963     return typeName.makeStringAndClear();
 964 }
 965
 966
 967 static void keyType2String( OUStringBuffer & buf, sal_Int32 keyType )
 968 {
 969     if( css::sdbc::KeyRule::CASCADE == keyType )
 970     {
 971         buf.append( "CASCADE " );
 972     }
 973     else if( css::sdbc::KeyRule::RESTRICT  == keyType )
 974     {
 975         buf.append( "RESTRICT " );
 976     }
 977     else if( css::sdbc::KeyRule::SET_DEFAULT  == keyType )
 978     {
 979         buf.append( "SET DEFAULT " );
 980     }
 981     else if( css::sdbc::KeyRule::SET_NULL  == keyType )
 982     {
 983         buf.append( "SET NULL " );
 984     }
 985     else //if( css::sdbc::KeyRule::NO_ACTION == keyType )
 986     {
 987         buf.append( "NO ACTION " );
 988     }
 989 }
 990
 991 void bufferKey2TableConstraint(
 992     OUStringBuffer &buf, const Reference< XPropertySet > &key, ConnectionSettings *settings )
 993 {
 994     Statics &st = getStatics();
 995     sal_Int32 type = extractIntProperty( key, st.TYPE );
 996     OUString referencedTable = extractStringProperty( key, st.REFERENCED_TABLE );
 997     sal_Int32 updateRule = extractIntProperty( key, st.UPDATE_RULE );
 998     sal_Int32 deleteRule = extractIntProperty( key, st.DELETE_RULE );
 999     bool foreign = false;
1000     if( type == css::sdbcx::KeyType::UNIQUE )
1001     {
1002         buf.append( "UNIQUE( " );
1003     }
1004     else if( type == css::sdbcx::KeyType::PRIMARY )
1005     {
1006         buf.append( "PRIMARY KEY( " );
1007     }
1008     else if( type == css::sdbcx::KeyType::FOREIGN )
1009     {
1010         foreign = true;
1011         buf.append( "FOREIGN KEY( " );
1012     }
1013
1014     Reference< XColumnsSupplier > columns( key, UNO_QUERY );
1015     if( columns.is() )
1016     {
1017         Reference< XEnumerationAccess > colEnumAccess( columns->getColumns(), UNO_QUERY );
1018         if( colEnumAccess.is() )
1019         {
1020             Reference< XEnumeration > colEnum = colEnumAccess->createEnumeration();
1021             bool first = true;
1022             while(colEnum.is() && colEnum->hasMoreElements() )
1023             {
1024                 if( first )
1025                 {
1026                     first = false;
1027                 }
1028                 else
1029                 {
1030                     buf.append( ", " );
1031                 }
1032                 Reference< XPropertySet > keyColumn( colEnum->nextElement(), UNO_QUERY_THROW );
1033                 bufferQuoteIdentifier(buf, extractStringProperty( keyColumn, st.NAME ), settings );
1034             }
1035         }
1036     }
1037     buf.append( ") " );
1038
1039     if( !foreign )
1040         return;
1041
1042     buf.append( "REFERENCES " );
1043     OUString schema;
1044     OUString tableName;
1045     splitConcatenatedIdentifier( referencedTable, &schema, &tableName );
1046     bufferQuoteQualifiedIdentifier(buf , schema, tableName, settings );
1047     if(columns.is() )
1048     {
1049         Reference< XEnumerationAccess > colEnumAccess( columns->getColumns(), UNO_QUERY);
1050         if( colEnumAccess.is() )
1051         {
1052             buf.append( " (" );
1053             Reference< XEnumeration > colEnum(colEnumAccess->createEnumeration());
1054             bool first = true;
1055             while(colEnum.is() && colEnum->hasMoreElements() )
1056             {
1057                 if( first )
1058                 {
1059                     first = false;
1060                 }
1061                 else
1062                 {
1063                     buf.append( ", " );
1064                 }
1065                 Reference< XPropertySet > keyColumn( colEnum->nextElement(), UNO_QUERY_THROW );
1066                 bufferQuoteIdentifier(
1067                                       buf, extractStringProperty( keyColumn, st.RELATED_COLUMN ), settings );
1068             }
1069             buf.append( ") " );
1070         }
1071     }
1072
1073     buf.append( "ON DELETE " );
1074     keyType2String( buf, deleteRule );
1075     buf.append( " ON UPDATE " );
1076     keyType2String( buf, updateRule );
1077
1078 }
1079
1080 void extractNameValuePairsFromInsert( String2StringMap & map, const OString & lastQuery )
1081 {
1082     std::vector< OString > vec;
1083     tokenizeSQL( lastQuery, vec  );
1084
1085     int nSize = vec.size();
1086 //     printf( "1 %d\n", nSize );
1087     if( !(nSize > 6  &&
1088         vec[0].equalsIgnoreAsciiCase( "insert" ) &&
1089         vec[1].equalsIgnoreAsciiCase( "into" )) )
1090         return;
1091
1092     int n = 2;
1093
1094 //         printf( "1a\n" );
1095     // skip table name
1096     if( vec[n+1].equalsIgnoreAsciiCase( "." ) )
1097     {
1098         n +=2;
1099     }
1100
1101     n ++;
1102     if( !vec[n].equalsIgnoreAsciiCase( "(" ) )
1103         return;
1104
1105     std::vector< OString> names;
1106 //             printf( "2\n" );
1107     // extract names
1108     n++;
1109     while( nSize > n && ! vec[n].equalsIgnoreAsciiCase( ")" ) )
1110     {
1111         names.push_back( vec[n] );
1112         if( nSize > n+1 && vec[n+1].equalsIgnoreAsciiCase( "," ) )
1113         {
1114             n ++;
1115         }
1116         n++;
1117     }
1118     n++;
1119
1120     // now read the values
1121     if( !(nSize > n +1 && vec[n].equalsIgnoreAsciiCase("VALUES") &&
1122         vec[n+1].equalsIgnoreAsciiCase( "(" )) )
1123         return;
1124
1125     n +=2;
1126 //                 printf( "3\n" );
1127     for (auto& name : names)
1128     {
1129         if (n >= nSize)
1130             break;
1131
1132         map[name] = vec[n];
1133         if( nSize > n+1 && vec[n+1].equalsIgnoreAsciiCase(",") )
1134         {
1135             n ++;
1136         }
1137         n++;
1138     }
1139 }
1140
1141 OUString querySingleValue(
1142     const css::uno::Reference< css::sdbc::XConnection > &connection,
1143     const OUString &query )
1144 {
1145     OUString ret;
1146     Reference< XStatement > stmt = connection->createStatement();
1147     DisposeGuard guard( stmt );
1148     Reference< XResultSet > rs = stmt->executeQuery( query );
1149     Reference< XRow > xRow( rs, UNO_QUERY );
1150     if( rs->next() )
1151         ret = xRow->getString( 1 );
1152     return ret;
1153 }
1154
1155
1156 // copied from connectivity/source/dbtools, can't use the function directly
1157 bool implSetObject( const Reference< XParameters >& _rxParameters,
1158                         const sal_Int32 _nColumnIndex, const Any& _rValue)
1159 {
1160     bool bSuccessfullyReRouted = true;
1161     switch (_rValue.getValueTypeClass())
1162     {
1163         case css::uno::TypeClass_HYPER:
1164         {
1165             _rxParameters->setLong( _nColumnIndex, sal_Int64(0) );
1166         }
1167         break;
1168
1169         case css::uno::TypeClass_VOID:
1170             _rxParameters->setNull(_nColumnIndex,css::sdbc::DataType::VARCHAR);
1171             break;
1172
1173         case css::uno::TypeClass_STRING:
1174             _rxParameters->setString(_nColumnIndex, *o3tl::forceAccess<OUString>(_rValue));
1175             break;
1176
1177         case css::uno::TypeClass_BOOLEAN:
1178             _rxParameters->setBoolean(_nColumnIndex, *o3tl::forceAccess<bool>(_rValue));
1179             break;
1180
1181         case css::uno::TypeClass_BYTE:
1182             _rxParameters->setByte(_nColumnIndex, *o3tl::forceAccess<sal_Int8>(_rValue));
1183             break;
1184
1185         case css::uno::TypeClass_UNSIGNED_SHORT:
1186         case css::uno::TypeClass_SHORT:
1187             _rxParameters->setShort(_nColumnIndex, *o3tl::forceAccess<sal_Int16>(_rValue));
1188             break;
1189
1190         case css::uno::TypeClass_CHAR:
1191             _rxParameters->setString(_nColumnIndex, OUString(*o3tl::forceAccess<sal_Unicode>(_rValue)));
1192             break;
1193
1194         case css::uno::TypeClass_UNSIGNED_LONG:
1195         case css::uno::TypeClass_LONG:
1196             _rxParameters->setInt(_nColumnIndex, *o3tl::forceAccess<sal_Int32>(_rValue));
1197             break;
1198
1199         case css::uno::TypeClass_FLOAT:
1200             _rxParameters->setFloat(_nColumnIndex, *o3tl::forceAccess<float>(_rValue));
1201             break;
1202
1203         case css::uno::TypeClass_DOUBLE:
1204             _rxParameters->setDouble(_nColumnIndex, *o3tl::forceAccess<double>(_rValue));
1205             break;
1206
1207         case css::uno::TypeClass_SEQUENCE:
1208             if (auto s = o3tl::tryAccess<Sequence< sal_Int8 >>(_rValue))
1209             {
1210                 _rxParameters->setBytes(_nColumnIndex, *s);
1211             }
1212             else
1213                 bSuccessfullyReRouted = false;
1214             break;
1215         case css::uno::TypeClass_STRUCT:
1216             if (auto s1 = o3tl::tryAccess<css::util::DateTime>(_rValue))
1217                 _rxParameters->setTimestamp(_nColumnIndex, *s1);
1218             else if (auto s2 = o3tl::tryAccess<css::util::Date>(_rValue))
1219                 _rxParameters->setDate(_nColumnIndex, *s2);
1220             else if (auto s3 = o3tl::tryAccess<css::util::Time>(_rValue))
1221                 _rxParameters->setTime(_nColumnIndex, *s3);
1222             else
1223                 bSuccessfullyReRouted = false;
1224             break;
1225
1226         case css::uno::TypeClass_INTERFACE:
1227         {
1228             Reference< css::io::XInputStream >  xStream;
1229             if (_rValue >>= xStream)
1230             {
1231                 _rValue >>= xStream;
1232                 _rxParameters->setBinaryStream(_nColumnIndex, xStream, xStream->available());
1233                 break;
1234             }
1235             [[fallthrough]];
1236         }
1237         default:
1238             bSuccessfullyReRouted = false;
1239
1240     }
1241
1242     return bSuccessfullyReRouted;
1243 }
1244
1245 }
1246
1247 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */