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