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