connectivity/source/drivers/macab/MacabStatement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "MacabStatement.hxx"
  22 #include "sqlbison.hxx"
  23 #include "MacabConnection.hxx"
  24 #include "MacabAddressBook.hxx"
  25 #include "MacabDriver.hxx"
  26 #include "MacabResultSet.hxx"
  27 #include "MacabResultSetMetaData.hxx"
  28 #include "macabcondition.hxx"
  29 #include "macaborder.hxx"
  30 #include "TConnection.hxx"
  31 #include <connectivity/dbexception.hxx>
  32 #include "resource/sharedresources.hxx"
  33 #include "resource/macab_res.hrc"
  34
  35 #if OSL_DEBUG_LEVEL > 0
  36 # define OUtoCStr( x ) ( OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
  37 #else /* OSL_DEBUG_LEVEL */
  38 # define OUtoCStr( x ) ("dummy")
  39 #endif /* OSL_DEBUG_LEVEL */
  40
  41 using namespace connectivity::macab;
  42 using namespace com::sun::star::uno;
  43 using namespace com::sun::star::lang;
  44 using namespace com::sun::star::beans;
  45 using namespace com::sun::star::sdbc;
  46 using namespace com::sun::star::sdbcx;
  47 using namespace com::sun::star::container;
  48 using namespace com::sun::star::io;
  49 using namespace com::sun::star::util;
  50
  51 namespace connectivity
  52 {
  53     namespace macab
  54     {
  55     void impl_throwError(sal_uInt16 _nErrorId)
  56     {
  57         ::connectivity::SharedResources aResources;
  58         const OUString sError( aResources.getResourceString(_nErrorId) );
  59         ::dbtools::throwGenericSQLException(sError,NULL);
  60     }
  61     }
  62 }
  63
  64 IMPLEMENT_SERVICE_INFO(MacabStatement, "com.sun.star.sdbc.drivers.MacabStatement", "com.sun.star.sdbc.Statement");
  65
  66 MacabCommonStatement::MacabCommonStatement(MacabConnection* _pConnection )
  67     : MacabCommonStatement_BASE(m_aMutex),
  68     OPropertySetHelper(MacabCommonStatement_BASE::rBHelper),
  69     m_aParser(_pConnection->getDriver()->getComponentContext()),
  70     m_aSQLIterator(_pConnection, _pConnection->createCatalog()->getTables(), m_aParser, NULL ),
  71     m_pParseTree(NULL),
  72     m_pConnection(_pConnection),
  73     rBHelper(MacabCommonStatement_BASE::rBHelper)
  74 {
  75     m_pConnection->acquire();
  76 }
  77
  78 MacabCommonStatement::~MacabCommonStatement()
  79 {
  80 }
  81
  82 void MacabCommonStatement::disposing()
  83 {
  84     MacabCommonStatement_BASE::disposing();
  85 }
  86
  87 void MacabCommonStatement::resetParameters() const throw(::com::sun::star::sdbc::SQLException)
  88 {
  89 }
  90
  91 void MacabCommonStatement::getNextParameter(OUString &) const throw(::com::sun::star::sdbc::SQLException)
  92 {
  93     impl_throwError(STR_PARA_ONLY_PREPARED);
  94 }
  95
  96 MacabCondition *MacabCommonStatement::analyseWhereClause(const OSQLParseNode *pParseNode) const throw(SQLException)
  97 {
  98     if (pParseNode->count() == 3)
  99     {
 100         const OSQLParseNode *pLeft = pParseNode->getChild(0),
 101                             *pMiddle = pParseNode->getChild(1),
 102                             *pRight = pParseNode->getChild(2);
 103
 104         // WHERE ( ... ) ?
 105         if (SQL_ISPUNCTUATION(pLeft, "(") && SQL_ISPUNCTUATION(pRight, ")"))
 106         {
 107               return analyseWhereClause(pMiddle);
 108         }
 109         else if (SQL_ISRULE(pParseNode, comparison_predicate))
 110         {
 111             if (pLeft->isToken() && pRight->isToken())
 112             {
 113                 switch (pMiddle->getNodeType())
 114                 {
 115                     case SQL_NODE_EQUAL:
 116                         // WHERE 0 = 1
 117                         return new MacabConditionConstant(pLeft->getTokenValue() == pRight->getTokenValue());
 118
 119                     case SQL_NODE_NOTEQUAL:
 120                         // WHERE 0 <> 1
 121                         // (might not be correct SQL... don't care, handling anyway)
 122                         return new MacabConditionConstant(pLeft->getTokenValue() != pRight->getTokenValue());
 123
 124                     default:
 125                         break;
 126                 }
 127             }
 128             else if (SQL_ISRULE(pLeft, column_ref))
 129             {
 130                 OUString sColumnName,
 131                                 sTableRange;
 132
 133                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 134
 135                 if (pRight->isToken() || SQL_ISRULE(pRight, parameter))
 136                 {
 137                     OUString sMatchString;
 138
 139                     if (pRight->isToken())                      // WHERE Name = 'Doe'
 140                         sMatchString = pRight->getTokenValue();
 141                     else if (SQL_ISRULE(pRight, parameter))     // WHERE Name = ?
 142                         getNextParameter(sMatchString);
 143
 144                     switch (pMiddle->getNodeType())
 145                     {
 146                         case SQL_NODE_EQUAL:
 147                             // WHERE Name = 'Smith'
 148                             return new MacabConditionEqual(m_pHeader, sColumnName, sMatchString);
 149
 150                          case SQL_NODE_NOTEQUAL:
 151                             // WHERE Name <> 'Jones'
 152                             return new MacabConditionDifferent(m_pHeader, sColumnName, sMatchString);
 153
 154                         default:
 155                             break;
 156                     }
 157                 }
 158             }
 159         }
 160         else if (SQL_ISRULE(pParseNode, search_condition))
 161         {
 162             if (SQL_ISTOKEN(pMiddle, OR))
 163             {
 164                 // WHERE Name = 'Smith' OR Name = 'Jones'
 165                 return new MacabConditionOr(
 166                     analyseWhereClause(pLeft),
 167                     analyseWhereClause(pRight));
 168             }
 169         }
 170         else if (SQL_ISRULE(pParseNode, boolean_term))
 171         {
 172             if (SQL_ISTOKEN(pMiddle, AND))
 173             {
 174                 // WHERE Name = 'Smith' AND "Given Name" = 'Peter'
 175                 return new MacabConditionAnd(
 176                     analyseWhereClause(pLeft),
 177                     analyseWhereClause(pRight));
 178             }
 179         }
 180     }
 181     else if (SQL_ISRULE(pParseNode, test_for_null) || SQL_ISRULE(pParseNode, like_predicate))
 182     {
 183         const OSQLParseNode *pLeft = pParseNode->getChild(0);
 184         const OSQLParseNode* pPart2 = pParseNode->getChild(1);
 185         const OSQLParseNode *pMiddleLeft = pPart2->getChild(0),
 186                             *pMiddleRight = pPart2->getChild(1),
 187                             *pRight = pPart2->getChild(2);
 188
 189         if (SQL_ISRULE(pParseNode, test_for_null))
 190         {
 191             if (SQL_ISRULE(pLeft, column_ref) &&
 192                             SQL_ISTOKEN(pMiddleLeft, IS) &&
 193                             SQL_ISTOKEN(pRight, NULL))
 194             {
 195                 OUString sColumnName,
 196                                 sTableRange;
 197
 198                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 199
 200                 if (SQL_ISTOKEN(pMiddleRight, NOT))
 201                 {
 202                     // WHERE "Mobile Phone" IS NOT NULL
 203                     return new MacabConditionNotNull(m_pHeader, sColumnName);
 204                 }
 205                 else
 206                 {
 207                     // WHERE "Mobile Phone" IS NULL
 208                     return new MacabConditionNull(m_pHeader, sColumnName);
 209                 }
 210             }
 211         }
 212         else if (SQL_ISRULE(pParseNode, like_predicate))
 213         {
 214             if (SQL_ISRULE(pLeft, column_ref))
 215             {
 216                 OUString sColumnName,
 217                                 sTableRange;
 218
 219                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 220
 221                 if (pMiddleRight->isToken() || SQL_ISRULE(pMiddleRight, parameter))
 222                 {
 223                     OUString sMatchString;
 224
 225                     if (pMiddleRight->isToken())                    // WHERE Name LIKE 'Sm%'
 226                         sMatchString = pMiddleRight->getTokenValue();
 227                     else if (SQL_ISRULE(pMiddleRight, parameter))   // WHERE Name LIKE ?
 228                         getNextParameter(sMatchString);
 229
 230                     return new MacabConditionSimilar(m_pHeader, sColumnName, sMatchString);
 231                 }
 232             }
 233         }
 234     }
 235     impl_throwError(STR_QUERY_TOO_COMPLEX);
 236     // Unreachable:
 237     OSL_ASSERT(false);
 238     return 0;
 239 }
 240
 241 MacabOrder *MacabCommonStatement::analyseOrderByClause(const OSQLParseNode *pParseNode) const throw(SQLException)
 242 {
 243     if (SQL_ISRULE(pParseNode, ordering_spec_commalist))
 244     {
 245         MacabComplexOrder *list = new MacabComplexOrder();
 246         sal_uInt32 n = pParseNode->count();
 247
 248         // Iterate through the ordering columns
 249         for (sal_uInt32 i = 0; i < n; i++)
 250         {
 251             list->addOrder
 252                 (analyseOrderByClause(pParseNode->getChild(i)));
 253         }
 254
 255         return list;
 256     }
 257     else if (SQL_ISRULE(pParseNode, ordering_spec))
 258     {
 259         if (pParseNode->count() == 2)
 260         {
 261             OSQLParseNode* pColumnRef = pParseNode->getChild(0);
 262             OSQLParseNode* pAscendingDescending = pParseNode->getChild(1);
 263
 264             if (SQL_ISRULE(pColumnRef, column_ref))
 265             {
 266                 if (pColumnRef->count() == 3)
 267                     pColumnRef = pColumnRef->getChild(2);
 268
 269                 if (pColumnRef->count() == 1)
 270                 {
 271                     OUString sColumnName =
 272                         pColumnRef->getChild(0)->getTokenValue();
 273                     bool bAscending =
 274                         !SQL_ISTOKEN(pAscendingDescending, DESC);
 275
 276                     return new MacabSimpleOrder(m_pHeader, sColumnName, bAscending);
 277                 }
 278             }
 279         }
 280     }
 281     impl_throwError(STR_QUERY_TOO_COMPLEX);
 282     // Unreachable:
 283     OSL_ASSERT(false);
 284     return 0;
 285 }
 286
 287 OUString MacabCommonStatement::getTableName() const
 288 {
 289     const OSQLTables& xTabs = m_aSQLIterator.getTables();
 290
 291     if( xTabs.empty() )
 292         return OUString();
 293
 294     // can only deal with one table at a time
 295     if(xTabs.size() > 1 || m_aSQLIterator.hasErrors() )
 296         return OUString();
 297
 298     return xTabs.begin()->first;
 299 }
 300
 301 void MacabCommonStatement::setMacabFields(MacabResultSet *pResult) const throw(SQLException)
 302 {
 303     ::rtl::Reference<connectivity::OSQLColumns> xColumns;   // selected columns
 304     MacabResultSetMetaData *pMeta;              // meta information - holds the list of AddressBook fields
 305
 306     xColumns = m_aSQLIterator.getSelectColumns();
 307     if (!xColumns.is())
 308     {
 309         ::connectivity::SharedResources aResources;
 310         const OUString sError( aResources.getResourceString(
 311                 STR_INVALID_COLUMN_SELECTION
 312              ) );
 313         ::dbtools::throwGenericSQLException(sError,NULL);
 314     }
 315     pMeta = static_cast<MacabResultSetMetaData *>(pResult->getMetaData().get());
 316     pMeta->setMacabFields(xColumns);
 317 }
 318
 319 void MacabCommonStatement::selectRecords(MacabResultSet *pResult) const throw(SQLException)
 320 {
 321     const OSQLParseNode *pParseNode;
 322
 323     pParseNode = m_aSQLIterator.getWhereTree();
 324     if (pParseNode != NULL)
 325     {
 326         if (SQL_ISRULE(pParseNode, where_clause))
 327         {
 328             resetParameters();
 329             pParseNode = pParseNode->getChild(1);
 330             MacabCondition *pCondition = analyseWhereClause(pParseNode);
 331             if (pCondition->isAlwaysTrue())
 332                 pResult->allMacabRecords();
 333             else
 334                 pResult->someMacabRecords(pCondition);
 335             delete pCondition;
 336             return;
 337         }
 338     }
 339
 340     // no WHERE clause: get all rows
 341     pResult->allMacabRecords();
 342 }
 343
 344 void MacabCommonStatement::sortRecords(MacabResultSet *pResult) const throw(SQLException)
 345 {
 346     const OSQLParseNode *pParseNode;
 347
 348     pParseNode = m_aSQLIterator.getOrderTree();
 349     if (pParseNode != NULL)
 350     {
 351         if (SQL_ISRULE(pParseNode, opt_order_by_clause))
 352         {
 353             pParseNode = pParseNode->getChild(2);
 354             MacabOrder *pOrder = analyseOrderByClause(pParseNode);
 355             pResult->sortMacabRecords(pOrder);
 356             delete pOrder;
 357         }
 358     }
 359 }
 360
 361 Any SAL_CALL MacabCommonStatement::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
 362 {
 363     Any aRet = MacabCommonStatement_BASE::queryInterface(rType);
 364     if (!aRet.hasValue())
 365         aRet = OPropertySetHelper::queryInterface(rType);
 366     return aRet;
 367 }
 368
 369 Sequence< Type > SAL_CALL MacabCommonStatement::getTypes(  ) throw(RuntimeException, std::exception)
 370 {
 371     ::cppu::OTypeCollection aTypes( cppu::UnoType<XMultiPropertySet>::get(),
 372                                     cppu::UnoType<XFastPropertySet>::get(),
 373                                     cppu::UnoType<XPropertySet>::get());
 374
 375     return comphelper::concatSequences(aTypes.getTypes(),MacabCommonStatement_BASE::getTypes());
 376 }
 377
 378 void SAL_CALL MacabCommonStatement::cancel(  ) throw(RuntimeException)
 379 {
 380     ::osl::MutexGuard aGuard( m_aMutex );
 381
 382     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 383     // cancel the current sql statement
 384 }
 385
 386 void SAL_CALL MacabCommonStatement::close(  ) throw(SQLException, RuntimeException)
 387 {
 388     {
 389         ::osl::MutexGuard aGuard( m_aMutex );
 390         checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 391
 392     }
 393     dispose();
 394 }
 395
 396 sal_Bool SAL_CALL MacabCommonStatement::execute(
 397         const OUString& sql ) throw(SQLException, RuntimeException)
 398 {
 399     ::osl::MutexGuard aGuard( m_aMutex );
 400     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 401
 402     Reference< XResultSet > xRS = executeQuery(sql);
 403
 404     return xRS.is();
 405 }
 406
 407 Reference< XResultSet > SAL_CALL MacabCommonStatement::executeQuery(
 408         const OUString& sql ) throw(SQLException, RuntimeException)
 409 {
 410     ::osl::MutexGuard aGuard( m_aMutex );
 411     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 412
 413 OSL_TRACE("Mac OS Address book - SQL Request: %s", OUtoCStr(sql));
 414
 415     MacabResultSet* pResult = new MacabResultSet(this);
 416     Reference< XResultSet > xRS = pResult;
 417     OUString aErr;
 418
 419     m_pParseTree = m_aParser.parseTree(aErr, sql);
 420     if (m_pParseTree == NULL)
 421         throw SQLException(aErr, *this, aErr, 0, Any());
 422
 423     m_aSQLIterator.setParseTree(m_pParseTree);
 424     m_aSQLIterator.traverseAll();
 425     switch (m_aSQLIterator.getStatementType())
 426     {
 427         case SQL_STATEMENT_SELECT:
 428             {
 429             OUString sTableName = getTableName(); // FROM which table ?
 430             if (sTableName.getLength() != 0) // a match
 431             {
 432                 MacabRecords *aRecords;
 433                 aRecords = m_pConnection->getAddressBook()->getMacabRecords(sTableName);
 434
 435                 // In case, somehow, we don't have anything with the name m_sTableName
 436                 if(aRecords == NULL)
 437                 {
 438                     impl_throwError(STR_NO_TABLE);
 439                 }
 440                 else
 441                 {
 442                     m_pHeader = aRecords->getHeader();
 443
 444                     pResult->setTableName(sTableName);
 445
 446                     setMacabFields(pResult);        // SELECT which columns ?
 447                     selectRecords(pResult); // WHERE which condition ?
 448                     sortRecords(pResult);   // ORDER BY which columns ?
 449                 }
 450 // To be continued: DISTINCT
 451 //                  etc...
 452             }
 453             }
 454             break;
 455
 456         default:
 457 // To be continued: UPDATE
 458 //                  DELETE
 459 //                  etc...
 460             impl_throwError(STR_QUERY_TOO_COMPLEX);
 461     }
 462
 463     m_xResultSet = Reference<XResultSet>(pResult);
 464     return xRS;
 465 }
 466
 467 Reference< XConnection > SAL_CALL MacabCommonStatement::getConnection(  ) throw(SQLException, RuntimeException)
 468 {
 469     ::osl::MutexGuard aGuard( m_aMutex );
 470     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 471
 472     // just return our connection here
 473     return m_pConnection;
 474 }
 475
 476 sal_Int32 SAL_CALL MacabCommonStatement::executeUpdate( const OUString& ) throw(SQLException, RuntimeException)
 477 {
 478     ::osl::MutexGuard aGuard( m_aMutex );
 479     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 480
 481     // the return values gives information about how many rows are affected by executing the sql statement
 482     return 0;
 483 }
 484
 485 Any SAL_CALL MacabCommonStatement::getWarnings(  ) throw(SQLException, RuntimeException)
 486 {
 487     ::osl::MutexGuard aGuard( m_aMutex );
 488     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 489
 490     return makeAny(m_aLastWarning);
 491 }
 492
 493 void SAL_CALL MacabCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeException)
 494 {
 495     ::osl::MutexGuard aGuard( m_aMutex );
 496     checkDisposed(MacabCommonStatement_BASE::rBHelper.bDisposed);
 497
 498     m_aLastWarning = SQLWarning();
 499 }
 500
 501 ::cppu::IPropertyArrayHelper* MacabCommonStatement::createArrayHelper( ) const
 502 {
 503     // this properties are defined by the service statement
 504     // they must be in alphabetic order
 505     Sequence< Property > aProps(10);
 506     Property* pProperties = aProps.getArray();
 507     sal_Int32 nPos = 0;
 508     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 509         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), 0);
 510     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING),
 511         PROPERTY_ID_ESCAPEPROCESSING, cppu::UnoType<bool>::get(), 0);
 512     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 513         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 514     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 515         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 516     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE),
 517         PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 518     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS),
 519         PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0);
 520     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT),
 521         PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0);
 522     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 523         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0);
 524     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
 525         PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0);
 526     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_USEBOOKMARKS),
 527         PROPERTY_ID_USEBOOKMARKS, cppu::UnoType<bool>::get(), 0);
 528
 529     return new ::cppu::OPropertyArrayHelper(aProps);
 530 }
 531
 532 ::cppu::IPropertyArrayHelper & MacabCommonStatement::getInfoHelper()
 533 {
 534     return *getArrayHelper();
 535 }
 536
 537 sal_Bool MacabCommonStatement::convertFastPropertyValue(
 538         Any &,
 539         Any &,
 540         sal_Int32,
 541         const Any&) throw (::com::sun::star::lang::IllegalArgumentException)
 542 {
 543     bool bConverted = false;
 544     // here we have to try to convert
 545     return bConverted;
 546 }
 547
 548 void MacabCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any&) throw (Exception)
 549 {
 550     // set the value to whatever is necessary
 551     switch (nHandle)
 552     {
 553         case PROPERTY_ID_QUERYTIMEOUT:
 554         case PROPERTY_ID_MAXFIELDSIZE:
 555         case PROPERTY_ID_MAXROWS:
 556         case PROPERTY_ID_CURSORNAME:
 557         case PROPERTY_ID_RESULTSETCONCURRENCY:
 558         case PROPERTY_ID_RESULTSETTYPE:
 559         case PROPERTY_ID_FETCHDIRECTION:
 560         case PROPERTY_ID_FETCHSIZE:
 561         case PROPERTY_ID_ESCAPEPROCESSING:
 562         case PROPERTY_ID_USEBOOKMARKS:
 563         default:
 564             ;
 565     }
 566 }
 567
 568 void MacabCommonStatement::getFastPropertyValue(Any&,sal_Int32 nHandle) const
 569 {
 570     switch (nHandle)
 571     {
 572         case PROPERTY_ID_QUERYTIMEOUT:
 573         case PROPERTY_ID_MAXFIELDSIZE:
 574         case PROPERTY_ID_MAXROWS:
 575         case PROPERTY_ID_CURSORNAME:
 576         case PROPERTY_ID_RESULTSETCONCURRENCY:
 577         case PROPERTY_ID_RESULTSETTYPE:
 578         case PROPERTY_ID_FETCHDIRECTION:
 579         case PROPERTY_ID_FETCHSIZE:
 580         case PROPERTY_ID_ESCAPEPROCESSING:
 581         case PROPERTY_ID_USEBOOKMARKS:
 582         default:
 583             ;
 584     }
 585 }
 586
 587 void SAL_CALL MacabCommonStatement::acquire() throw()
 588 {
 589     MacabCommonStatement_BASE::acquire();
 590 }
 591
 592 void SAL_CALL MacabCommonStatement::release() throw()
 593 {
 594     MacabCommonStatement_BASE::release();
 595 }
 596
 597 Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL MacabCommonStatement::getPropertySetInfo(  ) throw(RuntimeException)
 598 {
 599     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 600 }
 601
 602 MacabStatement::MacabStatement(MacabConnection* _pConnection)
 603     : MacabStatement_BASE(_pConnection)
 604 {
 605 }
 606
 607 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */