connectivity/source/drivers/kab/KStatement.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 "KStatement.hxx"
  22 #include "KConnection.hxx"
  23 #include "KDriver.hxx"
  24 #include "KResultSet.hxx"
  25 #include "KResultSetMetaData.hxx"
  26 #include "kcondition.hxx"
  27 #include "korder.hxx"
  28 #include "TConnection.hxx"
  29 #include <connectivity/dbexception.hxx>
  30 #include "resource/kab_res.hrc"
  31 #include "resource/sharedresources.hxx"
  32
  33
  34 #if OSL_DEBUG_LEVEL > 0
  35 # define OUtoCStr( x ) ( OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
  36 #else /* OSL_DEBUG_LEVEL */
  37 # define OUtoCStr( x ) ("dummy")
  38 #endif /* OSL_DEBUG_LEVEL */
  39
  40 using namespace connectivity::kab;
  41 using namespace com::sun::star::uno;
  42 using namespace com::sun::star::lang;
  43 using namespace com::sun::star::beans;
  44 using namespace com::sun::star::sdbc;
  45 using namespace com::sun::star::sdbcx;
  46 using namespace com::sun::star::container;
  47 using namespace com::sun::star::io;
  48 using namespace com::sun::star::util;
  49
  50 namespace
  51 {
  52     void lcl_throwError(sal_uInt16 _nErrorId)
  53     {
  54         ::connectivity::SharedResources aResources;
  55         const OUString sError( aResources.getResourceString(_nErrorId) );
  56         ::dbtools::throwGenericSQLException(sError,NULL);
  57     }
  58 }
  59
  60 IMPLEMENT_SERVICE_INFO(KabStatement, "com.sun.star.sdbc.drivers.KabStatement", "com.sun.star.sdbc.Statement");
  61
  62 KabCommonStatement::KabCommonStatement(KabConnection* _pConnection )
  63     : KabCommonStatement_BASE(m_aMutex),
  64     OPropertySetHelper(KabCommonStatement_BASE::rBHelper),
  65     m_aParser(_pConnection->getDriver()->getComponentContext()),
  66     m_aSQLIterator(_pConnection, _pConnection->createCatalog()->getTables(), m_aParser, NULL ),
  67     m_pParseTree(NULL),
  68     m_pConnection(_pConnection),
  69     rBHelper(KabCommonStatement_BASE::rBHelper)
  70 {
  71     m_pConnection->acquire();
  72 }
  73
  74 KabCommonStatement::~KabCommonStatement()
  75 {
  76 }
  77
  78 void KabCommonStatement::disposing()
  79 {
  80     KabCommonStatement_BASE::disposing();
  81 }
  82
  83 void KabCommonStatement::resetParameters() const throw(::com::sun::star::sdbc::SQLException)
  84 {
  85     lcl_throwError(STR_PARA_ONLY_PREPARED);
  86 }
  87
  88 void KabCommonStatement::getNextParameter(OUString &) const throw(::com::sun::star::sdbc::SQLException)
  89 {
  90     lcl_throwError(STR_PARA_ONLY_PREPARED);
  91 }
  92
  93 KabCondition *KabCommonStatement::analyseWhereClause(const OSQLParseNode *pParseNode) const throw(SQLException)
  94 {
  95     if (pParseNode->count() == 3)
  96     {
  97         const OSQLParseNode *pLeft = pParseNode->getChild(0),
  98                             *pMiddle = pParseNode->getChild(1),
  99                             *pRight = pParseNode->getChild(2);
 100
 101         // WHERE ( ... ) ?
 102         if (SQL_ISPUNCTUATION(pLeft, "(") && SQL_ISPUNCTUATION(pRight, ")"))
 103         {
 104               return analyseWhereClause(pMiddle);
 105         }
 106         else if (SQL_ISRULE(pParseNode, comparison_predicate))
 107         {
 108             if (pLeft->isToken() && pRight->isToken())
 109             {
 110                 switch (pMiddle->getNodeType())
 111                 {
 112                     case SQL_NODE_EQUAL:
 113                         // WHERE 0 = 1
 114                         return new KabConditionConstant(pLeft->getTokenValue() == pRight->getTokenValue());
 115
 116                     case SQL_NODE_NOTEQUAL:
 117                         // WHERE 0 <> 1
 118                         // (might not be correct SQL... don't care, handling anyway)
 119                         return new KabConditionConstant(pLeft->getTokenValue() != pRight->getTokenValue());
 120
 121                     default:
 122                         break;
 123                 }
 124             }
 125             else if (SQL_ISRULE(pLeft, column_ref))
 126             {
 127                 OUString sColumnName,
 128                                 sTableRange;
 129
 130                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 131
 132                 if (pRight->isToken() || SQL_ISRULE(pRight, parameter))
 133                 {
 134                     OUString sMatchString;
 135
 136                     if (pRight->isToken())                      // WHERE Name = 'Doe'
 137                         sMatchString = pRight->getTokenValue();
 138                     else if (SQL_ISRULE(pRight, parameter))     // WHERE Name = ?
 139                         getNextParameter(sMatchString);
 140
 141                     switch (pMiddle->getNodeType())
 142                     {
 143                         case SQL_NODE_EQUAL:
 144                             // WHERE Name = 'Smith'
 145                             return new KabConditionEqual(sColumnName, sMatchString);
 146
 147                          case SQL_NODE_NOTEQUAL:
 148                             // WHERE Name <> 'Jones'
 149                             return new KabConditionDifferent(sColumnName, sMatchString);
 150
 151                         default:
 152                             break;
 153                     }
 154                 }
 155             }
 156         }
 157         else if (SQL_ISRULE(pParseNode, search_condition))
 158         {
 159             if (SQL_ISTOKEN(pMiddle, OR))
 160             {
 161                 // WHERE Name = 'Smith' OR Name = 'Jones'
 162                 return new KabConditionOr(
 163                     analyseWhereClause(pLeft),
 164                     analyseWhereClause(pRight));
 165             }
 166         }
 167         else if (SQL_ISRULE(pParseNode, boolean_term))
 168         {
 169             if (SQL_ISTOKEN(pMiddle, AND))
 170             {
 171                 // WHERE Name = 'Smith' AND "Given Name" = 'Peter'
 172                 return new KabConditionAnd(
 173                     analyseWhereClause(pLeft),
 174                     analyseWhereClause(pRight));
 175             }
 176         }
 177     }
 178     else if (SQL_ISRULE(pParseNode, test_for_null) || SQL_ISRULE(pParseNode, like_predicate))
 179     {
 180         const OSQLParseNode *pLeft = pParseNode->getChild(0);
 181         const OSQLParseNode* pPart2 = pParseNode->getChild(1);
 182         const OSQLParseNode *pMiddleLeft = pPart2->getChild(0),
 183                             *pMiddleRight = pPart2->getChild(1),
 184                             *pRight = pPart2->getChild(2);
 185
 186         if (SQL_ISRULE(pParseNode, test_for_null))
 187         {
 188             if (SQL_ISRULE(pLeft, column_ref) &&
 189                             SQL_ISTOKEN(pMiddleLeft, IS) &&
 190                             SQL_ISTOKEN(pRight, NULL))
 191             {
 192                 OUString sColumnName,
 193                                 sTableRange;
 194
 195                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 196
 197                 if (SQL_ISTOKEN(pMiddleRight, NOT))
 198                 {
 199                     // WHERE "Mobile Phone" IS NOT NULL
 200                     return new KabConditionNotNull(sColumnName);
 201                 }
 202                 else
 203                 {
 204                     // WHERE "Mobile Phone" IS NULL
 205                     return new KabConditionNull(sColumnName);
 206                 }
 207             }
 208         }
 209         else if (SQL_ISRULE(pParseNode, like_predicate))
 210         {
 211             if (SQL_ISRULE(pLeft, column_ref))
 212             {
 213                 OUString sColumnName,
 214                                 sTableRange;
 215
 216                 m_aSQLIterator.getColumnRange(pLeft, sColumnName, sTableRange);
 217
 218                 if (pMiddleRight->isToken() || SQL_ISRULE(pMiddleRight, parameter))
 219                 {
 220                     OUString sMatchString;
 221
 222                     if (pMiddleRight->isToken())                    // WHERE Name LIKE 'Sm%'
 223                         sMatchString = pMiddleRight->getTokenValue();
 224                     else if (SQL_ISRULE(pMiddleRight, parameter))   // WHERE Name LIKE ?
 225                         getNextParameter(sMatchString);
 226
 227                     return new KabConditionSimilar(sColumnName, sMatchString);
 228                 }
 229             }
 230         }
 231     }
 232
 233     lcl_throwError(STR_QUERY_TOO_COMPLEX);
 234
 235     // Unreachable:
 236     OSL_ASSERT(false);
 237     return 0;
 238 }
 239
 240 KabOrder *KabCommonStatement::analyseOrderByClause(const OSQLParseNode *pParseNode) const throw(SQLException)
 241 {
 242     if (SQL_ISRULE(pParseNode, ordering_spec_commalist))
 243     {
 244         KabComplexOrder *list = new KabComplexOrder();
 245         sal_uInt32 n = pParseNode->count();
 246
 247         // Iterate through the ordering columns
 248         for (sal_uInt32 i = 0; i < n; i++)
 249         {
 250             list->addOrder
 251                 (analyseOrderByClause(pParseNode->getChild(i)));
 252         }
 253
 254         return list;
 255     }
 256     else if (SQL_ISRULE(pParseNode, ordering_spec))
 257     {
 258         if (pParseNode->count() == 2)
 259         {
 260             OSQLParseNode* pColumnRef = pParseNode->getChild(0);
 261             OSQLParseNode* pAscendingDescending = pParseNode->getChild(1);
 262
 263             if (SQL_ISRULE(pColumnRef, column_ref))
 264             {
 265                 if (pColumnRef->count() == 3)
 266                     pColumnRef = pColumnRef->getChild(2);
 267
 268                 if (pColumnRef->count() == 1)
 269                 {
 270                     OUString sColumnName =
 271                         pColumnRef->getChild(0)->getTokenValue();
 272                     sal_Bool bAscending =
 273                         SQL_ISTOKEN(pAscendingDescending, DESC)?
 274                         sal_False:
 275                         sal_True;
 276
 277                     return new KabSimpleOrder(sColumnName, bAscending);
 278                 }
 279             }
 280         }
 281     }
 282     lcl_throwError(STR_QUERY_TOO_COMPLEX);
 283     // Unreachable:
 284     OSL_ASSERT(false);
 285     return 0;
 286 }
 287
 288 sal_Bool KabCommonStatement::isTableKnown(KabResultSet *pResult) const
 289 {
 290     // can handle requests like        SELECT * FROM addresses addresses
 291     // but cannot handle requests like SELECT * FROM addresses persons
 292     if (m_aSQLIterator.getTables().size() != 1)
 293         return sal_False;
 294
 295     if (m_aSQLIterator.getTables().begin()->first != pResult->getMetaData()->getTableName(0))
 296         return sal_False;
 297
 298     return sal_True;
 299 }
 300
 301 void KabCommonStatement::setKabFields(KabResultSet *pResult) const throw(SQLException)
 302 {
 303     ::rtl::Reference<connectivity::OSQLColumns> xColumns;   // selected columns
 304
 305     xColumns = m_aSQLIterator.getSelectColumns();
 306     if (!xColumns.is())
 307     {
 308         lcl_throwError(STR_INVALID_COLUMN_SELECTION);
 309     }
 310     pResult->getKabMetaData()->setKabFields(xColumns);
 311 }
 312
 313 void KabCommonStatement::selectAddressees(KabResultSet *pResult) const throw(SQLException)
 314 {
 315     const OSQLParseNode *pParseNode;
 316
 317     pParseNode = m_aSQLIterator.getWhereTree();
 318     if (pParseNode != NULL)
 319     {
 320         if (SQL_ISRULE(pParseNode, where_clause))
 321         {
 322             resetParameters();
 323             pParseNode = pParseNode->getChild(1);
 324             KabCondition *pCondition = analyseWhereClause(pParseNode);
 325             if (pCondition->isAlwaysTrue())
 326                 pResult->allKabAddressees();
 327             else if (!pCondition->isAlwaysFalse())
 328                 pResult->someKabAddressees(pCondition);
 329             delete pCondition;
 330             return;
 331         }
 332     }
 333
 334     // no WHERE clause: get all rows
 335     pResult->allKabAddressees();
 336 }
 337
 338 void KabCommonStatement::sortAddressees(KabResultSet *pResult) const throw(SQLException)
 339 {
 340     const OSQLParseNode *pParseNode;
 341
 342     pParseNode = m_aSQLIterator.getOrderTree();
 343     if (pParseNode != NULL)
 344     {
 345         if (SQL_ISRULE(pParseNode, opt_order_by_clause))
 346         {
 347             pParseNode = pParseNode->getChild(2);
 348             KabOrder *pOrder = analyseOrderByClause(pParseNode);
 349             pResult->sortKabAddressees(pOrder);
 350             delete pOrder;
 351         }
 352     }
 353 }
 354
 355 Any SAL_CALL KabCommonStatement::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
 356 {
 357     Any aRet = KabCommonStatement_BASE::queryInterface(rType);
 358     if (!aRet.hasValue())
 359         aRet = OPropertySetHelper::queryInterface(rType);
 360     return aRet;
 361 }
 362
 363 Sequence< Type > SAL_CALL KabCommonStatement::getTypes(  ) throw(RuntimeException, std::exception)
 364 {
 365     ::cppu::OTypeCollection aTypes( ::getCppuType( (const Reference< XMultiPropertySet > *)0 ),
 366                                     ::getCppuType( (const Reference< XFastPropertySet > *)0 ),
 367                                     ::getCppuType( (const Reference< XPropertySet > *)0 ));
 368
 369     return comphelper::concatSequences(aTypes.getTypes(),KabCommonStatement_BASE::getTypes());
 370 }
 371
 372 void SAL_CALL KabCommonStatement::cancel(  ) throw(RuntimeException, std::exception)
 373 {
 374     ::osl::MutexGuard aGuard( m_aMutex );
 375
 376     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 377     // cancel the current sql statement
 378 }
 379
 380 void SAL_CALL KabCommonStatement::close(  ) throw(SQLException, RuntimeException, std::exception)
 381 {
 382     {
 383         ::osl::MutexGuard aGuard( m_aMutex );
 384         checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 385
 386     }
 387     dispose();
 388 }
 389
 390 sal_Bool SAL_CALL KabCommonStatement::execute(
 391         const OUString& sql ) throw(SQLException, RuntimeException, std::exception)
 392 {
 393     ::osl::MutexGuard aGuard( m_aMutex );
 394     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 395
 396     Reference< XResultSet > xRS = executeQuery(sql);
 397
 398     return xRS.is();
 399 }
 400
 401 Reference< XResultSet > SAL_CALL KabCommonStatement::executeQuery(
 402         const OUString& sql ) throw(SQLException, RuntimeException, std::exception)
 403 {
 404     ::osl::MutexGuard aGuard( m_aMutex );
 405     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 406
 407 OSL_TRACE("KDE Address book - SQL Request: %s", OUtoCStr(sql));
 408
 409     KabResultSet* pResult = new KabResultSet(this);
 410     Reference< XResultSet > xRS = pResult;
 411     OUString aErr;
 412
 413     m_pParseTree = m_aParser.parseTree(aErr, sql);
 414     if (m_pParseTree == NULL)
 415         throw SQLException(aErr, *this, aErr, 0, Any());
 416
 417     m_aSQLIterator.setParseTree(m_pParseTree);
 418     m_aSQLIterator.traverseAll();
 419     switch (m_aSQLIterator.getStatementType())
 420     {
 421         case SQL_STATEMENT_SELECT:
 422             if (isTableKnown(pResult))      // FROM which table ?
 423             {
 424                 setKabFields(pResult);      // SELECT which columns ?
 425                 selectAddressees(pResult);  // WHERE which condition ?
 426                 sortAddressees(pResult);    // ORDER BY which columns ?
 427 // To be continued: DISTINCT
 428 //                  etc...
 429             }
 430             break;
 431
 432         default:
 433 // To be continued: UPDATE
 434 //                  DELETE
 435 //                  etc...
 436             lcl_throwError(STR_QUERY_TOO_COMPLEX);
 437     }
 438
 439     return xRS;
 440 }
 441
 442 Reference< XConnection > SAL_CALL KabCommonStatement::getConnection(  ) throw(SQLException, RuntimeException, std::exception)
 443 {
 444     ::osl::MutexGuard aGuard( m_aMutex );
 445     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 446
 447     // just return our connection here
 448     return (Reference< XConnection >) m_pConnection;
 449 }
 450
 451 sal_Int32 SAL_CALL KabCommonStatement::executeUpdate( const OUString& ) throw(SQLException, RuntimeException, std::exception)
 452 {
 453     ::osl::MutexGuard aGuard( m_aMutex );
 454     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 455
 456     // the return values gives information about how many rows are affected by executing the sql statement
 457     return 0;
 458 }
 459
 460 Any SAL_CALL KabCommonStatement::getWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 461 {
 462     ::osl::MutexGuard aGuard( m_aMutex );
 463     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 464
 465     return makeAny(m_aLastWarning);
 466 }
 467
 468 void SAL_CALL KabCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 469 {
 470     ::osl::MutexGuard aGuard( m_aMutex );
 471     checkDisposed(KabCommonStatement_BASE::rBHelper.bDisposed);
 472
 473     m_aLastWarning = SQLWarning();
 474 }
 475
 476 ::cppu::IPropertyArrayHelper* KabCommonStatement::createArrayHelper( ) const
 477 {
 478     // this properties are defined by the service statement
 479     // they must be in alphabetic order
 480     Sequence< Property > aProps(10);
 481     Property* pProperties = aProps.getArray();
 482     sal_Int32 nPos = 0;
 483     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 484         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), 0);
 485     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING),
 486         PROPERTY_ID_ESCAPEPROCESSING, ::getBooleanCppuType(), 0);
 487     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 488         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 489     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 490         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 491     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE),
 492         PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 493     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS),
 494         PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0);
 495     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT),
 496         PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0);
 497     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 498         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0);
 499     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
 500         PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0);
 501     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_USEBOOKMARKS),
 502         PROPERTY_ID_USEBOOKMARKS, ::getBooleanCppuType(), 0);
 503
 504     return new ::cppu::OPropertyArrayHelper(aProps);
 505 }
 506
 507 ::cppu::IPropertyArrayHelper & KabCommonStatement::getInfoHelper()
 508 {
 509     return *const_cast<KabCommonStatement*>(this)->getArrayHelper();
 510 }
 511
 512 sal_Bool KabCommonStatement::convertFastPropertyValue(
 513         Any &,
 514         Any &,
 515         sal_Int32,
 516         const Any&) throw (::com::sun::star::lang::IllegalArgumentException)
 517 {
 518     sal_Bool bConverted = sal_False;
 519     // here we have to try to convert
 520     return bConverted;
 521 }
 522
 523 void KabCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any&) throw (Exception, std::exception)
 524 {
 525     // set the value to whatever is necessary
 526     switch (nHandle)
 527     {
 528         case PROPERTY_ID_QUERYTIMEOUT:
 529         case PROPERTY_ID_MAXFIELDSIZE:
 530         case PROPERTY_ID_MAXROWS:
 531         case PROPERTY_ID_CURSORNAME:
 532         case PROPERTY_ID_RESULTSETCONCURRENCY:
 533         case PROPERTY_ID_RESULTSETTYPE:
 534         case PROPERTY_ID_FETCHDIRECTION:
 535         case PROPERTY_ID_FETCHSIZE:
 536         case PROPERTY_ID_ESCAPEPROCESSING:
 537         case PROPERTY_ID_USEBOOKMARKS:
 538         default:
 539             ;
 540     }
 541 }
 542
 543 void KabCommonStatement::getFastPropertyValue(Any&,sal_Int32 nHandle) const
 544 {
 545     switch (nHandle)
 546     {
 547         case PROPERTY_ID_QUERYTIMEOUT:
 548         case PROPERTY_ID_MAXFIELDSIZE:
 549         case PROPERTY_ID_MAXROWS:
 550         case PROPERTY_ID_CURSORNAME:
 551         case PROPERTY_ID_RESULTSETCONCURRENCY:
 552         case PROPERTY_ID_RESULTSETTYPE:
 553         case PROPERTY_ID_FETCHDIRECTION:
 554         case PROPERTY_ID_FETCHSIZE:
 555         case PROPERTY_ID_ESCAPEPROCESSING:
 556         case PROPERTY_ID_USEBOOKMARKS:
 557         default:
 558             ;
 559     }
 560 }
 561
 562 void SAL_CALL KabCommonStatement::acquire() throw()
 563 {
 564     KabCommonStatement_BASE::acquire();
 565 }
 566
 567 void SAL_CALL KabCommonStatement::release() throw()
 568 {
 569     KabCommonStatement_BASE::release();
 570 }
 571
 572 Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL KabCommonStatement::getPropertySetInfo(  ) throw(RuntimeException, std::exception)
 573 {
 574     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 575 }
 576
 577 KabStatement::KabStatement(KabConnection* _pConnection)
 578     : KabStatement_BASE(_pConnection)
 579 {
 580 }
 581
 582 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */