connectivity/source/drivers/postgresql/pq_updateableresultset.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: 200? 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 <rtl/ustrbuf.hxx>
  38 #include <rtl/strbuf.hxx>
  39
  40 #include <cppuhelper/queryinterface.hxx>
  41 #include <cppuhelper/typeprovider.hxx>
  42 #include <com/sun/star/sdbc/SQLException.hpp>
  43 #include <com/sun/star/sdbc/XGeneratedResultSet.hpp>
  44
  45 #include "pq_updateableresultset.hxx"
  46 #include "pq_resultsetmetadata.hxx"
  47 #include "pq_tools.hxx"
  48 #include "pq_statics.hxx"
  49
  50 #include <string.h>
  51
  52 #include <connectivity/dbconversion.hxx>
  53
  54 using osl::MutexGuard;
  55
  56
  57 using com::sun::star::uno::Reference;
  58 using com::sun::star::uno::Sequence;
  59 using com::sun::star::uno::UNO_QUERY;
  60 using com::sun::star::uno::Any;
  61 using com::sun::star::uno::Type;
  62
  63 using com::sun::star::sdbc::XGeneratedResultSet;
  64 using com::sun::star::sdbc::XResultSetMetaDataSupplier;
  65 using com::sun::star::sdbc::SQLException;
  66 using com::sun::star::sdbc::XResultSet;
  67 using com::sun::star::sdbc::XCloseable;
  68 using com::sun::star::sdbc::XColumnLocate;
  69 using com::sun::star::sdbc::XResultSetUpdate;
  70 using com::sun::star::sdbc::XRowUpdate;
  71 using com::sun::star::sdbc::XRow;
  72 using com::sun::star::sdbc::XStatement;
  73
  74 using com::sun::star::beans::XFastPropertySet;
  75 using com::sun::star::beans::XPropertySet;
  76 using com::sun::star::beans::XMultiPropertySet;
  77
  78 using namespace dbtools;
  79
  80 namespace pq_sdbc_driver
  81 {
  82
  83
  84 css::uno::Reference< css::sdbc::XCloseable > UpdateableResultSet::createFromPGResultSet(
  85     const ::rtl::Reference< comphelper::RefCountedMutex > & mutex,
  86     const css::uno::Reference< css::uno::XInterface > &owner,
  87     ConnectionSettings **ppSettings,
  88     PGresult *result,
  89     const OUString &schema,
  90     const OUString &table,
  91     const std::vector< OUString > &primaryKey )
  92 {
  93     sal_Int32 columnCount = PQnfields( result );
  94     sal_Int32 rowCount = PQntuples( result );
  95     std::vector< OUString > columnNames( columnCount );
  96     for( int i = 0 ; i < columnCount ; i ++ )
  97     {
  98         char * name = PQfname( result, i );
  99         columnNames[i] = OUString( name, strlen(name), ConnectionSettings::encoding );
 100     }
 101     std::vector< std::vector< Any > > data( rowCount );
 102
 103     // copy all the data into unicode strings (also binaries, as we yet
 104     // don't know, what a binary is and what not!)
 105     for( int row = 0 ; row < rowCount ; row ++ )
 106     {
 107         std::vector< Any > aRow( columnCount );
 108         for( int col = 0 ; col < columnCount ; col ++ )
 109         {
 110             if( ! PQgetisnull( result, row, col ) )
 111             {
 112                 char * val = PQgetvalue( result, row, col );
 113
 114                 aRow[col] <<=
 115                     OUString( val, strlen( val ), ConnectionSettings::encoding );
 116             }
 117         }
 118         data[row] = aRow;
 119     }
 120
 121     UpdateableResultSet *pRS =  new UpdateableResultSet(
 122         mutex, owner, columnNames, data, ppSettings, schema, table, primaryKey );
 123
 124     Reference <XCloseable > ret = pRS; // give it a refcount
 125
 126     pRS->m_meta = new ResultSetMetaData( mutex, pRS,nullptr, ppSettings, result, schema, table );
 127
 128     PQclear( result ); // we don't need it anymore
 129
 130     return ret;
 131 }
 132
 133 css::uno::Any  UpdateableResultSet::queryInterface(
 134     const css::uno::Type & reqType )
 135 {
 136     Any ret = SequenceResultSet::queryInterface( reqType );
 137     if( ! ret.hasValue() )
 138         ret = ::cppu::queryInterface(
 139             reqType,
 140             static_cast< XResultSetUpdate * > ( this ),
 141             static_cast< XRowUpdate * > ( this ) );
 142     return ret;
 143 }
 144
 145
 146 css::uno::Sequence< css::uno::Type > UpdateableResultSet::getTypes()
 147 {
 148     static cppu::OTypeCollection collection(
 149         cppu::UnoType<XResultSetUpdate>::get(),
 150         cppu::UnoType<XRowUpdate>::get(),
 151         SequenceResultSet::getTypes());
 152
 153     return collection.getTypes();
 154
 155 }
 156
 157 css::uno::Sequence< sal_Int8> UpdateableResultSet::getImplementationId()
 158 {
 159     return css::uno::Sequence<sal_Int8>();
 160 }
 161
 162 OUString UpdateableResultSet::buildWhereClause()
 163 {
 164     OUString ret;
 165     if( !m_primaryKey.empty() )
 166     {
 167         OUStringBuffer buf( 128 );
 168         buf.append( " WHERE " );
 169         for( size_t i = 0 ; i < m_primaryKey.size() ; i ++ )
 170         {
 171             if( i > 0 )
 172                 buf.append( " AND " );
 173             sal_Int32 index = findColumn( m_primaryKey[i] );
 174             bufferQuoteIdentifier( buf, m_primaryKey[i], *m_ppSettings );
 175             buf.append( " = " );
 176             bufferQuoteConstant( buf, getString( index ), *m_ppSettings );
 177         }
 178         ret = buf.makeStringAndClear();
 179     }
 180     return ret;
 181 }
 182
 183
 184 void UpdateableResultSet::insertRow(  )
 185 {
 186     MutexGuard guard( m_xMutex->GetMutex() );
 187     if (isLog(*m_ppSettings, LogLevel::Info))
 188     {
 189         log(*m_ppSettings, LogLevel::Info, "UpdateableResultSet::insertRow got called");
 190     }
 191     if( ! m_insertRow )
 192         throw SQLException(
 193             "pq_resultset.insertRow: moveToInsertRow has not been called !",
 194             *this, OUString(), 1, Any() );
 195
 196     OUStringBuffer buf( 128 );
 197     buf.append( "INSERT INTO " );
 198     bufferQuoteQualifiedIdentifier( buf, m_schema, m_table, *m_ppSettings );
 199     buf.append( " ( " );
 200
 201     int columns = 0;
 202     for( UpdateableFieldVector::size_type i = 0 ; i < m_updateableField.size() ; i++ )
 203     {
 204         if( m_updateableField[i].isTouched )
 205         {
 206             if( columns > 0 )
 207                 buf.append( ", " );
 208             columns ++;
 209             bufferQuoteIdentifier( buf, m_columnNames[i], *m_ppSettings);
 210         }
 211     }
 212     buf.append( " ) VALUES ( " );
 213
 214     columns = 0;
 215     for(UpdateableField & i : m_updateableField)
 216     {
 217         if( i.isTouched )
 218         {
 219             if( columns > 0 )
 220                 buf.append( " , " );
 221             columns ++;
 222             bufferQuoteAnyConstant( buf, i.value, *m_ppSettings );
 223
 224 //             OUString val;
 225 //             m_updateableField[i].value >>= val;
 226 //             buf.append( val );
 227 //                 OStringToOUString(val, (*m_ppSettings)->encoding ) );
 228         }
 229     }
 230
 231     buf.append( " )" );
 232
 233     Reference< XStatement > stmt =
 234         extractConnectionFromStatement(m_owner)->createStatement();
 235     DisposeGuard dispGuard( stmt );
 236     stmt->executeUpdate( buf.makeStringAndClear() );
 237
 238     // reflect the changes !
 239     m_rowCount ++;
 240     m_data.resize( m_rowCount );
 241     m_data[m_rowCount-1] = std::vector< Any > ( m_fieldCount );
 242     Reference< XGeneratedResultSet > result( stmt, UNO_QUERY );
 243     if( result.is() )
 244     {
 245         Reference< XResultSet > rs = result->getGeneratedValues();
 246         if( rs.is() && rs->next() )
 247         {
 248             Reference< XColumnLocate > columnLocate( rs, UNO_QUERY );
 249             Reference< XRow> xRow ( rs, UNO_QUERY );
 250             for( int i = 0 ; i < m_fieldCount ; i++ )
 251             {
 252                 int field = columnLocate->findColumn( m_columnNames[i] );
 253                 if( field >= 1 )
 254                 {
 255                     m_data[m_rowCount-1][i] <<=  xRow->getString( field );
 256 //                     printf( "adding %s %s\n" ,
 257 //                             OUStringToOString( m_columnNames[i], RTL_TEXTENCODING_ASCII_US).getStr(),
 258 //                             OUStringToOString( xRow->getString( field ), RTL_TEXTENCODING_ASCII_US).getStr() );
 259
 260                 }
 261             }
 262         }
 263         else
 264         {
 265             // do the best we can ( DEFAULT and AUTO increment values fail ! )
 266             for( int i = 0 ; i < m_fieldCount ; i ++ )
 267             {
 268                 if( m_updateableField[i].isTouched )
 269                     m_data[m_rowCount-1][i] = m_updateableField[i].value;
 270             }
 271         }
 272     }
 273
 274     // cleanup
 275     m_updateableField = UpdateableFieldVector();
 276 }
 277
 278 void UpdateableResultSet::updateRow(  )
 279 {
 280     MutexGuard guard( m_xMutex->GetMutex() );
 281     if (isLog(*m_ppSettings, LogLevel::Info))
 282     {
 283         log(*m_ppSettings, LogLevel::Info, "UpdateableResultSet::updateRow got called");
 284     }
 285     if( m_insertRow )
 286         throw SQLException(
 287             "pq_resultset.updateRow: moveToCurrentRow has not been called !",
 288             *this, OUString(), 1, Any() );
 289
 290     OUStringBuffer buf( 128 );
 291     buf.append( "UPDATE " );
 292     bufferQuoteQualifiedIdentifier( buf, m_schema, m_table, *m_ppSettings );
 293     buf.append( "SET " );
 294
 295     int columns = 0;
 296     for( UpdateableFieldVector::size_type i = 0; i < m_updateableField.size() ; i ++ )
 297     {
 298         if( m_updateableField[i].isTouched )
 299         {
 300             if( columns > 0 )
 301                 buf.append( ", " );
 302             columns ++;
 303
 304             buf.append( m_columnNames[i] );
 305             buf.append( " = " );
 306             bufferQuoteAnyConstant( buf, m_updateableField[i].value, *m_ppSettings );
 307 //             OUString val;
 308 //             m_updateableField[i].value >>= val;
 309 //             bufferQuoteConstant( buf, val ):
 310 //             buf.append( val );
 311         }
 312     }
 313     buf.append( buildWhereClause() );
 314
 315     Reference< XStatement > stmt = extractConnectionFromStatement(m_owner)->createStatement();
 316     DisposeGuard dispGuard( stmt );
 317     stmt->executeUpdate( buf.makeStringAndClear() );
 318
 319     // reflect the changes !
 320     for( int i = 0 ; i < m_fieldCount ; i ++ )
 321     {
 322         if( m_updateableField[i].isTouched  )
 323             m_data[m_row][i] = m_updateableField[i].value;
 324     }
 325     m_updateableField = UpdateableFieldVector();
 326 }
 327
 328 void UpdateableResultSet::deleteRow(  )
 329 {
 330     if (isLog(*m_ppSettings, LogLevel::Info))
 331     {
 332         log(*m_ppSettings, LogLevel::Info, "UpdateableResultSet::deleteRow got called");
 333     }
 334     if( m_insertRow )
 335         throw SQLException(
 336             "pq_resultset.deleteRow: deleteRow cannot be called when on insert row !",
 337             *this, OUString(), 1, Any() );
 338
 339     if( m_row < 0 || m_row >= m_rowCount )
 340     {
 341         throw SQLException(
 342             "deleteRow cannot be called on invalid row ("
 343             + OUString::number(m_row) + ")",
 344             *this, OUString(), 0, Any() );
 345     }
 346
 347     Reference< XStatement > stmt = extractConnectionFromStatement(m_owner)->createStatement();
 348     DisposeGuard dispGuard( stmt );
 349     OUStringBuffer buf( 128 );
 350     buf.append( "DELETE FROM " );
 351     bufferQuoteQualifiedIdentifier( buf, m_schema, m_table, *m_ppSettings );
 352     buf.append( " " );
 353     buf.append( buildWhereClause() );
 354
 355     stmt->executeUpdate( buf.makeStringAndClear() );
 356
 357     // reflect the changes !
 358     for( int i = m_row + 1; i < m_row ; i ++ )
 359     {
 360         m_data[i-1] = m_data[i];
 361     }
 362     m_rowCount --;
 363     m_data.resize( m_rowCount );
 364  }
 365
 366 void UpdateableResultSet::cancelRowUpdates(  )
 367 {
 368     MutexGuard guard( m_xMutex->GetMutex() );
 369     m_updateableField = UpdateableFieldVector();
 370 }
 371
 372 void UpdateableResultSet::moveToInsertRow(  )
 373 {
 374     m_insertRow = true;
 375 }
 376
 377 void UpdateableResultSet::moveToCurrentRow(  )
 378 {
 379     m_insertRow = false;
 380 }
 381
 382 void UpdateableResultSet::checkUpdate( sal_Int32 columnIndex)
 383 {
 384     checkColumnIndex( columnIndex );
 385     if( m_updateableField.empty() )
 386         m_updateableField = UpdateableFieldVector( m_fieldCount );
 387     m_updateableField[columnIndex-1].isTouched = true;
 388 }
 389
 390 void UpdateableResultSet::updateNull( sal_Int32 columnIndex )
 391 {
 392     MutexGuard guard( m_xMutex->GetMutex() );
 393     checkClosed();
 394     checkUpdate( columnIndex );
 395     m_updateableField[columnIndex-1].value = Any();
 396 }
 397
 398 void UpdateableResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x )
 399 {
 400     MutexGuard guard( m_xMutex->GetMutex() );
 401     checkClosed();
 402     checkUpdate( columnIndex );
 403
 404     Statics &st = getStatics();
 405     m_updateableField[columnIndex-1].value <<=  ( x ? st.TRUE : st.FALSE );
 406
 407 }
 408
 409 void UpdateableResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x )
 410 {
 411     updateInt(columnIndex,x);
 412 }
 413
 414 void UpdateableResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x )
 415 {
 416     updateInt( columnIndex, x );
 417 }
 418
 419 void UpdateableResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x )
 420 {
 421     updateLong( columnIndex, x );
 422 //     MutexGuard guard( m_xMutex->GetMutex() );
 423 //     checkClosed();
 424 //     checkUpdate( columnIndex );
 425
 426 //     m_updateableField[columnIndex-1].value <<= OUString::valueOf( x );
 427
 428 }
 429
 430 void UpdateableResultSet::updateLong( sal_Int32 columnIndex, sal_Int64 x )
 431 {
 432     MutexGuard guard( m_xMutex->GetMutex() );
 433     checkClosed();
 434     checkUpdate( columnIndex );
 435
 436 //     OStringBuffer buf( 20 );
 437 //     buf.append( "'" );
 438 //     buf.append( (sal_Int64) x );
 439 //     buf.append( "'" );
 440     m_updateableField[columnIndex-1].value <<= OUString::number( x );
 441 }
 442
 443 void UpdateableResultSet::updateFloat( sal_Int32 columnIndex, float x )
 444 {
 445
 446     MutexGuard guard( m_xMutex->GetMutex() );
 447     checkClosed();
 448     checkUpdate( columnIndex );
 449
 450     m_updateableField[columnIndex-1].value <<= OUString::number( x );
 451 }
 452
 453 void UpdateableResultSet::updateDouble( sal_Int32 columnIndex, double x )
 454 {
 455     MutexGuard guard( m_xMutex->GetMutex() );
 456     checkClosed();
 457     checkUpdate( columnIndex );
 458
 459     m_updateableField[columnIndex-1].value <<= OUString::number( x );
 460 }
 461
 462 void UpdateableResultSet::updateString( sal_Int32 columnIndex, const OUString& x )
 463 {
 464     MutexGuard guard( m_xMutex->GetMutex() );
 465     checkClosed();
 466     checkUpdate( columnIndex );
 467
 468     m_updateableField[columnIndex-1].value <<= x;
 469 }
 470
 471 void UpdateableResultSet::updateBytes( sal_Int32 columnIndex, const css::uno::Sequence< sal_Int8 >& x )
 472 {
 473     MutexGuard guard( m_xMutex->GetMutex() );
 474     checkClosed();
 475     checkUpdate( columnIndex );
 476
 477     size_t len;
 478     unsigned char * escapedString =
 479         PQescapeBytea( reinterpret_cast<unsigned char const *>(x.getConstArray()), x.getLength(), &len);
 480     if( ! escapedString )
 481     {
 482         throw SQLException(
 483             "pq_preparedstatement.setBytes: Error during converting bytesequence to an SQL conform string",
 484             *this, OUString(), 1, Any() );
 485     }
 486 //     buf.append( (const sal_Char *)escapedString, len -1 );
 487
 488     m_updateableField[columnIndex-1].value <<=
 489         OUString( reinterpret_cast<char*>(escapedString), len, RTL_TEXTENCODING_ASCII_US );
 490     free( escapedString );
 491 }
 492
 493 void UpdateableResultSet::updateDate( sal_Int32 columnIndex, const css::util::Date& x )
 494 {
 495     updateString( columnIndex, DBTypeConversion::toDateString( x ) );
 496 }
 497
 498 void UpdateableResultSet::updateTime( sal_Int32 columnIndex, const css::util::Time& x )
 499 {
 500     updateString( columnIndex, DBTypeConversion::toTimeString( x ) );
 501 }
 502
 503 void UpdateableResultSet::updateTimestamp( sal_Int32 columnIndex, const css::util::DateTime& x )
 504 {
 505     updateString( columnIndex, DBTypeConversion::toDateTimeString( x ) );
 506 }
 507
 508 void UpdateableResultSet::updateBinaryStream( sal_Int32 /* columnIndex */, const css::uno::Reference< css::io::XInputStream >& /* x */, sal_Int32 /* length */ )
 509 {
 510 }
 511
 512 void UpdateableResultSet::updateCharacterStream( sal_Int32 /* columnIndex */, const css::uno::Reference< css::io::XInputStream >& /* x */, sal_Int32 /* length */ )
 513 {
 514 }
 515
 516 void UpdateableResultSet::updateObject( sal_Int32 /* columnIndex */, const css::uno::Any& /* x */ )
 517 {
 518 }
 519
 520 void UpdateableResultSet::updateNumericObject( sal_Int32 /* columnIndex */, const css::uno::Any& /* x */, sal_Int32 /* scale */ )
 521 {
 522 }
 523
 524
 525 Sequence< Type > UpdateableResultSet::getStaticTypes( bool updateable )
 526 {
 527     if( updateable )
 528     {
 529         cppu::OTypeCollection collection(
 530             cppu::UnoType<XResultSetUpdate>::get(),
 531             cppu::UnoType<XRowUpdate>::get(),
 532 //             cppu::UnoType<css::sdbcx::XRowLocate>::get(),
 533             getStaticTypes( false /* updateable */ ) );
 534         return collection.getTypes();
 535     }
 536     else
 537     {
 538         cppu::OTypeCollection collection(
 539             cppu::UnoType<XResultSet>::get(),
 540             cppu::UnoType<XResultSetMetaDataSupplier>::get(),
 541             cppu::UnoType<XRow>::get(),
 542             cppu::UnoType<XColumnLocate>::get(),
 543             cppu::UnoType<XCloseable>::get(),
 544             cppu::UnoType<XPropertySet>::get(),
 545             cppu::UnoType<XFastPropertySet>::get(),
 546             cppu::UnoType<XMultiPropertySet>::get(),
 547             cppu::UnoType<css::lang::XComponent>::get(),  // OComponentHelper
 548             cppu::UnoType<css::lang::XTypeProvider>::get(),
 549             cppu::UnoType<css::uno::XAggregation>::get(),
 550             cppu::UnoType<css::uno::XWeak>::get());
 551         return collection.getTypes();
 552     }
 553 }
 554
 555 }
 556
 557 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */