connectivity/source/drivers/postgresql/pq_baseresultset.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 <comphelper/sequence.hxx>
  38
  39 #include "pq_tools.hxx"
  40 #include "pq_array.hxx"
  41 #include "pq_baseresultset.hxx"
  42
  43 #include <com/sun/star/script/CannotConvertException.hpp>
  44 #include <com/sun/star/sdbc/SQLException.hpp>
  45 #include <connectivity/dbconversion.hxx>
  46
  47 using osl::MutexGuard;
  48
  49
  50 using com::sun::star::beans::XPropertySetInfo;
  51
  52 using com::sun::star::uno::Any;
  53 using com::sun::star::uno::Type;
  54 using com::sun::star::uno::Sequence;
  55 using com::sun::star::uno::Reference;
  56 using com::sun::star::uno::XInterface;
  57
  58 using com::sun::star::lang::IllegalArgumentException;
  59
  60 using com::sun::star::sdbc::SQLException;
  61
  62
  63 using com::sun::star::beans::Property;
  64
  65 using namespace dbtools;
  66
  67 namespace pq_sdbc_driver
  68 {
  69 static ::cppu::IPropertyArrayHelper & getResultSetPropertyArrayHelper()
  70 {
  71     // LEM TODO: this needs to be kept in sync with other, e.g. pq_statics.css:508
  72     // Should really share!
  73     // At least use for the handles the #define'd values in .hxx file...
  74     static ::cppu::OPropertyArrayHelper arrayHelper(
  75         Sequence<Property>{
  76             Property(
  77                 u"CursorName"_ustr, 0,
  78                 ::cppu::UnoType<OUString>::get() , 0 ),
  79             Property(
  80                 u"EscapeProcessing"_ustr, 1,
  81                 cppu::UnoType<bool>::get() , 0 ),
  82             Property(
  83                 u"FetchDirection"_ustr, 2,
  84                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
  85             Property(
  86                 u"FetchSize"_ustr, 3,
  87                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
  88             Property(
  89                 u"IsBookmarkable"_ustr, 4,
  90                 cppu::UnoType<bool>::get() , 0 ),
  91             Property(
  92                 u"ResultSetConcurrency"_ustr, 5,
  93                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
  94             Property(
  95                 u"ResultSetType"_ustr, 6,
  96                 ::cppu::UnoType<sal_Int32>::get() , 0 )},
  97         true );
  98     return arrayHelper;
  99 }
 100
 101 BaseResultSet::BaseResultSet(
 102     const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
 103     const Reference< XInterface > & owner,
 104     sal_Int32 rowCount,
 105     sal_Int32 colCount,
 106     const Reference< css::script::XTypeConverter > & tc )
 107     : BaseResultSet_BASE( refMutex->GetMutex() )
 108     , OPropertySetHelper( BaseResultSet_BASE::rBHelper )
 109     , m_owner( owner )
 110     , m_tc( tc )
 111     , m_xMutex( refMutex )
 112     , m_row( -1 )
 113     , m_rowCount( rowCount )
 114     , m_fieldCount( colCount )
 115     , m_wasNull(false)
 116 {
 117 }
 118
 119 // LEM TODO: refMutex->GetMutex() should live longer than OComponentHelper,
 120 // but calling OComponentHelper::dispose explicitly here calls
 121 // BaseResultSet::~BaseResultSet in an infinite loop :(
 122 BaseResultSet::~BaseResultSet()
 123 {
 124 }
 125
 126 Any BaseResultSet::queryInterface( const Type & rType )
 127 {
 128     Any aRet = BaseResultSet_BASE::queryInterface(rType);
 129     return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
 130 }
 131
 132 // void BaseResultSet::close(  ) throw (SQLException, RuntimeException)
 133 // {
 134 //     Reference< XInterface > owner;
 135 //     {
 136 //         ResultSetGuard guard(*this);
 137 //         if( m_result )
 138 //         {
 139 //             PQclear(m_result );
 140 //             m_result = 0;
 141 //             m_row = -1;
 142 //         }
 143 //         owner = m_owner;
 144 //         m_owner.clear();
 145 //     }
 146 // }
 147
 148 Sequence<Type > BaseResultSet::getTypes()
 149 {
 150     static Sequence< Type > collection(
 151         ::comphelper::concatSequences(
 152             OPropertySetHelper::getTypes(),
 153             BaseResultSet_BASE::getTypes()));
 154     return collection;
 155 }
 156
 157 Sequence< sal_Int8> BaseResultSet::getImplementationId()
 158 {
 159     return css::uno::Sequence<sal_Int8>();
 160 }
 161
 162 // Reference< XResultSetMetaData > BaseResultSet::getMetaData(  ) throw (SQLException, RuntimeException)
 163 // {
 164 //     ResultSetGuard guard(*this);
 165 //     checkClosed();
 166 //     return new ResultSetMetaData( m_xMutex, this, &m_result );
 167 // }
 168
 169 sal_Bool BaseResultSet::next(  )
 170 {
 171     MutexGuard guard( m_xMutex->GetMutex() );
 172     checkClosed();
 173     m_row ++;
 174     return m_row < m_rowCount;
 175 }
 176
 177 sal_Bool BaseResultSet::isBeforeFirst(  )
 178 {
 179     MutexGuard guard( m_xMutex->GetMutex() );
 180     checkClosed();
 181     return m_row == -1;
 182 }
 183
 184 sal_Bool BaseResultSet::isAfterLast(  )
 185 {
 186     MutexGuard guard( m_xMutex->GetMutex() );
 187     checkClosed();
 188     return m_row >= m_rowCount;
 189 }
 190
 191 sal_Bool BaseResultSet::isFirst(  )
 192 {
 193     MutexGuard guard( m_xMutex->GetMutex() );
 194     checkClosed();
 195     return m_row == 0 && m_rowCount;
 196 }
 197
 198 sal_Bool BaseResultSet::isLast(  )
 199 {
 200     MutexGuard guard( m_xMutex->GetMutex() );
 201     checkClosed();
 202     return m_row >= 0 && m_row + 1 == m_rowCount;
 203 }
 204
 205 void BaseResultSet::beforeFirst(  )
 206 {
 207     MutexGuard guard( m_xMutex->GetMutex() );
 208     checkClosed();
 209     m_row = -1;
 210 }
 211
 212 void BaseResultSet::afterLast(  )
 213 {
 214     MutexGuard guard( m_xMutex->GetMutex() );
 215     checkClosed();
 216     m_row = m_rowCount;
 217 }
 218
 219 sal_Bool BaseResultSet::first(  )
 220 {
 221     MutexGuard guard( m_xMutex->GetMutex() );
 222     checkClosed();
 223     bool bRet = ( m_rowCount > 0 );
 224     if( bRet )
 225         m_row = 0;
 226     return bRet;
 227 }
 228
 229 sal_Bool BaseResultSet::last(  )
 230 {
 231     MutexGuard guard( m_xMutex->GetMutex() );
 232     checkClosed();
 233     bool bRet = ( m_rowCount > 0 );
 234     if( bRet )
 235         m_row = m_rowCount -1;
 236     return bRet;
 237 }
 238
 239 sal_Int32 BaseResultSet::getRow(  )
 240 {
 241     MutexGuard guard( m_xMutex->GetMutex() );
 242     checkClosed();
 243     return m_row +1;
 244 }
 245
 246 sal_Bool BaseResultSet::absolute( sal_Int32 row )
 247 {
 248     MutexGuard guard( m_xMutex->GetMutex() );
 249     checkClosed();
 250     if( row > 0 )
 251     {
 252         m_row = row -1;
 253         if( m_row > m_rowCount )
 254             m_row = m_rowCount;
 255     }
 256     else
 257     {
 258         m_row = m_rowCount + row;
 259         if( m_row < -1 )
 260             m_row = -1;
 261     }
 262     return true;
 263 }
 264
 265 sal_Bool BaseResultSet::relative( sal_Int32 rows )
 266 {
 267     MutexGuard guard( m_xMutex->GetMutex() );
 268     checkClosed();
 269     m_row += rows;
 270
 271     if( m_row > m_rowCount )
 272         m_row = m_rowCount;
 273     else if ( m_row < -1 )
 274         m_row = -1;
 275     return true;
 276 }
 277
 278 sal_Bool BaseResultSet::previous(  )
 279 {
 280     MutexGuard guard( m_xMutex->GetMutex() );
 281     checkClosed();
 282     bool bRet = ( m_row != -1 );
 283     if( bRet )
 284         m_row --;
 285     return bRet;
 286 }
 287
 288 void BaseResultSet::refreshRow(  )
 289 {
 290     // TODO: not supported for now
 291 }
 292
 293 sal_Bool BaseResultSet::rowUpdated(  )
 294 {
 295     return false;
 296 }
 297
 298 sal_Bool BaseResultSet::rowInserted(  )
 299 {
 300     return false;
 301 }
 302
 303 sal_Bool BaseResultSet::rowDeleted(  )
 304 {
 305     return false;
 306 }
 307
 308 Reference< XInterface > BaseResultSet::getStatement()
 309 {
 310     MutexGuard guard( m_xMutex->GetMutex() );
 311     checkClosed();
 312     return m_owner;
 313 }
 314
 315
 316 //----------------- XRow interface ----------------------------------------------------
 317
 318 sal_Bool BaseResultSet::wasNull(  )
 319 {
 320     return m_wasNull;
 321 }
 322
 323 Any BaseResultSet::convertTo( const Any & val , const Type & type )
 324 {
 325     Any aRet;
 326     try
 327     {
 328         aRet = m_tc->convertTo( val , type );
 329     }
 330     catch( css::lang::IllegalArgumentException & )
 331     {}
 332     catch( css::script::CannotConvertException & )
 333     {}
 334     return aRet;
 335 }
 336
 337 sal_Bool BaseResultSet::getBoolean( sal_Int32 columnIndex )
 338 {
 339     MutexGuard guard( m_xMutex->GetMutex() );
 340     checkClosed();
 341     checkColumnIndex( columnIndex );
 342     checkRowIndex();
 343
 344     OUString str = getString( columnIndex );
 345
 346     if( str.getLength() > 0 )
 347     {
 348         switch(str[0])
 349         {
 350         case '1':
 351         case 't':
 352         case 'T':
 353         case 'y':
 354         case 'Y':
 355
 356             return true;
 357         }
 358     }
 359     return false;
 360 }
 361
 362 sal_Int8 BaseResultSet::getByte( sal_Int32 columnIndex )
 363 {
 364     MutexGuard guard( m_xMutex->GetMutex() );
 365     checkClosed();
 366     checkColumnIndex( columnIndex );
 367     checkRowIndex();
 368     sal_Int8 b = 0;
 369     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(b)>::get()) >>= b;
 370     return b;
 371 }
 372
 373 sal_Int16 BaseResultSet::getShort( sal_Int32 columnIndex )
 374 {
 375     MutexGuard guard( m_xMutex->GetMutex() );
 376     checkClosed();
 377     checkColumnIndex( columnIndex );
 378     checkRowIndex();
 379     sal_Int16 i = 0;
 380     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(i)>::get()) >>= i;
 381     return i;
 382 }
 383
 384 OUString BaseResultSet::getString( sal_Int32 columnIndex )
 385 {
 386     MutexGuard guard(m_xMutex->GetMutex());
 387     checkClosed();
 388     checkColumnIndex( columnIndex );
 389     checkRowIndex();
 390     OUString ret;
 391     convertTo( getValue(  columnIndex ), cppu::UnoType<decltype(ret)>::get() ) >>= ret;
 392 //     printf( "BaseResultSet::getString() %s\n" , OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ).getStr() );
 393     return ret;
 394 }
 395
 396 sal_Int32 BaseResultSet::getInt( sal_Int32 columnIndex )
 397 {
 398     MutexGuard guard( m_xMutex->GetMutex() );
 399     checkClosed();
 400     checkColumnIndex( columnIndex );
 401     checkRowIndex();
 402     sal_Int32 i = 0;
 403     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(i)>::get()) >>= i;
 404     return i;
 405 }
 406
 407 sal_Int64 BaseResultSet::getLong( sal_Int32 columnIndex )
 408 {
 409     MutexGuard guard( m_xMutex->GetMutex() );
 410     checkClosed();
 411     checkColumnIndex( columnIndex );
 412     checkRowIndex();
 413     sal_Int64 i = 0;
 414     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(i)>::get()) >>= i;
 415     return i;
 416 }
 417
 418 float BaseResultSet::getFloat( sal_Int32 columnIndex )
 419 {
 420     MutexGuard guard( m_xMutex->GetMutex() );
 421     checkClosed();
 422     checkColumnIndex( columnIndex );
 423     checkRowIndex();
 424     float f = 0.;
 425     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(f)>::get()) >>= f;
 426     return f;
 427 }
 428
 429 double BaseResultSet::getDouble( sal_Int32 columnIndex )
 430 {
 431     MutexGuard guard( m_xMutex->GetMutex() );
 432     checkClosed();
 433     checkColumnIndex( columnIndex );
 434     double d = 0.;
 435     convertTo( getValue( columnIndex ), cppu::UnoType<decltype(d)>::get()) >>= d;
 436     return d;
 437 }
 438
 439 Sequence< sal_Int8 > BaseResultSet::getBytes( sal_Int32 columnIndex )
 440 {
 441     MutexGuard guard( m_xMutex->GetMutex() );
 442     checkClosed();
 443     checkColumnIndex( columnIndex );
 444     checkRowIndex();
 445
 446     Sequence< sal_Int8 > ret;
 447     OUString ustr;
 448     if( ! (getValue( columnIndex ) >>= ustr) )
 449         m_wasNull = true;
 450     else
 451     {
 452         // if this is a binary, it must contain escaped data !
 453         OString val = OUStringToOString( ustr, RTL_TEXTENCODING_ASCII_US );
 454
 455         size_t length;
 456         char * res = reinterpret_cast<char*>(PQunescapeBytea( reinterpret_cast<unsigned char const *>(val.getStr()), &length));
 457         ret = Sequence< sal_Int8 > ( reinterpret_cast<sal_Int8*>(res), length );
 458         if( res )
 459             PQfreemem( res );
 460     }
 461     return ret;
 462 }
 463
 464
 465 css::util::Date BaseResultSet::getDate( sal_Int32 columnIndex )
 466 {
 467     return DBTypeConversion::toDate( getString( columnIndex ) );
 468 }
 469
 470 css::util::Time BaseResultSet::getTime( sal_Int32 columnIndex )
 471 {
 472     return DBTypeConversion::toTime( getString( columnIndex ) );
 473 }
 474
 475 css::util::DateTime BaseResultSet::getTimestamp( sal_Int32 columnIndex )
 476 {
 477     return DBTypeConversion::toDateTime( getString( columnIndex ) );
 478 }
 479
 480   // LEM TODO: these look like they are missing an actual implementation
 481 Reference< css::io::XInputStream > BaseResultSet::getBinaryStream( sal_Int32 /* columnIndex */ )
 482 {
 483     return nullptr;
 484 }
 485
 486 Reference< css::io::XInputStream > BaseResultSet::getCharacterStream( sal_Int32 /* columnIndex */ )
 487 {
 488     return nullptr;
 489 }
 490
 491 Any BaseResultSet::getObject(
 492         sal_Int32 /* columnIndex */,
 493         const Reference< css::container::XNameAccess >& /* typeMap */ )
 494 {
 495     return Any();
 496 }
 497
 498 Reference< css::sdbc::XRef > BaseResultSet::getRef( sal_Int32 /* columnIndex */ )
 499 {
 500     return Reference< css::sdbc::XRef > ();
 501 }
 502
 503 Reference< css::sdbc::XBlob > BaseResultSet::getBlob( sal_Int32 /* columnIndex */ )
 504 {
 505     return Reference< css::sdbc::XBlob > ();
 506 }
 507
 508 Reference< css::sdbc::XClob > BaseResultSet::getClob( sal_Int32 /* columnIndex */ )
 509 {
 510     return Reference< css::sdbc::XClob > ();
 511 }
 512
 513 Reference< css::sdbc::XArray > BaseResultSet::getArray( sal_Int32 columnIndex )
 514 {
 515     return new Array( m_xMutex, parseArray( getString( columnIndex ) ), *this, m_tc );
 516 }
 517
 518 ::cppu::IPropertyArrayHelper & BaseResultSet::getInfoHelper()
 519 {
 520     return getResultSetPropertyArrayHelper();
 521 }
 522
 523 sal_Bool BaseResultSet::convertFastPropertyValue(
 524         Any & /* rConvertedValue */, Any & /* rOldValue */, sal_Int32 nHandle, const Any& rValue )
 525 {
 526     bool bRet;
 527     switch( nHandle )
 528     {
 529     case BASERESULTSET_CURSOR_NAME:
 530     {
 531         OUString val;
 532         bRet = ( rValue >>= val );
 533         m_props[nHandle] <<= val;
 534         break;
 535     }
 536     case BASERESULTSET_ESCAPE_PROCESSING:
 537     case BASERESULTSET_IS_BOOKMARKABLE:
 538     {
 539         bool val(false);
 540         bRet = ( rValue >>= val );
 541         m_props[nHandle] <<= val;
 542         break;
 543     }
 544     case BASERESULTSET_FETCH_DIRECTION:
 545     case BASERESULTSET_FETCH_SIZE:
 546     case BASERESULTSET_RESULT_SET_CONCURRENCY:
 547     case BASERESULTSET_RESULT_SET_TYPE:
 548     {
 549         sal_Int32 val;
 550         bRet = ( rValue >>= val );
 551         m_props[nHandle] <<= val;
 552         break;
 553     }
 554     default:
 555     {
 556         throw IllegalArgumentException(
 557             "pq_resultset: Invalid property handle (" + OUString::number( nHandle ) + ")",
 558             *this, 2 );
 559     }
 560     }
 561     return bRet;
 562 }
 563
 564
 565 void BaseResultSet::setFastPropertyValue_NoBroadcast(
 566     sal_Int32 nHandle,const Any& rValue )
 567 {
 568     m_props[nHandle] = rValue;
 569 }
 570
 571 void BaseResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 572 {
 573     rValue = m_props[nHandle];
 574 }
 575
 576 Reference < XPropertySetInfo >  BaseResultSet::getPropertySetInfo()
 577 {
 578     return OPropertySetHelper::createPropertySetInfo( getResultSetPropertyArrayHelper() );
 579 }
 580
 581 void BaseResultSet::disposing()
 582 {
 583     close();
 584 }
 585
 586 void BaseResultSet::checkColumnIndex(sal_Int32 index )
 587 {
 588     if( index < 1 || index > m_fieldCount )
 589     {
 590         throw SQLException(
 591             "pq_resultset: index out of range ("
 592             + OUString::number( index )
 593             + ", allowed range is 1 to " + OUString::number( m_fieldCount )
 594             + ")",
 595             *this, OUString(), 1, Any() );
 596     }
 597
 598 }
 599
 600 void BaseResultSet::checkRowIndex()
 601 {
 602     if( m_row < 0 || m_row >= m_rowCount )
 603     {
 604         throw SQLException(
 605             "pq_baseresultset: row index out of range, allowed is 0 to " + OUString::number( m_rowCount -1 )
 606             + ", got " + OUString::number( m_row ),
 607             *this, OUString(),1, Any() );
 608     }
 609 }
 610
 611 }
 612
 613 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */