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 28 #include <connectivity/sqlnode.hxx> 29 #include <connectivity/sqlerror.hxx> 30 #include <internalnode.hxx> 31 #define YYBISON 1 32 #ifndef BISON_INCLUDED 33 #define BISON_INCLUDED 34 #include <sqlbison.hxx> 35 #endif 36 #include <connectivity/sqlparse.hxx> 37 #include <com/sun/star/lang/Locale.hpp> 38 #include <com/sun/star/util/XNumberFormatter.hpp> 39 #include <com/sun/star/util/XNumberFormatTypes.hpp> 40 #include <com/sun/star/i18n/NumberFormatIndex.hpp> 41 #include <com/sun/star/beans/XPropertySet.hpp> 42 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp> 43 #include <com/sun/star/sdbc/DataType.hpp> 44 #include <com/sun/star/sdb/XQueriesSupplier.hpp> 45 #include <com/sun/star/sdb/ErrorCondition.hpp> 46 #include <com/sun/star/util/XNumberFormatter.hpp> 47 #include <com/sun/star/util/XNumberFormatsSupplier.hpp> 48 #include <com/sun/star/util/XNumberFormats.hpp> 49 #include <com/sun/star/util/NumberFormat.hpp> 50 #include <com/sun/star/util/XNumberFormatTypes.hpp> 51 #include <com/sun/star/lang/Locale.hpp> 52 #include <com/sun/star/i18n/KParseType.hpp> 53 #include <com/sun/star/i18n/KParseTokens.hpp> 54 #include "connectivity/dbconversion.hxx" 55 #include <com/sun/star/util/DateTime.hpp> 56 #include <com/sun/star/util/Time.hpp> 57 #include <com/sun/star/util/Date.hpp> 58 #include "TConnection.hxx" 59 #include "sqlscan.hxx" 60 #include <comphelper/numbers.hxx> 61 #include <comphelper/processfactory.hxx> 62 #include <comphelper/stl_types.hxx> 63 #include "connectivity/dbtools.hxx" 64 #include "connectivity/dbmetadata.hxx" 65 #include "connectivity/sqlerror.hxx" 66 #include <tools/diagnose_ex.h> 67 #include <string.h> 68 #include <boost/bind.hpp> 69 #include <algorithm> 70 #include <functional> 71 #include <rtl/logfile.hxx> 72 #include <rtl/ustrbuf.hxx> 73 74 using namespace ::com::sun::star::sdbc; 75 using namespace ::com::sun::star::util; 76 using namespace ::com::sun::star::beans; 77 using namespace ::com::sun::star::sdb; 78 using namespace ::com::sun::star::uno; 79 using namespace ::com::sun::star::lang; 80 using namespace ::com::sun::star::i18n; 81 using namespace ::com::sun::star; 82 using namespace ::osl; 83 using namespace ::dbtools; 84 using namespace ::comphelper; 85 86 87 extern int SQLyyparse (void); 88 extern ::rtl::OUString ConvertLikeToken(const ::connectivity::OSQLParseNode* pTokenNode, const ::connectivity::OSQLParseNode* pEscapeNode, sal_Bool bInternational); 89 extern void setParser( ::connectivity::OSQLParser* ); 90 91 namespace 92 { 93 // ----------------------------------------------------------------------------- 94 sal_Bool lcl_saveConvertToNumber(const Reference< XNumberFormatter > & _xFormatter,sal_Int32 _nKey,const ::rtl::OUString& _sValue,double& _nrValue) 95 { 96 sal_Bool bRet = sal_False; 97 try 98 { 99 _nrValue = _xFormatter->convertStringToNumber(_nKey, _sValue); 100 bRet = sal_True; 101 } 102 catch(Exception&) 103 { 104 } 105 return bRet; 106 } 107 // ----------------------------------------------------------------------------- 108 void replaceAndReset(connectivity::OSQLParseNode*& _pResetNode,connectivity::OSQLParseNode* _pNewNode) 109 { 110 _pResetNode->getParent()->replace(_pResetNode, _pNewNode); 111 delete _pResetNode; 112 _pResetNode = _pNewNode; 113 } 114 // ----------------------------------------------------------------------------- 115 /** quotes a string and search for quotes inside the string and replace them with the new quote 116 @param rValue 117 The value to be quoted. 118 @param rQuot 119 The quote 120 @param rQuotToReplace 121 The quote to replace with 122 @return 123 The quoted string. 124 */ 125 ::rtl::OUString SetQuotation(const ::rtl::OUString& rValue, const ::rtl::OUString& rQuot, const ::rtl::OUString& rQuotToReplace) 126 { 127 ::rtl::OUString rNewValue = rQuot; 128 rNewValue += rValue; 129 sal_Int32 nIndex = (sal_Int32)-1; // Quotes durch zweifache Quotes ersetzen, sonst kriegt der Parser Probleme 130 131 if (rQuot.getLength()) 132 { 133 do 134 { 135 nIndex += 2; 136 nIndex = rNewValue.indexOf(rQuot,nIndex); 137 if(nIndex != -1) 138 rNewValue = rNewValue.replaceAt(nIndex,rQuot.getLength(),rQuotToReplace); 139 } while (nIndex != -1); 140 } 141 142 rNewValue += rQuot; 143 return rNewValue; 144 } 145 } 146 147 namespace connectivity 148 { 149 150 //============================================================================= 151 struct OSQLParser_Data 152 { 153 ::com::sun::star::lang::Locale aLocale; 154 ::connectivity::SQLError aErrors; 155 156 OSQLParser_Data( const Reference< XMultiServiceFactory >& _xServiceFactory ) 157 :aErrors( _xServiceFactory ) 158 { 159 } 160 }; 161 162 //============================================================================= 163 //= SQLParseNodeParameter 164 //============================================================================= 165 //----------------------------------------------------------------------------- 166 SQLParseNodeParameter::SQLParseNodeParameter( const Reference< XConnection >& _rxConnection, 167 const Reference< XNumberFormatter >& _xFormatter, const Reference< XPropertySet >& _xField, 168 const Locale& _rLocale, const IParseContext* _pContext, 169 bool _bIntl, bool _bQuote, sal_Char _cDecSep, bool _bPredicate, bool _bParseToSDBC ) 170 :rLocale(_rLocale) 171 ,aMetaData( _rxConnection ) 172 ,pParser( NULL ) 173 ,pSubQueryHistory( new QueryNameSet ) 174 ,xFormatter(_xFormatter) 175 ,xField(_xField) 176 ,m_rContext( _pContext ? (const IParseContext&)(*_pContext) : (const IParseContext&)OSQLParser::s_aDefaultContext ) 177 ,cDecSep(_cDecSep) 178 ,bQuote(_bQuote) 179 ,bInternational(_bIntl) 180 ,bPredicate(_bPredicate) 181 ,bParseToSDBCLevel( _bParseToSDBC ) 182 { 183 } 184 185 //----------------------------------------------------------------------------- 186 SQLParseNodeParameter::~SQLParseNodeParameter() 187 { 188 } 189 190 //============================================================================= 191 //= OSQLParseNode 192 //============================================================================= 193 //----------------------------------------------------------------------------- 194 ::rtl::OUString OSQLParseNode::convertDateString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const 195 { 196 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertDateString" ); 197 Date aDate = DBTypeConversion::toDate(rString); 198 Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); 199 Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); 200 201 double fDate = DBTypeConversion::toDouble(aDate,DBTypeConversion::getNULLDate(xSupplier)); 202 sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 36; // XXX hack 203 return rParam.xFormatter->convertNumberToString(nKey, fDate); 204 } 205 206 //----------------------------------------------------------------------------- 207 ::rtl::OUString OSQLParseNode::convertDateTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const 208 { 209 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertDateTimeString" ); 210 DateTime aDate = DBTypeConversion::toDateTime(rString); 211 Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); 212 Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); 213 214 double fDateTime = DBTypeConversion::toDouble(aDate,DBTypeConversion::getNULLDate(xSupplier)); 215 sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 51; // XXX hack 216 return rParam.xFormatter->convertNumberToString(nKey, fDateTime); 217 } 218 219 //----------------------------------------------------------------------------- 220 ::rtl::OUString OSQLParseNode::convertTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const 221 { 222 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertTimeString" ); 223 Time aTime = DBTypeConversion::toTime(rString); 224 Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); 225 226 Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); 227 228 double fTime = DBTypeConversion::toDouble(aTime); 229 sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 41; // XXX hack 230 return rParam.xFormatter->convertNumberToString(nKey, fTime); 231 } 232 233 //----------------------------------------------------------------------------- 234 void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, 235 const Reference< XConnection >& _rxConnection, 236 const IParseContext* pContext, 237 sal_Bool _bIntl, 238 sal_Bool _bQuote) const 239 { 240 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToStr" ); 241 242 parseNodeToStr( 243 rString, _rxConnection, NULL, NULL, 244 pContext ? pContext->getPreferredLocale() : OParseContext::getDefaultLocale(), 245 pContext, _bIntl, _bQuote, '.', false, false ); 246 } 247 248 //----------------------------------------------------------------------------- 249 void OSQLParseNode::parseNodeToPredicateStr(::rtl::OUString& rString, 250 const Reference< XConnection >& _rxConnection, 251 const Reference< XNumberFormatter > & xFormatter, 252 const ::com::sun::star::lang::Locale& rIntl, 253 sal_Char _cDec, 254 const IParseContext* pContext ) const 255 { 256 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToPredicateStr" ); 257 258 OSL_ENSURE(xFormatter.is(), "OSQLParseNode::parseNodeToPredicateStr:: no formatter!"); 259 260 if (xFormatter.is()) 261 parseNodeToStr(rString, _rxConnection, xFormatter, NULL, rIntl, pContext, sal_True, sal_True, _cDec, true, false); 262 } 263 264 //----------------------------------------------------------------------------- 265 void OSQLParseNode::parseNodeToPredicateStr(::rtl::OUString& rString, 266 const Reference< XConnection > & _rxConnection, 267 const Reference< XNumberFormatter > & xFormatter, 268 const Reference< XPropertySet > & _xField, 269 const ::com::sun::star::lang::Locale& rIntl, 270 sal_Char _cDec, 271 const IParseContext* pContext ) const 272 { 273 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToPredicateStr" ); 274 275 OSL_ENSURE(xFormatter.is(), "OSQLParseNode::parseNodeToPredicateStr:: no formatter!"); 276 277 if (xFormatter.is()) 278 parseNodeToStr( rString, _rxConnection, xFormatter, _xField, rIntl, pContext, true, true, _cDec, true, false ); 279 } 280 281 //----------------------------------------------------------------------------- 282 void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, 283 const Reference< XConnection > & _rxConnection, 284 const Reference< XNumberFormatter > & xFormatter, 285 const Reference< XPropertySet > & _xField, 286 const ::com::sun::star::lang::Locale& rIntl, 287 const IParseContext* pContext, 288 bool _bIntl, 289 bool _bQuote, 290 sal_Char _cDecSep, 291 bool _bPredicate, 292 bool _bSubstitute) const 293 { 294 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToStr" ); 295 296 OSL_ENSURE( _rxConnection.is(), "OSQLParseNode::parseNodeToStr: invalid connection!" ); 297 298 if ( _rxConnection.is() ) 299 { 300 ::rtl::OUStringBuffer sBuffer = rString; 301 try 302 { 303 OSQLParseNode::impl_parseNodeToString_throw( sBuffer, 304 SQLParseNodeParameter( 305 _rxConnection, xFormatter, _xField, rIntl, pContext, 306 _bIntl, _bQuote, _cDecSep, _bPredicate, _bSubstitute 307 ) ); 308 } 309 catch( const SQLException& ) 310 { 311 OSL_ENSURE( false, "OSQLParseNode::parseNodeToStr: this should not throw!" ); 312 // our callers don't expect this method to throw anything. The only known situation 313 // where impl_parseNodeToString_throw can throw is when there is a cyclic reference 314 // in the sub queries, but this cannot be the case here, as we do not parse to 315 // SDBC level. 316 } 317 rString = sBuffer.makeStringAndClear(); 318 } 319 } 320 //----------------------------------------------------------------------------- 321 bool OSQLParseNode::parseNodeToExecutableStatement( ::rtl::OUString& _out_rString, const Reference< XConnection >& _rxConnection, 322 OSQLParser& _rParser, ::com::sun::star::sdbc::SQLException* _pErrorHolder ) const 323 { 324 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToExecutableStatement" ); 325 OSL_PRECOND( _rxConnection.is(), "OSQLParseNode::parseNodeToExecutableStatement: invalid connection!" ); 326 SQLParseNodeParameter aParseParam( _rxConnection, 327 NULL, NULL, OParseContext::getDefaultLocale(), NULL, false, true, '.', false, true ); 328 329 if ( aParseParam.aMetaData.supportsSubqueriesInFrom() ) 330 { 331 Reference< XQueriesSupplier > xSuppQueries( _rxConnection, UNO_QUERY ); 332 OSL_ENSURE( xSuppQueries.is(), "OSQLParseNode::parseNodeToExecutableStatement: cannot substitute everything without a QueriesSupplier!" ); 333 if ( xSuppQueries.is() ) 334 aParseParam.xQueries = xSuppQueries->getQueries(); 335 } 336 337 aParseParam.pParser = &_rParser; 338 339 _out_rString = ::rtl::OUString(); 340 ::rtl::OUStringBuffer sBuffer; 341 bool bSuccess = false; 342 try 343 { 344 impl_parseNodeToString_throw( sBuffer, aParseParam ); 345 bSuccess = true; 346 } 347 catch( const SQLException& e ) 348 { 349 if ( _pErrorHolder ) 350 *_pErrorHolder = e; 351 } 352 _out_rString = sBuffer.makeStringAndClear(); 353 return bSuccess; 354 } 355 356 //----------------------------------------------------------------------------- 357 namespace 358 { 359 bool lcl_isAliasNamePresent( const OSQLParseNode& _rTableNameNode ) 360 { 361 return OSQLParseNode::getTableRange(_rTableNameNode.getParent()).getLength() != 0; 362 } 363 } 364 365 //----------------------------------------------------------------------------- 366 void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const 367 { 368 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableRange" ); 369 if ( isToken() ) 370 { 371 parseLeaf(rString,rParam); 372 return; 373 } 374 375 // einmal auswerten wieviel Subtrees dieser Knoten besitzt 376 sal_uInt32 nCount = count(); 377 378 bool bHandled = false; 379 switch ( getKnownRuleID() ) 380 { 381 // special handling for parameters 382 case parameter: 383 { 384 if(rString.getLength()) 385 rString.appendAscii(" "); 386 if (nCount == 1) // ? 387 m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); 388 else if (nCount == 2) // :Name 389 { 390 m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); 391 rString.append(m_aChildren[1]->m_aNodeValue); 392 } // [Name] 393 else 394 { 395 m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); 396 rString.append(m_aChildren[1]->m_aNodeValue); 397 rString.append(m_aChildren[2]->m_aNodeValue); 398 } 399 bHandled = true; 400 } 401 break; 402 403 // table refs 404 case table_ref: 405 if ( ( nCount == 2 ) || ( nCount == 3 ) || ( nCount == 5 ) ) 406 { 407 impl_parseTableRangeNodeToString_throw( rString, rParam ); 408 bHandled = true; 409 } 410 break; 411 412 // table name - might be a query name 413 case table_name: 414 bHandled = impl_parseTableNameNodeToString_throw( rString, rParam ); 415 break; 416 417 case as: 418 if ( rParam.aMetaData.generateASBeforeCorrelationName() ) 419 rString.append(::rtl::OUString::createFromAscii( " AS" )); 420 bHandled = true; 421 break; 422 423 case like_predicate: 424 // je nachdem ob international angegeben wird oder nicht wird like anders behandelt 425 // interanational: *, ? sind Platzhalter 426 // sonst SQL92 konform: %, _ 427 impl_parseLikeNodeToString_throw( rString, rParam ); 428 bHandled = true; 429 break; 430 431 case general_set_fct: 432 case set_fct_spec: 433 case position_exp: 434 case extract_exp: 435 case length_exp: 436 case char_value_fct: 437 { 438 if (!addDateValue(rString, rParam)) 439 { 440 // Funktionsname nicht quoten 441 SQLParseNodeParameter aNewParam(rParam); 442 aNewParam.bQuote = ( SQL_ISRULE(this,length_exp) || SQL_ISRULE(this,char_value_fct) ); 443 444 m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); 445 aNewParam.bQuote = rParam.bQuote; 446 //aNewParam.bPredicate = sal_False; // disable [ ] around names // look at i73215 447 ::rtl::OUStringBuffer aStringPara; 448 for (sal_uInt32 i=1; i<nCount; i++) 449 { 450 const OSQLParseNode * pSubTree = m_aChildren[i]; 451 if (pSubTree) 452 { 453 pSubTree->impl_parseNodeToString_throw( aStringPara, aNewParam ); 454 455 // bei den CommaListen zwischen alle Subtrees Commas setzen 456 if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i < (nCount - 1))) 457 aStringPara.appendAscii(","); 458 } 459 else 460 i++; 461 } 462 rString.append(aStringPara.makeStringAndClear()); 463 } 464 bHandled = true; 465 } 466 break; 467 default: 468 break; 469 } // switch ( getKnownRuleID() ) 470 471 if ( !bHandled ) 472 { 473 for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); 474 i != m_aChildren.end();) 475 { 476 const OSQLParseNode* pSubTree = *i; 477 if ( !pSubTree ) 478 { 479 ++i; 480 continue; 481 } 482 483 SQLParseNodeParameter aNewParam(rParam); 484 485 // don't replace the field for subqueries 486 if (rParam.xField.is() && SQL_ISRULE(pSubTree,subquery)) 487 aNewParam.xField = NULL; 488 489 // if there is a field given we don't display the fieldname, if there is any 490 if (rParam.xField.is() && SQL_ISRULE(pSubTree,column_ref)) 491 { 492 sal_Bool bFilter = sal_False; 493 // retrieve the fields name 494 ::rtl::OUString aFieldName; 495 try 496 { 497 sal_Int32 nNamePropertyId = PROPERTY_ID_NAME; 498 if ( rParam.xField->getPropertySetInfo()->hasPropertyByName( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_REALNAME ) ) ) 499 nNamePropertyId = PROPERTY_ID_REALNAME; 500 rParam.xField->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( nNamePropertyId ) ) >>= aFieldName; 501 } 502 catch ( Exception& ) 503 { 504 } 505 506 if(pSubTree->count()) 507 { 508 const OSQLParseNode* pCol = pSubTree->m_aChildren[pSubTree->count()-1]; 509 if ( ( SQL_ISRULE(pCol,column_val) 510 && pCol->getChild(0)->getTokenValue().equalsIgnoreAsciiCase(aFieldName) 511 ) 512 || pCol->getTokenValue().equalsIgnoreAsciiCase(aFieldName) 513 ) 514 bFilter = sal_True; 515 } 516 517 // ok we found the field, if the following node is the 518 // comparision operator '=' we filter it as well 519 if (bFilter) 520 { 521 if (SQL_ISRULE(this, comparison_predicate)) 522 { 523 ++i; 524 if(i != m_aChildren.end()) 525 { 526 pSubTree = *i; 527 if (pSubTree && pSubTree->getNodeType() == SQL_NODE_EQUAL) 528 i++; 529 } 530 } 531 else 532 i++; 533 } 534 else 535 { 536 pSubTree->impl_parseNodeToString_throw( rString, aNewParam ); 537 i++; 538 539 // bei den CommaListen zwischen alle Subtrees Commas setzen 540 if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) 541 rString.appendAscii(","); 542 } 543 } 544 else 545 { 546 pSubTree->impl_parseNodeToString_throw( rString, aNewParam ); 547 i++; 548 549 // bei den CommaListen zwischen alle Subtrees Commas setzen 550 if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) 551 { 552 if (SQL_ISRULE(this,value_exp_commalist) && rParam.bPredicate) 553 rString.appendAscii(";"); 554 else 555 rString.appendAscii(","); 556 } 557 } 558 } 559 } 560 } 561 562 //----------------------------------------------------------------------------- 563 bool OSQLParseNode::impl_parseTableNameNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const 564 { 565 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseTableNameNodeToString_throw" ); 566 // is the table_name part of a table_ref? 567 OSL_ENSURE( getParent(), "OSQLParseNode::impl_parseTableNameNodeToString_throw: table_name without parent?" ); 568 if ( !getParent() || ( getParent()->getKnownRuleID() != table_ref ) ) 569 return false; 570 571 // if it's a query, maybe we need to substitute the SQL statement ... 572 if ( !rParam.bParseToSDBCLevel ) 573 return false; 574 575 if ( !rParam.xQueries.is() ) 576 // connection does not support queries in queries, or was no query supplier 577 return false; 578 579 try 580 { 581 ::rtl::OUString sTableOrQueryName( getChild(0)->getTokenValue() ); 582 bool bIsQuery = rParam.xQueries->hasByName( sTableOrQueryName ); 583 if ( !bIsQuery ) 584 return false; 585 586 // avoid recursion (e.g. "foo" defined as "SELECT * FROM bar" and "bar" defined as "SELECT * FROM foo". 587 if ( rParam.pSubQueryHistory->find( sTableOrQueryName ) != rParam.pSubQueryHistory->end() ) 588 { 589 ::rtl::OUString sMessage( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cyclic sub queries" ) ) ); 590 OSL_ENSURE( rParam.pParser, "OSQLParseNode::impl_parseTableNameNodeToString_throw: no parser?" ); 591 if ( rParam.pParser ) 592 { 593 const SQLError& rErrors( rParam.pParser->getErrorHelper() ); 594 rErrors.raiseException( sdb::ErrorCondition::PARSER_CYCLIC_SUB_QUERIES ); 595 } 596 else 597 { 598 SQLError aErrors( ::comphelper::getProcessServiceFactory() ); 599 aErrors.raiseException( sdb::ErrorCondition::PARSER_CYCLIC_SUB_QUERIES ); 600 } 601 } 602 rParam.pSubQueryHistory->insert( sTableOrQueryName ); 603 604 Reference< XPropertySet > xQuery( rParam.xQueries->getByName( sTableOrQueryName ), UNO_QUERY_THROW ); 605 606 // substitute the query name with the constituting command 607 ::rtl::OUString sCommand; 608 OSL_VERIFY( xQuery->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_COMMAND ) ) >>= sCommand ); 609 610 sal_Bool bEscapeProcessing = sal_False; 611 OSL_VERIFY( xQuery->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ) ) >>= bEscapeProcessing ); 612 613 // the query we found here might itself be based on another query, so parse it recursively 614 OSL_ENSURE( rParam.pParser, "OSQLParseNode::impl_parseTableNameNodeToString_throw: cannot analyze sub queries without a parser!" ); 615 if ( bEscapeProcessing && rParam.pParser ) 616 { 617 ::rtl::OUString sError; 618 ::std::auto_ptr< OSQLParseNode > pSubQueryNode( rParam.pParser->parseTree( sError, sCommand, sal_False ) ); 619 if ( pSubQueryNode.get() ) 620 { 621 // parse the sub-select to SDBC level, too 622 ::rtl::OUStringBuffer sSubSelect; 623 pSubQueryNode->impl_parseNodeToString_throw( sSubSelect, rParam ); 624 if ( sSubSelect.getLength() ) 625 sCommand = sSubSelect.makeStringAndClear(); 626 } 627 } 628 629 rString.appendAscii( " ( " ); 630 rString.append(sCommand); 631 rString.appendAscii( " )" ); 632 633 // append the query name as table alias, since it might be referenced in other 634 // parts of the statement - but only if there's no other alias name present 635 if ( !lcl_isAliasNamePresent( *this ) ) 636 { 637 rString.appendAscii( " AS " ); 638 if ( rParam.bQuote ) 639 rString.append(SetQuotation( sTableOrQueryName, 640 rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); 641 } 642 643 // don't forget to remove the query name from the history, else multiple inclusions 644 // won't work 645 // #i69227# / 2006-10-10 / frank.schoenheit@sun.com 646 rParam.pSubQueryHistory->erase( sTableOrQueryName ); 647 648 return true; 649 } 650 catch( const SQLException& ) 651 { 652 throw; 653 } 654 catch( const Exception& ) 655 { 656 DBG_UNHANDLED_EXCEPTION(); 657 } 658 return false; 659 } 660 661 //----------------------------------------------------------------------------- 662 void OSQLParseNode::impl_parseTableRangeNodeToString_throw(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const 663 { 664 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseTableRangeNodeToString_throw" ); 665 OSL_PRECOND( ( count() == 2 ) || ( count() == 3 ) || ( count() == 5 ) ,"Illegal count"); 666 667 // rString += ::rtl::OUString::createFromAscii(" "); 668 ::std::for_each(m_aChildren.begin(),m_aChildren.end(), 669 boost::bind( &OSQLParseNode::impl_parseNodeToString_throw, _1, boost::ref( rString ), boost::cref( rParam ) )); 670 } 671 672 //----------------------------------------------------------------------------- 673 void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const 674 { 675 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseLikeNodeToString_throw" ); 676 OSL_ENSURE(count() == 2,"count != 2: Prepare for GPF"); 677 678 const OSQLParseNode* pEscNode = NULL; 679 const OSQLParseNode* pParaNode = NULL; 680 681 SQLParseNodeParameter aNewParam(rParam); 682 //aNewParam.bQuote = sal_True; // why setting this to true? @see http://www.openoffice.org/issues/show_bug.cgi?id=75557 683 684 // if there is a field given we don't display the fieldname, if there are any 685 sal_Bool bAddName = sal_True; 686 if (rParam.xField.is()) 687 { 688 // retrieve the fields name 689 ::rtl::OUString aFieldName; 690 try 691 { 692 // retrieve the fields name 693 rtl::OUString aString; 694 rParam.xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aString; 695 aFieldName = aString.getStr(); 696 } 697 catch ( Exception& ) 698 { 699 OSL_ENSURE( false, "OSQLParseNode::impl_parseLikeNodeToString_throw Exception occured!" ); 700 } 701 if ( !m_aChildren[0]->isLeaf() ) 702 { 703 const OSQLParseNode* pCol = m_aChildren[0]->getChild(m_aChildren[0]->count()-1); 704 if ((SQL_ISRULE(pCol,column_val) && pCol->getChild(0)->getTokenValue().equalsIgnoreAsciiCase(aFieldName)) || 705 pCol->getTokenValue().equalsIgnoreAsciiCase(aFieldName) ) 706 bAddName = sal_False; 707 } 708 } 709 710 if (bAddName) 711 m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); 712 713 const OSQLParseNode* pPart2 = m_aChildren[1]; 714 pPart2->getChild(0)->impl_parseNodeToString_throw( rString, aNewParam ); 715 pPart2->getChild(1)->impl_parseNodeToString_throw( rString, aNewParam ); 716 pParaNode = pPart2->getChild(2); 717 pEscNode = pPart2->getChild(3); 718 719 if (pParaNode->isToken()) 720 { 721 ::rtl::OUString aStr = ConvertLikeToken(pParaNode, pEscNode, rParam.bInternational); 722 rString.appendAscii(" "); 723 rString.append(SetQuotation(aStr,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'"))); 724 } 725 else 726 pParaNode->impl_parseNodeToString_throw( rString, aNewParam ); 727 728 pEscNode->impl_parseNodeToString_throw( rString, aNewParam ); 729 } 730 731 732 // ----------------------------------------------------------------------------- 733 sal_Bool OSQLParseNode::getTableComponents(const OSQLParseNode* _pTableNode, 734 ::com::sun::star::uno::Any &_rCatalog, 735 ::rtl::OUString &_rSchema, 736 ::rtl::OUString &_rTable, 737 const Reference< XDatabaseMetaData >& _xMetaData) 738 { 739 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableComponents" ); 740 OSL_ENSURE(_pTableNode,"Wrong use of getTableComponents! _pTableNode is not allowed to be null!"); 741 if(_pTableNode) 742 { 743 const sal_Bool bSupportsCatalog = _xMetaData.is() && _xMetaData->supportsCatalogsInDataManipulation(); 744 const sal_Bool bSupportsSchema = _xMetaData.is() && _xMetaData->supportsSchemasInDataManipulation(); 745 const OSQLParseNode* pTableNode = _pTableNode; 746 // clear the parameter given 747 _rCatalog = Any(); 748 _rSchema = _rTable = ::rtl::OUString(); 749 // see rule catalog_name: in sqlbison.y 750 if (SQL_ISRULE(pTableNode,catalog_name)) 751 { 752 OSL_ENSURE(pTableNode->getChild(0) && pTableNode->getChild(0)->isToken(),"Invalid parsenode!"); 753 _rCatalog <<= pTableNode->getChild(0)->getTokenValue(); 754 pTableNode = pTableNode->getChild(2); 755 } 756 // check if we have schema_name rule 757 if(SQL_ISRULE(pTableNode,schema_name)) 758 { 759 if ( bSupportsCatalog && !bSupportsSchema ) 760 _rCatalog <<= pTableNode->getChild(0)->getTokenValue(); 761 else 762 _rSchema = pTableNode->getChild(0)->getTokenValue(); 763 pTableNode = pTableNode->getChild(2); 764 } 765 // check if we have table_name rule 766 if(SQL_ISRULE(pTableNode,table_name)) 767 { 768 _rTable = pTableNode->getChild(0)->getTokenValue(); 769 } 770 else 771 { 772 OSL_ENSURE(0,"Error in parse tree!"); 773 } 774 } 775 return _rTable.getLength() != 0; 776 } 777 // ----------------------------------------------------------------------------- 778 void OSQLParser::killThousandSeparator(OSQLParseNode* pLiteral) 779 { 780 if ( pLiteral ) 781 { 782 if ( s_xLocaleData->getLocaleItem( m_pData->aLocale ).decimalSeparator.toChar() == ',' ) 783 { 784 pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace('.', sal_Unicode()); 785 // and replace decimal 786 pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace(',', '.'); 787 } 788 else 789 pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace(',', sal_Unicode()); 790 } 791 } 792 // ----------------------------------------------------------------------------- 793 OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral) 794 { 795 if ( !pLiteral ) 796 return NULL; 797 798 OSQLParseNode* pReturn = pLiteral; 799 800 if ( ( pLiteral->isRule() && !SQL_ISRULE(pLiteral,value_exp) ) || SQL_ISTOKEN(pLiteral,FALSE) || SQL_ISTOKEN(pLiteral,TRUE) ) 801 { 802 switch(nType) 803 { 804 case DataType::CHAR: 805 case DataType::VARCHAR: 806 case DataType::LONGVARCHAR: 807 case DataType::CLOB: 808 if ( !SQL_ISRULE(pReturn,char_value_exp) && !buildStringNodes(pReturn) ) 809 pReturn = NULL; 810 default: 811 break; 812 } 813 } 814 else 815 { 816 switch(pLiteral->getNodeType()) 817 { 818 case SQL_NODE_STRING: 819 switch(nType) 820 { 821 case DataType::CHAR: 822 case DataType::VARCHAR: 823 case DataType::LONGVARCHAR: 824 case DataType::CLOB: 825 break; 826 case DataType::DATE: 827 case DataType::TIME: 828 case DataType::TIMESTAMP: 829 if (m_xFormatter.is()) 830 pReturn = buildDate( nType, pReturn); 831 break; 832 default: 833 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); 834 break; 835 } 836 break; 837 case SQL_NODE_ACCESS_DATE: 838 switch(nType) 839 { 840 case DataType::DATE: 841 case DataType::TIME: 842 case DataType::TIMESTAMP: 843 if ( m_xFormatter.is() ) 844 pReturn = buildDate( nType, pReturn); 845 else 846 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_DATE_COMPARE); 847 break; 848 default: 849 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); 850 break; 851 } 852 break; 853 case SQL_NODE_INTNUM: 854 switch(nType) 855 { 856 case DataType::BIT: 857 case DataType::BOOLEAN: 858 case DataType::DECIMAL: 859 case DataType::NUMERIC: 860 case DataType::TINYINT: 861 case DataType::SMALLINT: 862 case DataType::INTEGER: 863 case DataType::BIGINT: 864 case DataType::FLOAT: 865 case DataType::REAL: 866 case DataType::DOUBLE: 867 // kill thousand seperators if any 868 killThousandSeparator(pReturn); 869 break; 870 case DataType::CHAR: 871 case DataType::VARCHAR: 872 case DataType::LONGVARCHAR: 873 case DataType::CLOB: 874 pReturn = buildNode_STR_NUM(pReturn); 875 break; 876 default: 877 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_INT_COMPARE); 878 break; 879 } 880 break; 881 case SQL_NODE_APPROXNUM: 882 switch(nType) 883 { 884 case DataType::DECIMAL: 885 case DataType::NUMERIC: 886 case DataType::FLOAT: 887 case DataType::REAL: 888 case DataType::DOUBLE: 889 // kill thousand seperators if any 890 killThousandSeparator(pReturn); 891 break; 892 case DataType::CHAR: 893 case DataType::VARCHAR: 894 case DataType::LONGVARCHAR: 895 case DataType::CLOB: 896 pReturn = buildNode_STR_NUM(pReturn); 897 break; 898 case DataType::INTEGER: 899 default: 900 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_REAL_COMPARE); 901 break; 902 } 903 break; 904 default: 905 ; 906 } 907 } 908 return pReturn; 909 } 910 // ----------------------------------------------------------------------------- 911 sal_Int16 OSQLParser::buildPredicateRule(OSQLParseNode*& pAppend,OSQLParseNode* pLiteral,OSQLParseNode*& pCompare,OSQLParseNode* pLiteral2) 912 { 913 OSL_ENSURE(inPredicateCheck(),"Only in predicate check allowed!"); 914 sal_Int16 nErg = 0; 915 if ( m_xField.is() ) 916 { 917 sal_Int32 nType = 0; 918 try 919 { 920 m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType; 921 } 922 catch( Exception& ) 923 { 924 return nErg; 925 } 926 927 OSQLParseNode* pNode1 = convertNode(nType,pLiteral); 928 if ( pNode1 ) 929 { 930 OSQLParseNode* pNode2 = convertNode(nType,pLiteral2); 931 if ( !m_sErrorMessage.getLength() ) 932 nErg = buildNode(pAppend,pCompare,pNode1,pNode2); 933 } 934 } 935 if (!pCompare->getParent()) // I have no parent so I was not used and I must die :-) 936 delete pCompare; 937 return nErg; 938 } 939 // ----------------------------------------------------------------------------- 940 sal_Int16 OSQLParser::buildLikeRule(OSQLParseNode*& pAppend, OSQLParseNode*& pLiteral, const OSQLParseNode* pEscape) 941 { 942 sal_Int16 nErg = 0; 943 sal_Int32 nType = 0; 944 945 if (!m_xField.is()) 946 return nErg; 947 try 948 { 949 Any aValue; 950 { 951 aValue = m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)); 952 aValue >>= nType; 953 } 954 } 955 catch( Exception& ) 956 { 957 return nErg; 958 } 959 960 switch (nType) 961 { 962 case DataType::CHAR: 963 case DataType::VARCHAR: 964 case DataType::LONGVARCHAR: 965 case DataType::CLOB: 966 if(pLiteral->isRule()) 967 { 968 pAppend->append(pLiteral); 969 nErg = 1; 970 } 971 else 972 { 973 switch(pLiteral->getNodeType()) 974 { 975 case SQL_NODE_STRING: 976 pLiteral->m_aNodeValue = ConvertLikeToken(pLiteral, pEscape, sal_False); 977 pAppend->append(pLiteral); 978 nErg = 1; 979 break; 980 case SQL_NODE_APPROXNUM: 981 if (m_xFormatter.is() && m_nFormatKey) 982 { 983 sal_Int16 nScale = 0; 984 try 985 { 986 Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, ::rtl::OUString::createFromAscii("Decimals") ); 987 aValue >>= nScale; 988 } 989 catch( Exception& ) 990 { 991 } 992 993 pAppend->append(new OSQLInternalNode(stringToDouble(pLiteral->getTokenValue(),nScale),SQL_NODE_STRING)); 994 } 995 else 996 pAppend->append(new OSQLInternalNode(pLiteral->getTokenValue(),SQL_NODE_STRING)); 997 998 delete pLiteral; 999 nErg = 1; 1000 break; 1001 default: 1002 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_VALUE_NO_LIKE); 1003 m_sErrorMessage = m_sErrorMessage.replaceAt(m_sErrorMessage.indexOf(::rtl::OUString::createFromAscii("#1")),2,pLiteral->getTokenValue()); 1004 break; 1005 } 1006 } 1007 break; 1008 default: 1009 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_FIELD_NO_LIKE); 1010 break; 1011 } 1012 return nErg; 1013 } 1014 //----------------------------------------------------------------------------- 1015 OSQLParseNode* OSQLParser::buildNode_Date(const double& fValue, sal_Int32 nType) 1016 { 1017 ::rtl::OUString aEmptyString; 1018 OSQLParseNode* pNewNode = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::set_fct_spec)); 1019 pNewNode->append(new OSQLInternalNode(::rtl::OUString::createFromAscii("{"), SQL_NODE_PUNCTUATION)); 1020 OSQLParseNode* pDateNode = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::odbc_fct_spec)); 1021 pNewNode->append(pDateNode); 1022 pNewNode->append(new OSQLInternalNode(::rtl::OUString::createFromAscii("}"), SQL_NODE_PUNCTUATION)); 1023 1024 switch (nType) 1025 { 1026 case DataType::DATE: 1027 { 1028 Date aDate = DBTypeConversion::toDate(fValue,DBTypeConversion::getNULLDate(m_xFormatter->getNumberFormatsSupplier())); 1029 ::rtl::OUString aString = DBTypeConversion::toDateString(aDate); 1030 pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_D)); 1031 pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); 1032 break; 1033 } 1034 case DataType::TIME: 1035 { 1036 Time aTime = DBTypeConversion::toTime(fValue); 1037 ::rtl::OUString aString = DBTypeConversion::toTimeString(aTime); 1038 pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_T)); 1039 pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); 1040 break; 1041 } 1042 case DataType::TIMESTAMP: 1043 { 1044 DateTime aDateTime = DBTypeConversion::toDateTime(fValue,DBTypeConversion::getNULLDate(m_xFormatter->getNumberFormatsSupplier())); 1045 if (aDateTime.Seconds || aDateTime.Minutes || aDateTime.Hours) 1046 { 1047 ::rtl::OUString aString = DBTypeConversion::toDateTimeString(aDateTime); 1048 pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_TS)); 1049 pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); 1050 } 1051 else 1052 { 1053 Date aDate(aDateTime.Day,aDateTime.Month,aDateTime.Year); 1054 pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_D)); 1055 pDateNode->append(new OSQLInternalNode(DBTypeConversion::toDateString(aDate), SQL_NODE_STRING)); 1056 } 1057 break; 1058 } 1059 } 1060 1061 return pNewNode; 1062 } 1063 // ----------------------------------------------------------------------------- 1064 OSQLParseNode* OSQLParser::buildNode_STR_NUM(OSQLParseNode*& _pLiteral) 1065 { 1066 OSQLParseNode* pReturn = NULL; 1067 if ( _pLiteral ) 1068 { 1069 if (m_nFormatKey) 1070 { 1071 sal_Int16 nScale = 0; 1072 ::rtl::OUString aDec; 1073 try 1074 { 1075 Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Decimals")) ); 1076 aValue >>= nScale; 1077 } 1078 catch( Exception& ) 1079 { 1080 } 1081 1082 pReturn = new OSQLInternalNode(stringToDouble(_pLiteral->getTokenValue(),nScale),SQL_NODE_STRING); 1083 } 1084 else 1085 pReturn = new OSQLInternalNode(_pLiteral->getTokenValue(),SQL_NODE_STRING); 1086 1087 delete _pLiteral; 1088 _pLiteral = NULL; 1089 } 1090 return pReturn; 1091 } 1092 // ----------------------------------------------------------------------------- 1093 ::rtl::OUString OSQLParser::stringToDouble(const ::rtl::OUString& _rValue,sal_Int16 _nScale) 1094 { 1095 ::rtl::OUString aValue; 1096 if(!m_xCharClass.is()) 1097 m_xCharClass = Reference<XCharacterClassification>(m_xServiceFactory->createInstance(::rtl::OUString::createFromAscii("com.sun.star.i18n.CharacterClassification")),UNO_QUERY); 1098 if(m_xCharClass.is() && s_xLocaleData.is()) 1099 { 1100 try 1101 { 1102 ParseResult aResult = m_xCharClass->parsePredefinedToken(KParseType::ANY_NUMBER,_rValue,0,m_pData->aLocale,0,::rtl::OUString(),KParseType::ANY_NUMBER,::rtl::OUString()); 1103 if((aResult.TokenType & KParseType::IDENTNAME) && aResult.EndPos == _rValue.getLength()) 1104 { 1105 aValue = ::rtl::OUString::valueOf(aResult.Value); 1106 sal_Int32 nPos = aValue.lastIndexOf(::rtl::OUString::createFromAscii(".")); 1107 if((nPos+_nScale) < aValue.getLength()) 1108 aValue = aValue.replaceAt(nPos+_nScale,aValue.getLength()-nPos-_nScale,::rtl::OUString()); 1109 aValue = aValue.replaceAt(aValue.lastIndexOf(::rtl::OUString::createFromAscii(".")),1,s_xLocaleData->getLocaleItem(m_pData->aLocale).decimalSeparator); 1110 return aValue; 1111 } 1112 } 1113 catch(Exception&) 1114 { 1115 } 1116 } 1117 return aValue; 1118 } 1119 // ----------------------------------------------------------------------------- 1120 1121 ::osl::Mutex& OSQLParser::getMutex() 1122 { 1123 static ::osl::Mutex aMutex; 1124 return aMutex; 1125 } 1126 1127 //----------------------------------------------------------------------------- 1128 OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const ::rtl::OUString& rStatement, 1129 const Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter, 1130 const Reference< XPropertySet > & xField) 1131 { 1132 1133 1134 // mutex for parsing 1135 static ::osl::Mutex aMutex; 1136 1137 // Guard the parsing 1138 ::osl::MutexGuard aGuard(getMutex()); 1139 // must be reset 1140 setParser(this); 1141 1142 1143 // reset the parser 1144 m_xField = xField; 1145 m_xFormatter = xFormatter; 1146 1147 if (m_xField.is()) 1148 { 1149 sal_Int32 nType=0; 1150 try 1151 { 1152 // get the field name 1153 rtl::OUString aString; 1154 1155 // retrieve the fields name 1156 // #75243# use the RealName of the column if there is any otherwise the name which could be the alias 1157 // of the field 1158 Reference< XPropertySetInfo> xInfo = m_xField->getPropertySetInfo(); 1159 if ( xInfo->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME))) 1160 m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME)) >>= aString; 1161 else 1162 m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aString; 1163 1164 m_sFieldName = aString; 1165 1166 // get the field format key 1167 if ( xInfo->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY))) 1168 m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY)) >>= m_nFormatKey; 1169 else 1170 m_nFormatKey = 0; 1171 1172 // get the field type 1173 m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType; 1174 } 1175 catch ( Exception& ) 1176 { 1177 OSL_ASSERT(0); 1178 } 1179 1180 if (m_nFormatKey && m_xFormatter.is()) 1181 { 1182 Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_LOCALE) ); 1183 OSL_ENSURE(aValue.getValueType() == ::getCppuType((const ::com::sun::star::lang::Locale*)0), "OSQLParser::PredicateTree : invalid language property !"); 1184 1185 if (aValue.getValueType() == ::getCppuType((const ::com::sun::star::lang::Locale*)0)) 1186 aValue >>= m_pData->aLocale; 1187 } 1188 else 1189 m_pData->aLocale = m_pContext->getPreferredLocale(); 1190 1191 if ( m_xFormatter.is() ) 1192 { 1193 try 1194 { 1195 Reference< ::com::sun::star::util::XNumberFormatsSupplier > xFormatSup = m_xFormatter->getNumberFormatsSupplier(); 1196 if ( xFormatSup.is() ) 1197 { 1198 Reference< ::com::sun::star::util::XNumberFormats > xFormats = xFormatSup->getNumberFormats(); 1199 if ( xFormats.is() ) 1200 { 1201 ::com::sun::star::lang::Locale aLocale; 1202 aLocale.Language = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("en")); 1203 aLocale.Country = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("US")); 1204 ::rtl::OUString sFormat(RTL_CONSTASCII_USTRINGPARAM("YYYY-MM-DD")); 1205 m_nDateFormatKey = xFormats->queryKey(sFormat,aLocale,sal_False); 1206 if ( m_nDateFormatKey == sal_Int32(-1) ) 1207 m_nDateFormatKey = xFormats->addNew(sFormat, aLocale); 1208 } 1209 } 1210 } 1211 catch ( Exception& ) 1212 { 1213 OSL_ENSURE(0,"DateFormatKey"); 1214 } 1215 } 1216 1217 switch (nType) 1218 { 1219 case DataType::DATE: 1220 case DataType::TIME: 1221 case DataType::TIMESTAMP: 1222 s_pScanner->SetRule(s_pScanner->GetDATERule()); 1223 break; 1224 case DataType::CHAR: 1225 case DataType::VARCHAR: 1226 case DataType::LONGVARCHAR: 1227 case DataType::CLOB: 1228 s_pScanner->SetRule(s_pScanner->GetSTRINGRule()); 1229 break; 1230 default: 1231 if ( s_xLocaleData->getLocaleItem( m_pData->aLocale ).decimalSeparator.toChar() == ',' ) 1232 s_pScanner->SetRule(s_pScanner->GetGERRule()); 1233 else 1234 s_pScanner->SetRule(s_pScanner->GetENGRule()); 1235 } 1236 1237 } 1238 else 1239 s_pScanner->SetRule(s_pScanner->GetSQLRule()); 1240 1241 s_pScanner->prepareScan(rStatement, m_pContext, sal_True); 1242 1243 SQLyylval.pParseNode = NULL; 1244 // SQLyypvt = NULL; 1245 m_pParseTree = NULL; 1246 m_sErrorMessage= ::rtl::OUString(); 1247 1248 // ... und den Parser anwerfen ... 1249 if (SQLyyparse() != 0) 1250 { 1251 m_sFieldName= ::rtl::OUString(); 1252 m_xField.clear(); 1253 m_xFormatter.clear(); 1254 m_nFormatKey = 0; 1255 m_nDateFormatKey = 0; 1256 1257 if (!m_sErrorMessage.getLength()) 1258 m_sErrorMessage = s_pScanner->getErrorMessage(); 1259 if (!m_sErrorMessage.getLength()) 1260 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_GENERAL); 1261 1262 rErrorMessage = m_sErrorMessage; 1263 1264 // clear the garbage collector 1265 (*s_pGarbageCollector)->clearAndDelete(); 1266 return NULL; 1267 } 1268 else 1269 { 1270 (*s_pGarbageCollector)->clear(); 1271 1272 m_sFieldName= ::rtl::OUString(); 1273 m_xField.clear(); 1274 m_xFormatter.clear(); 1275 m_nFormatKey = 0; 1276 m_nDateFormatKey = 0; 1277 1278 // Das Ergebnis liefern (den Root Parse Node): 1279 1280 // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree 1281 // - einfach diesen zurueckliefern: 1282 OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert"); 1283 return m_pParseTree; 1284 } 1285 } 1286 1287 //============================================================================= 1288 //----------------------------------------------------------------------------- 1289 OSQLParser::OSQLParser(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _xServiceFactory,const IParseContext* _pContext) 1290 :m_pContext(_pContext) 1291 ,m_pParseTree(NULL) 1292 ,m_pData( new OSQLParser_Data( _xServiceFactory ) ) 1293 ,m_nFormatKey(0) 1294 ,m_nDateFormatKey(0) 1295 ,m_xServiceFactory(_xServiceFactory) 1296 { 1297 1298 1299 setParser(this); 1300 1301 #ifdef SQLYYDEBUG 1302 #ifdef SQLYYDEBUG_ON 1303 SQLyydebug = 1; 1304 #endif 1305 #endif 1306 1307 ::osl::MutexGuard aGuard(getMutex()); 1308 // do we have to initialize the data 1309 if (s_nRefCount == 0) 1310 { 1311 s_pScanner = new OSQLScanner(); 1312 s_pScanner->setScanner(); 1313 s_pGarbageCollector = new OSQLParseNodesGarbageCollector(); 1314 1315 if(!s_xLocaleData.is()) 1316 s_xLocaleData = Reference<XLocaleData>(m_xServiceFactory->createInstance(::rtl::OUString::createFromAscii("com.sun.star.i18n.LocaleData")),UNO_QUERY); 1317 1318 // auf 0 zuruecksetzen 1319 memset(OSQLParser::s_nRuleIDs,0,sizeof(OSQLParser::s_nRuleIDs[0]) * (OSQLParseNode::rule_count+1)); 1320 1321 struct 1322 { 1323 OSQLParseNode::Rule eRule; // the parse node's ID for the rule 1324 ::rtl::OString sRuleName; // the name of the rule ("select_statement") 1325 } aRuleDescriptions[] = 1326 { 1327 { OSQLParseNode::select_statement, "select_statement" }, 1328 { OSQLParseNode::table_exp, "table_exp" }, 1329 { OSQLParseNode::table_ref_commalist, "table_ref_commalist" }, 1330 { OSQLParseNode::table_ref, "table_ref" }, 1331 { OSQLParseNode::catalog_name, "catalog_name" }, 1332 { OSQLParseNode::schema_name, "schema_name" }, 1333 { OSQLParseNode::table_name, "table_name" }, 1334 { OSQLParseNode::opt_column_commalist, "opt_column_commalist" }, 1335 { OSQLParseNode::column_commalist, "column_commalist" }, 1336 { OSQLParseNode::column_ref_commalist, "column_ref_commalist" }, 1337 { OSQLParseNode::column_ref, "column_ref" }, 1338 { OSQLParseNode::opt_order_by_clause, "opt_order_by_clause" }, 1339 { OSQLParseNode::ordering_spec_commalist, "ordering_spec_commalist" }, 1340 { OSQLParseNode::ordering_spec, "ordering_spec" }, 1341 { OSQLParseNode::opt_asc_desc, "opt_asc_desc" }, 1342 { OSQLParseNode::where_clause, "where_clause" }, 1343 { OSQLParseNode::opt_where_clause, "opt_where_clause" }, 1344 { OSQLParseNode::search_condition, "search_condition" }, 1345 { OSQLParseNode::comparison_predicate, "comparison_predicate" }, 1346 { OSQLParseNode::between_predicate, "between_predicate" }, 1347 { OSQLParseNode::like_predicate, "like_predicate" }, 1348 { OSQLParseNode::opt_escape, "opt_escape" }, 1349 { OSQLParseNode::test_for_null, "test_for_null" }, 1350 { OSQLParseNode::scalar_exp_commalist, "scalar_exp_commalist" }, 1351 { OSQLParseNode::scalar_exp, "scalar_exp" }, 1352 { OSQLParseNode::parameter_ref, "parameter_ref" }, 1353 { OSQLParseNode::parameter, "parameter" }, 1354 { OSQLParseNode::general_set_fct, "general_set_fct" }, 1355 { OSQLParseNode::range_variable, "range_variable" }, 1356 { OSQLParseNode::column, "column" }, 1357 { OSQLParseNode::delete_statement_positioned, "delete_statement_positioned" }, 1358 { OSQLParseNode::delete_statement_searched, "delete_statement_searched" }, 1359 { OSQLParseNode::update_statement_positioned, "update_statement_positioned" }, 1360 { OSQLParseNode::update_statement_searched, "update_statement_searched" }, 1361 { OSQLParseNode::assignment_commalist, "assignment_commalist" }, 1362 { OSQLParseNode::assignment, "assignment" }, 1363 { OSQLParseNode::values_or_query_spec, "values_or_query_spec" }, 1364 { OSQLParseNode::insert_statement, "insert_statement" }, 1365 { OSQLParseNode::insert_atom_commalist, "insert_atom_commalist" }, 1366 { OSQLParseNode::insert_atom, "insert_atom" }, 1367 { OSQLParseNode::predicate_check, "predicate_check" }, 1368 { OSQLParseNode::from_clause, "from_clause" }, 1369 { OSQLParseNode::qualified_join, "qualified_join" }, 1370 { OSQLParseNode::cross_union, "cross_union" }, 1371 { OSQLParseNode::select_sublist, "select_sublist" }, 1372 { OSQLParseNode::derived_column, "derived_column" }, 1373 { OSQLParseNode::column_val, "column_val" }, 1374 { OSQLParseNode::set_fct_spec, "set_fct_spec" }, 1375 { OSQLParseNode::boolean_term, "boolean_term" }, 1376 { OSQLParseNode::boolean_primary, "boolean_primary" }, 1377 { OSQLParseNode::num_value_exp, "num_value_exp" }, 1378 { OSQLParseNode::join_type, "join_type" }, 1379 { OSQLParseNode::position_exp, "position_exp" }, 1380 { OSQLParseNode::extract_exp, "extract_exp" }, 1381 { OSQLParseNode::length_exp, "length_exp" }, 1382 { OSQLParseNode::char_value_fct, "char_value_fct" }, 1383 { OSQLParseNode::odbc_call_spec, "odbc_call_spec" }, 1384 { OSQLParseNode::in_predicate, "in_predicate" }, 1385 { OSQLParseNode::existence_test, "existence_test" }, 1386 { OSQLParseNode::unique_test, "unique_test" }, 1387 { OSQLParseNode::all_or_any_predicate, "all_or_any_predicate" }, 1388 { OSQLParseNode::named_columns_join, "named_columns_join" }, 1389 { OSQLParseNode::join_condition, "join_condition" }, 1390 { OSQLParseNode::joined_table, "joined_table" }, 1391 { OSQLParseNode::boolean_factor, "boolean_factor" }, 1392 { OSQLParseNode::sql_not, "sql_not" }, 1393 { OSQLParseNode::boolean_test, "boolean_test" }, 1394 { OSQLParseNode::manipulative_statement, "manipulative_statement" }, 1395 { OSQLParseNode::subquery, "subquery" }, 1396 { OSQLParseNode::value_exp_commalist, "value_exp_commalist" }, 1397 { OSQLParseNode::odbc_fct_spec, "odbc_fct_spec" }, 1398 { OSQLParseNode::union_statement, "union_statement" }, 1399 { OSQLParseNode::outer_join_type, "outer_join_type" }, 1400 { OSQLParseNode::char_value_exp, "char_value_exp" }, 1401 { OSQLParseNode::term, "term" }, 1402 { OSQLParseNode::value_exp_primary, "value_exp_primary" }, 1403 { OSQLParseNode::value_exp, "value_exp" }, 1404 { OSQLParseNode::selection, "selection" }, 1405 { OSQLParseNode::fold, "fold" }, 1406 { OSQLParseNode::char_substring_fct, "char_substring_fct" }, 1407 { OSQLParseNode::factor, "factor" }, 1408 { OSQLParseNode::base_table_def, "base_table_def" }, 1409 { OSQLParseNode::base_table_element_commalist, "base_table_element_commalist" }, 1410 { OSQLParseNode::data_type, "data_type" }, 1411 { OSQLParseNode::column_def, "column_def" }, 1412 { OSQLParseNode::table_node, "table_node" }, 1413 { OSQLParseNode::as, "as" }, 1414 { OSQLParseNode::op_column_commalist, "op_column_commalist" }, 1415 { OSQLParseNode::table_primary_as_range_column, "table_primary_as_range_column" }, 1416 { OSQLParseNode::datetime_primary, "datetime_primary" }, 1417 { OSQLParseNode::concatenation, "concatenation" }, 1418 { OSQLParseNode::char_factor, "char_factor" }, 1419 { OSQLParseNode::bit_value_fct, "bit_value_fct" }, 1420 { OSQLParseNode::comparison_predicate_part_2, "comparison_predicate_part_2" }, 1421 { OSQLParseNode::parenthesized_boolean_value_expression, "parenthesized_boolean_value_expression" }, 1422 { OSQLParseNode::character_string_type, "character_string_type" }, 1423 { OSQLParseNode::other_like_predicate_part_2, "other_like_predicate_part_2" }, 1424 { OSQLParseNode::between_predicate_part_2, "between_predicate_part_2" }, 1425 { OSQLParseNode::cast_spec, "cast_spec" } 1426 }; 1427 size_t nRuleMapCount = sizeof( aRuleDescriptions ) / sizeof( aRuleDescriptions[0] ); 1428 OSL_ENSURE( nRuleMapCount == size_t( OSQLParseNode::rule_count ), "OSQLParser::OSQLParser: added a new rule? Adjust this map!" ); 1429 1430 for ( size_t mapEntry = 0; mapEntry < nRuleMapCount; ++mapEntry ) 1431 { 1432 // look up the rule description in the our identifier map 1433 sal_uInt32 nParserRuleID = StrToRuleID( aRuleDescriptions[ mapEntry ].sRuleName ); 1434 // map the parser's rule ID to the OSQLParseNode::Rule 1435 s_aReverseRuleIDLookup[ nParserRuleID ] = aRuleDescriptions[ mapEntry ].eRule; 1436 // and map the OSQLParseNode::Rule to the parser's rule ID 1437 s_nRuleIDs[ aRuleDescriptions[ mapEntry ].eRule ] = nParserRuleID; 1438 } 1439 } 1440 ++s_nRefCount; 1441 1442 if (m_pContext == NULL) 1443 // take the default context 1444 m_pContext = &s_aDefaultContext; 1445 1446 m_pData->aLocale = m_pContext->getPreferredLocale(); 1447 } 1448 1449 //----------------------------------------------------------------------------- 1450 OSQLParser::~OSQLParser() 1451 { 1452 { 1453 ::osl::MutexGuard aGuard(getMutex()); 1454 OSL_ENSURE(s_nRefCount > 0, "OSQLParser::~OSQLParser() : suspicious call : have a refcount of 0 !"); 1455 if (!--s_nRefCount) 1456 { 1457 s_pScanner->setScanner(sal_True); 1458 delete s_pScanner; 1459 s_pScanner = NULL; 1460 1461 delete s_pGarbageCollector; 1462 s_pGarbageCollector = NULL; 1463 // is only set the first time so we should delete it only when there no more instances 1464 s_xLocaleData = NULL; 1465 1466 RuleIDMap aEmpty; 1467 s_aReverseRuleIDLookup.swap( aEmpty ); 1468 } 1469 m_pParseTree = NULL; 1470 } 1471 } 1472 // ----------------------------------------------------------------------------- 1473 void OSQLParseNode::substituteParameterNames(OSQLParseNode* _pNode) 1474 { 1475 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::substituteParameterNames" ); 1476 sal_Int32 nCount = _pNode->count(); 1477 for(sal_Int32 i=0;i < nCount;++i) 1478 { 1479 OSQLParseNode* pChildNode = _pNode->getChild(i); 1480 if(SQL_ISRULE(pChildNode,parameter) && pChildNode->count() > 1) 1481 { 1482 OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString::createFromAscii("?") ,SQL_NODE_PUNCTUATION,0); 1483 delete pChildNode->replace(pChildNode->getChild(0),pNewNode); 1484 sal_Int32 nChildCount = pChildNode->count(); 1485 for(sal_Int32 j=1;j < nChildCount;++j) 1486 delete pChildNode->removeAt(1); 1487 } 1488 else 1489 substituteParameterNames(pChildNode); 1490 1491 } 1492 } 1493 // ----------------------------------------------------------------------------- 1494 bool OSQLParser::extractDate(OSQLParseNode* pLiteral,double& _rfValue) 1495 { 1496 Reference< XNumberFormatsSupplier > xFormatSup = m_xFormatter->getNumberFormatsSupplier(); 1497 Reference< XNumberFormatTypes > xFormatTypes; 1498 if ( xFormatSup.is() ) 1499 xFormatTypes = xFormatTypes.query( xFormatSup->getNumberFormats() ); 1500 1501 // if there is no format key, yet, make sure we have a feasible one for our locale 1502 try 1503 { 1504 if ( !m_nFormatKey && xFormatTypes.is() ) 1505 m_nFormatKey = ::dbtools::getDefaultNumberFormat( m_xField, xFormatTypes, m_pData->aLocale ); 1506 } 1507 catch( Exception& ) { } 1508 ::rtl::OUString sValue = pLiteral->getTokenValue(); 1509 sal_Int32 nTryFormat = m_nFormatKey; 1510 bool bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); 1511 1512 // If our format key didn't do, try the default date format for our locale. 1513 if ( !bSuccess && xFormatTypes.is() ) 1514 { 1515 try 1516 { 1517 nTryFormat = xFormatTypes->getStandardFormat( NumberFormat::DATE, m_pData->aLocale ); 1518 } 1519 catch( Exception& ) { } 1520 bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); 1521 } 1522 1523 // if this also didn't do, try ISO format 1524 if ( !bSuccess && xFormatTypes.is() ) 1525 { 1526 try 1527 { 1528 nTryFormat = xFormatTypes->getFormatIndex( NumberFormatIndex::DATE_DIN_YYYYMMDD, m_pData->aLocale ); 1529 } 1530 catch( Exception& ) { } 1531 bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); 1532 } 1533 1534 // if this also didn't do, try fallback date format (en-US) 1535 if ( !bSuccess ) 1536 { 1537 nTryFormat = m_nDateFormatKey; 1538 bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); 1539 } 1540 return bSuccess; 1541 } 1542 // ----------------------------------------------------------------------------- 1543 OSQLParseNode* OSQLParser::buildDate(sal_Int32 _nType,OSQLParseNode*& pLiteral) 1544 { 1545 // try converting the string into a date, according to our format key 1546 double fValue = 0.0; 1547 OSQLParseNode* pFCTNode = NULL; 1548 1549 if ( extractDate(pLiteral,fValue) ) 1550 pFCTNode = buildNode_Date( fValue, _nType); 1551 1552 delete pLiteral; 1553 pLiteral = NULL; 1554 1555 if ( !pFCTNode ) 1556 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_DATE_COMPARE); 1557 1558 return pFCTNode; 1559 } 1560 // ----------------------------------------------------------------------------- 1561 //----------------------------------------------------------------------------- 1562 OSQLParseNode::OSQLParseNode(const sal_Char * pNewValue, 1563 SQLNodeType eNewNodeType, 1564 sal_uInt32 nNewNodeID) 1565 :m_pParent(NULL) 1566 ,m_aNodeValue(pNewValue,strlen(pNewValue),RTL_TEXTENCODING_UTF8) 1567 ,m_eNodeType(eNewNodeType) 1568 ,m_nNodeID(nNewNodeID) 1569 { 1570 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); 1571 1572 OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); 1573 } 1574 //----------------------------------------------------------------------------- 1575 OSQLParseNode::OSQLParseNode(const ::rtl::OString &_rNewValue, 1576 SQLNodeType eNewNodeType, 1577 sal_uInt32 nNewNodeID) 1578 :m_pParent(NULL) 1579 ,m_aNodeValue(_rNewValue,_rNewValue.getLength(),RTL_TEXTENCODING_UTF8) 1580 ,m_eNodeType(eNewNodeType) 1581 ,m_nNodeID(nNewNodeID) 1582 { 1583 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); 1584 1585 OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); 1586 } 1587 //----------------------------------------------------------------------------- 1588 OSQLParseNode::OSQLParseNode(const sal_Unicode * pNewValue, 1589 SQLNodeType eNewNodeType, 1590 sal_uInt32 nNewNodeID) 1591 :m_pParent(NULL) 1592 ,m_aNodeValue(pNewValue) 1593 ,m_eNodeType(eNewNodeType) 1594 ,m_nNodeID(nNewNodeID) 1595 { 1596 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); 1597 1598 OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); 1599 } 1600 //----------------------------------------------------------------------------- 1601 OSQLParseNode::OSQLParseNode(const ::rtl::OUString &_rNewValue, 1602 SQLNodeType eNewNodeType, 1603 sal_uInt32 nNewNodeID) 1604 :m_pParent(NULL) 1605 ,m_aNodeValue(_rNewValue) 1606 ,m_eNodeType(eNewNodeType) 1607 ,m_nNodeID(nNewNodeID) 1608 { 1609 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); 1610 1611 OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); 1612 } 1613 //----------------------------------------------------------------------------- 1614 OSQLParseNode::OSQLParseNode(const OSQLParseNode& rParseNode) 1615 { 1616 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); 1617 1618 // klemm den getParent auf NULL 1619 m_pParent = NULL; 1620 1621 // kopiere die member 1622 m_aNodeValue = rParseNode.m_aNodeValue; 1623 m_eNodeType = rParseNode.m_eNodeType; 1624 m_nNodeID = rParseNode.m_nNodeID; 1625 1626 1627 // denk dran, dass von Container abgeleitet wurde, laut SV-Help erzeugt 1628 // copy-Constructor des Containers einen neuen Container mit den gleichen 1629 // Zeigern als Inhalt -> d.h. nach dem Kopieren des Container wird fuer 1630 // alle Zeiger ungleich NULL eine Kopie hergestellt und anstelle des alten 1631 // Zeigers wieder eingehangen. 1632 1633 // wenn kein Blatt, dann SubTrees bearbeiten 1634 for (OSQLParseNodes::const_iterator i = rParseNode.m_aChildren.begin(); 1635 i != rParseNode.m_aChildren.end(); i++) 1636 append(new OSQLParseNode(**i)); 1637 } 1638 // ----------------------------------------------------------------------------- 1639 //----------------------------------------------------------------------------- 1640 OSQLParseNode& OSQLParseNode::operator=(const OSQLParseNode& rParseNode) 1641 { 1642 if (this != &rParseNode) 1643 { 1644 // kopiere die member - pParent bleibt der alte 1645 m_aNodeValue = rParseNode.m_aNodeValue; 1646 m_eNodeType = rParseNode.m_eNodeType; 1647 m_nNodeID = rParseNode.m_nNodeID; 1648 1649 for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); 1650 i != m_aChildren.end(); i++) 1651 delete *i; 1652 1653 m_aChildren.clear(); 1654 1655 for (OSQLParseNodes::const_iterator j = rParseNode.m_aChildren.begin(); 1656 j != rParseNode.m_aChildren.end(); j++) 1657 append(new OSQLParseNode(**j)); 1658 } 1659 return *this; 1660 } 1661 1662 //----------------------------------------------------------------------------- 1663 sal_Bool OSQLParseNode::operator==(OSQLParseNode& rParseNode) const 1664 { 1665 // die member muessen gleich sein 1666 sal_Bool bResult = (m_nNodeID == rParseNode.m_nNodeID) && 1667 (m_eNodeType == rParseNode.m_eNodeType) && 1668 (m_aNodeValue == rParseNode.m_aNodeValue) && 1669 count() == rParseNode.count(); 1670 1671 // Parameters are not equal! 1672 bResult = bResult && !SQL_ISRULE(this, parameter); 1673 1674 // compare childs 1675 for (sal_uInt32 i=0; bResult && i < count(); i++) 1676 bResult = *getChild(i) == *rParseNode.getChild(i); 1677 1678 return bResult; 1679 } 1680 1681 //----------------------------------------------------------------------------- 1682 OSQLParseNode::~OSQLParseNode() 1683 { 1684 for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); 1685 i != m_aChildren.end(); i++) 1686 delete *i; 1687 m_aChildren.clear(); 1688 } 1689 1690 //----------------------------------------------------------------------------- 1691 void OSQLParseNode::append(OSQLParseNode* pNewNode) 1692 { 1693 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::append" ); 1694 1695 OSL_ENSURE(pNewNode != NULL, "OSQLParseNode: ungueltiger NewSubTree"); 1696 OSL_ENSURE(pNewNode->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise"); 1697 OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewNode) == m_aChildren.end(), 1698 "OSQLParseNode::append() Node already element of parent"); 1699 1700 // stelle Verbindung zum getParent her: 1701 pNewNode->setParent( this ); 1702 // und haenge den SubTree hinten an 1703 m_aChildren.push_back(pNewNode); 1704 } 1705 // ----------------------------------------------------------------------------- 1706 sal_Bool OSQLParseNode::addDateValue(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const 1707 { 1708 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::addDateValue" ); 1709 // special display for date/time values 1710 if (SQL_ISRULE(this,set_fct_spec) && SQL_ISPUNCTUATION(m_aChildren[0],"{")) 1711 { 1712 const OSQLParseNode* pODBCNode = m_aChildren[1]; 1713 const OSQLParseNode* pODBCNodeChild = pODBCNode->m_aChildren[0]; 1714 1715 if (pODBCNodeChild->getNodeType() == SQL_NODE_KEYWORD && ( 1716 SQL_ISTOKEN(pODBCNodeChild, D) || 1717 SQL_ISTOKEN(pODBCNodeChild, T) || 1718 SQL_ISTOKEN(pODBCNodeChild, TS) )) 1719 { 1720 ::rtl::OUString suQuote(::rtl::OUString::createFromAscii("'")); 1721 if (rParam.bPredicate) 1722 { 1723 if (rParam.aMetaData.shouldEscapeDateTime()) 1724 { 1725 suQuote = ::rtl::OUString::createFromAscii("#"); 1726 } 1727 } 1728 else 1729 { 1730 if (rParam.aMetaData.shouldEscapeDateTime()) 1731 { 1732 // suQuote = ::rtl::OUString::createFromAscii("'"); 1733 return sal_False; 1734 } 1735 } 1736 1737 if (rString.getLength()) 1738 rString.appendAscii(" "); 1739 rString.append(suQuote); 1740 const ::rtl::OUString sTokenValue = pODBCNode->m_aChildren[1]->getTokenValue(); 1741 if (SQL_ISTOKEN(pODBCNodeChild, D)) 1742 { 1743 rString.append(rParam.bPredicate ? convertDateString(rParam, sTokenValue) : sTokenValue); 1744 } 1745 else if (SQL_ISTOKEN(pODBCNodeChild, T)) 1746 { 1747 rString.append(rParam.bPredicate ? convertTimeString(rParam, sTokenValue) : sTokenValue); 1748 } 1749 else 1750 { 1751 rString.append(rParam.bPredicate ? convertDateTimeString(rParam, sTokenValue) : sTokenValue); 1752 } 1753 rString.append(suQuote); 1754 return sal_True; 1755 } 1756 } 1757 return sal_False; 1758 } 1759 // ----------------------------------------------------------------------------- 1760 void OSQLParseNode::replaceNodeValue(const ::rtl::OUString& rTableAlias,const ::rtl::OUString& rColumnName) 1761 { 1762 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replaceNodeValue" ); 1763 for (sal_uInt32 i=0;i<count();++i) 1764 { 1765 if (SQL_ISRULE(this,column_ref) && count() == 1 && getChild(0)->getTokenValue() == rColumnName) 1766 { 1767 OSQLParseNode * pCol = removeAt((sal_uInt32)0); 1768 append(new OSQLParseNode(rTableAlias,SQL_NODE_NAME)); 1769 append(new OSQLParseNode(::rtl::OUString::createFromAscii("."),SQL_NODE_PUNCTUATION)); 1770 append(pCol); 1771 } 1772 else 1773 getChild(i)->replaceNodeValue(rTableAlias,rColumnName); 1774 } 1775 } 1776 //----------------------------------------------------------------------------- 1777 OSQLParseNode* OSQLParseNode::getByRule(OSQLParseNode::Rule eRule) const 1778 { 1779 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getByRule" ); 1780 OSQLParseNode* pRetNode = 0; 1781 if (isRule() && OSQLParser::RuleID(eRule) == getRuleID()) 1782 pRetNode = (OSQLParseNode*)this; 1783 else 1784 { 1785 for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); 1786 !pRetNode && i != m_aChildren.end(); i++) 1787 pRetNode = (*i)->getByRule(eRule); 1788 } 1789 return pRetNode; 1790 } 1791 //----------------------------------------------------------------------------- 1792 OSQLParseNode* MakeANDNode(OSQLParseNode *pLeftLeaf,OSQLParseNode *pRightLeaf) 1793 { 1794 OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_term)); 1795 pNewNode->append(pLeftLeaf); 1796 pNewNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("AND"),SQL_NODE_KEYWORD,SQL_TOKEN_AND)); 1797 pNewNode->append(pRightLeaf); 1798 return pNewNode; 1799 } 1800 //----------------------------------------------------------------------------- 1801 OSQLParseNode* MakeORNode(OSQLParseNode *pLeftLeaf,OSQLParseNode *pRightLeaf) 1802 { 1803 OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::search_condition)); 1804 pNewNode->append(pLeftLeaf); 1805 pNewNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("OR"),SQL_NODE_KEYWORD,SQL_TOKEN_OR)); 1806 pNewNode->append(pRightLeaf); 1807 return pNewNode; 1808 } 1809 //----------------------------------------------------------------------------- 1810 void OSQLParseNode::disjunctiveNormalForm(OSQLParseNode*& pSearchCondition) 1811 { 1812 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::disjunctiveNormalForm" ); 1813 if(!pSearchCondition) // no where condition at entry point 1814 return; 1815 1816 OSQLParseNode::absorptions(pSearchCondition); 1817 // '(' search_condition ')' 1818 if (SQL_ISRULE(pSearchCondition,boolean_primary)) 1819 { 1820 OSQLParseNode* pLeft = pSearchCondition->getChild(1); 1821 disjunctiveNormalForm(pLeft); 1822 } 1823 // search_condition SQL_TOKEN_OR boolean_term 1824 else if (SQL_ISRULE(pSearchCondition,search_condition)) 1825 { 1826 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 1827 disjunctiveNormalForm(pLeft); 1828 1829 OSQLParseNode* pRight = pSearchCondition->getChild(2); 1830 disjunctiveNormalForm(pRight); 1831 } 1832 // boolean_term SQL_TOKEN_AND boolean_factor 1833 else if (SQL_ISRULE(pSearchCondition,boolean_term)) 1834 { 1835 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 1836 disjunctiveNormalForm(pLeft); 1837 1838 OSQLParseNode* pRight = pSearchCondition->getChild(2); 1839 disjunctiveNormalForm(pRight); 1840 1841 OSQLParseNode* pNewNode = NULL; 1842 // '(' search_condition ')' on left side 1843 if(pLeft->count() == 3 && SQL_ISRULE(pLeft,boolean_primary) && SQL_ISRULE(pLeft->getChild(1),search_condition)) 1844 { 1845 // and-or tree on left side 1846 OSQLParseNode* pOr = pLeft->getChild(1); 1847 OSQLParseNode* pNewLeft = NULL; 1848 OSQLParseNode* pNewRight = NULL; 1849 1850 // cut right from parent 1851 pSearchCondition->removeAt(2); 1852 1853 pNewRight = MakeANDNode(pOr->removeAt(2) ,pRight); 1854 pNewLeft = MakeANDNode(pOr->removeAt((sal_uInt32)0) ,new OSQLParseNode(*pRight)); 1855 pNewNode = MakeORNode(pNewLeft,pNewRight); 1856 // and append new Node 1857 replaceAndReset(pSearchCondition,pNewNode); 1858 1859 disjunctiveNormalForm(pSearchCondition); 1860 } 1861 else if(pRight->count() == 3 && SQL_ISRULE(pRight,boolean_primary) && SQL_ISRULE(pRight->getChild(1),search_condition)) 1862 { // '(' search_condition ')' on right side 1863 // and-or tree on right side 1864 // a and (b or c) 1865 OSQLParseNode* pOr = pRight->getChild(1); 1866 OSQLParseNode* pNewLeft = NULL; 1867 OSQLParseNode* pNewRight = NULL; 1868 1869 // cut left from parent 1870 pSearchCondition->removeAt((sal_uInt32)0); 1871 1872 pNewRight = MakeANDNode(pLeft,pOr->removeAt(2)); 1873 pNewLeft = MakeANDNode(new OSQLParseNode(*pLeft),pOr->removeAt((sal_uInt32)0)); 1874 pNewNode = MakeORNode(pNewLeft,pNewRight); 1875 1876 // and append new Node 1877 replaceAndReset(pSearchCondition,pNewNode); 1878 disjunctiveNormalForm(pSearchCondition); 1879 } 1880 else if(SQL_ISRULE(pLeft,boolean_primary) && (!SQL_ISRULE(pLeft->getChild(1),search_condition) || !SQL_ISRULE(pLeft->getChild(1),boolean_term))) 1881 pSearchCondition->replace(pLeft, pLeft->removeAt(1)); 1882 else if(SQL_ISRULE(pRight,boolean_primary) && (!SQL_ISRULE(pRight->getChild(1),search_condition) || !SQL_ISRULE(pRight->getChild(1),boolean_term))) 1883 pSearchCondition->replace(pRight, pRight->removeAt(1)); 1884 } 1885 } 1886 //----------------------------------------------------------------------------- 1887 void OSQLParseNode::negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_Bool bNegate) 1888 { 1889 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::negateSearchCondition" ); 1890 if(!pSearchCondition) // no where condition at entry point 1891 return; 1892 // '(' search_condition ')' 1893 if (pSearchCondition->count() == 3 && SQL_ISRULE(pSearchCondition,boolean_primary)) 1894 { 1895 OSQLParseNode* pRight = pSearchCondition->getChild(1); 1896 negateSearchCondition(pRight,bNegate); 1897 } 1898 // search_condition SQL_TOKEN_OR boolean_term 1899 else if (SQL_ISRULE(pSearchCondition,search_condition)) 1900 { 1901 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 1902 OSQLParseNode* pRight = pSearchCondition->getChild(2); 1903 if(bNegate) 1904 { 1905 OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_term)); 1906 pNewNode->append(pSearchCondition->removeAt((sal_uInt32)0)); 1907 pNewNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("AND"),SQL_NODE_KEYWORD,SQL_TOKEN_AND)); 1908 pNewNode->append(pSearchCondition->removeAt((sal_uInt32)1)); 1909 replaceAndReset(pSearchCondition,pNewNode); 1910 1911 pLeft = pNewNode->getChild(0); 1912 pRight = pNewNode->getChild(2); 1913 } 1914 1915 negateSearchCondition(pLeft,bNegate); 1916 negateSearchCondition(pRight,bNegate); 1917 } 1918 // boolean_term SQL_TOKEN_AND boolean_factor 1919 else if (SQL_ISRULE(pSearchCondition,boolean_term)) 1920 { 1921 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 1922 OSQLParseNode* pRight = pSearchCondition->getChild(2); 1923 if(bNegate) 1924 { 1925 OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::search_condition)); 1926 pNewNode->append(pSearchCondition->removeAt((sal_uInt32)0)); 1927 pNewNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("OR"),SQL_NODE_KEYWORD,SQL_TOKEN_OR)); 1928 pNewNode->append(pSearchCondition->removeAt((sal_uInt32)1)); 1929 replaceAndReset(pSearchCondition,pNewNode); 1930 1931 pLeft = pNewNode->getChild(0); 1932 pRight = pNewNode->getChild(2); 1933 } 1934 1935 negateSearchCondition(pLeft,bNegate); 1936 negateSearchCondition(pRight,bNegate); 1937 } 1938 // SQL_TOKEN_NOT ( boolean_test ) 1939 else if (SQL_ISRULE(pSearchCondition,boolean_factor)) 1940 { 1941 OSQLParseNode *pNot = pSearchCondition->removeAt((sal_uInt32)0); 1942 delete pNot; 1943 OSQLParseNode *pBooleanTest = pSearchCondition->removeAt((sal_uInt32)0); 1944 // TODO is this needed // pBooleanTest->setParent(NULL); 1945 replaceAndReset(pSearchCondition,pBooleanTest); 1946 1947 if (!bNegate) 1948 negateSearchCondition(pSearchCondition,sal_True); // negate all deeper values 1949 } 1950 // row_value_constructor comparison row_value_constructor 1951 // row_value_constructor comparison any_all_some subquery 1952 else if(bNegate && (SQL_ISRULE(pSearchCondition,comparison_predicate) || SQL_ISRULE(pSearchCondition,all_or_any_predicate))) 1953 { 1954 OSQLParseNode* pComparison = pSearchCondition->getChild(1); 1955 OSQLParseNode* pNewComparison = NULL; 1956 switch(pComparison->getNodeType()) 1957 { 1958 case SQL_NODE_EQUAL: 1959 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii("<>"),SQL_NODE_NOTEQUAL,SQL_NOTEQUAL); 1960 break; 1961 case SQL_NODE_LESS: 1962 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii(">="),SQL_NODE_GREATEQ,SQL_GREATEQ); 1963 break; 1964 case SQL_NODE_GREAT: 1965 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii("<="),SQL_NODE_LESSEQ,SQL_LESSEQ); 1966 break; 1967 case SQL_NODE_LESSEQ: 1968 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii(">"),SQL_NODE_GREAT,SQL_GREAT); 1969 break; 1970 case SQL_NODE_GREATEQ: 1971 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii("<"),SQL_NODE_LESS,SQL_LESS); 1972 break; 1973 case SQL_NODE_NOTEQUAL: 1974 pNewComparison = new OSQLParseNode(::rtl::OUString::createFromAscii("="),SQL_NODE_EQUAL,SQL_EQUAL); 1975 break; 1976 default: 1977 OSL_ENSURE( false, "OSQLParseNode::negateSearchCondition: unexpected node type!" ); 1978 break; 1979 } 1980 pSearchCondition->replace(pComparison, pNewComparison); 1981 delete pComparison; 1982 } 1983 1984 else if(bNegate && (SQL_ISRULE(pSearchCondition,test_for_null) || SQL_ISRULE(pSearchCondition,in_predicate) || 1985 SQL_ISRULE(pSearchCondition,between_predicate) || SQL_ISRULE(pSearchCondition,boolean_test) )) 1986 { 1987 OSQLParseNode* pPart2 = pSearchCondition; 1988 if ( !SQL_ISRULE(pSearchCondition,boolean_test) ) 1989 pPart2 = pSearchCondition->getChild(1); 1990 sal_uInt32 nNotPos = 0; 1991 if ( SQL_ISRULE( pSearchCondition, test_for_null ) ) 1992 nNotPos = 1; 1993 else if ( SQL_ISRULE( pSearchCondition, boolean_test ) ) 1994 nNotPos = 2; 1995 1996 OSQLParseNode* pNot = pPart2->getChild(nNotPos); 1997 OSQLParseNode* pNotNot = NULL; 1998 if(pNot->isRule()) 1999 pNotNot = new OSQLParseNode(::rtl::OUString::createFromAscii("NOT"),SQL_NODE_KEYWORD,SQL_TOKEN_NOT); 2000 else 2001 pNotNot = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::sql_not)); 2002 pPart2->replace(pNot, pNotNot); 2003 delete pNot; 2004 } 2005 else if(bNegate && (SQL_ISRULE(pSearchCondition,like_predicate))) 2006 { 2007 OSQLParseNode* pNot = pSearchCondition->getChild( 1 )->getChild( 0 ); 2008 OSQLParseNode* pNotNot = NULL; 2009 if(pNot->isRule()) 2010 pNotNot = new OSQLParseNode(::rtl::OUString::createFromAscii("NOT"),SQL_NODE_KEYWORD,SQL_TOKEN_NOT); 2011 else 2012 pNotNot = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::sql_not)); 2013 pSearchCondition->getChild( 1 )->replace(pNot, pNotNot); 2014 delete pNot; 2015 } 2016 } 2017 //----------------------------------------------------------------------------- 2018 void OSQLParseNode::eraseBraces(OSQLParseNode*& pSearchCondition) 2019 { 2020 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::eraseBraces" ); 2021 if (pSearchCondition && (SQL_ISRULE(pSearchCondition,boolean_primary) || (pSearchCondition->count() == 3 && SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && 2022 SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")")))) 2023 { 2024 OSQLParseNode* pRight = pSearchCondition->getChild(1); 2025 absorptions(pRight); 2026 // if child is not a or or and tree then delete () around child 2027 if(!(SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || SQL_ISRULE(pSearchCondition->getChild(1),search_condition)) || 2028 SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || // and can always stand without () 2029 (SQL_ISRULE(pSearchCondition->getChild(1),search_condition) && SQL_ISRULE(pSearchCondition->getParent(),search_condition))) 2030 { 2031 OSQLParseNode* pNode = pSearchCondition->removeAt(1); 2032 replaceAndReset(pSearchCondition,pNode); 2033 } 2034 } 2035 } 2036 //----------------------------------------------------------------------------- 2037 void OSQLParseNode::absorptions(OSQLParseNode*& pSearchCondition) 2038 { 2039 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::absorptions" ); 2040 if(!pSearchCondition) // no where condition at entry point 2041 return; 2042 2043 eraseBraces(pSearchCondition); 2044 2045 if(SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) 2046 { 2047 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 2048 absorptions(pLeft); 2049 OSQLParseNode* pRight = pSearchCondition->getChild(2); 2050 absorptions(pRight); 2051 } 2052 2053 sal_uInt32 nPos = 0; 2054 // a and a || a or a 2055 OSQLParseNode* pNewNode = NULL; 2056 if(( SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) 2057 && *pSearchCondition->getChild(0) == *pSearchCondition->getChild(2)) 2058 { 2059 pNewNode = pSearchCondition->removeAt((sal_uInt32)0); 2060 replaceAndReset(pSearchCondition,pNewNode); 2061 } 2062 // (a or b) and a || ( b or c ) and a 2063 // a and ( a or b) || a and ( b or c ) 2064 else if ( SQL_ISRULE(pSearchCondition,boolean_term) 2065 && ( 2066 ( SQL_ISRULE(pSearchCondition->getChild(nPos = 0),boolean_primary) 2067 || SQL_ISRULE(pSearchCondition->getChild(nPos),search_condition) 2068 ) 2069 || ( SQL_ISRULE(pSearchCondition->getChild(nPos = 2),boolean_primary) 2070 || SQL_ISRULE(pSearchCondition->getChild(nPos),search_condition) 2071 ) 2072 ) 2073 ) 2074 { 2075 OSQLParseNode* p2ndSearch = pSearchCondition->getChild(nPos); 2076 if ( SQL_ISRULE(p2ndSearch,boolean_primary) ) 2077 p2ndSearch = p2ndSearch->getChild(1); 2078 2079 if ( *p2ndSearch->getChild(0) == *pSearchCondition->getChild(2-nPos) ) // a and ( a or b) -> a or b 2080 { 2081 pNewNode = pSearchCondition->removeAt((sal_uInt32)0); 2082 replaceAndReset(pSearchCondition,pNewNode); 2083 2084 } 2085 else if ( *p2ndSearch->getChild(2) == *pSearchCondition->getChild(2-nPos) ) // a and ( b or a) -> a or b 2086 { 2087 pNewNode = pSearchCondition->removeAt((sal_uInt32)2); 2088 replaceAndReset(pSearchCondition,pNewNode); 2089 } 2090 else if ( p2ndSearch->getByRule(OSQLParseNode::search_condition) ) 2091 { 2092 // a and ( b or c ) -> ( a and b ) or ( a and c ) 2093 // ( b or c ) and a -> ( a and b ) or ( a and c ) 2094 OSQLParseNode* pC = p2ndSearch->removeAt((sal_uInt32)2); 2095 OSQLParseNode* pB = p2ndSearch->removeAt((sal_uInt32)0); 2096 OSQLParseNode* pA = pSearchCondition->removeAt((sal_uInt32)2-nPos); 2097 2098 OSQLParseNode* p1stAnd = MakeANDNode(pA,pB); 2099 OSQLParseNode* p2ndAnd = MakeANDNode(new OSQLParseNode(*pA),pC); 2100 pNewNode = MakeORNode(p1stAnd,p2ndAnd); 2101 OSQLParseNode* pNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); 2102 pNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION)); 2103 pNode->append(pNewNode); 2104 pNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION)); 2105 OSQLParseNode::eraseBraces(p1stAnd); 2106 OSQLParseNode::eraseBraces(p2ndAnd); 2107 replaceAndReset(pSearchCondition,pNode); 2108 } 2109 } 2110 // a or a and b || a or b and a 2111 else if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(2),boolean_term)) 2112 { 2113 if(*pSearchCondition->getChild(2)->getChild(0) == *pSearchCondition->getChild(0)) 2114 { 2115 pNewNode = pSearchCondition->removeAt((sal_uInt32)0); 2116 replaceAndReset(pSearchCondition,pNewNode); 2117 } 2118 else if(*pSearchCondition->getChild(2)->getChild(2) == *pSearchCondition->getChild(0)) 2119 { 2120 pNewNode = pSearchCondition->removeAt((sal_uInt32)0); 2121 replaceAndReset(pSearchCondition,pNewNode); 2122 } 2123 } 2124 // a and b or a || b and a or a 2125 else if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(0),boolean_term)) 2126 { 2127 if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)) 2128 { 2129 pNewNode = pSearchCondition->removeAt((sal_uInt32)2); 2130 replaceAndReset(pSearchCondition,pNewNode); 2131 } 2132 else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)) 2133 { 2134 pNewNode = pSearchCondition->removeAt((sal_uInt32)2); 2135 replaceAndReset(pSearchCondition,pNewNode); 2136 } 2137 } 2138 eraseBraces(pSearchCondition); 2139 } 2140 //----------------------------------------------------------------------------- 2141 void OSQLParseNode::compress(OSQLParseNode *&pSearchCondition) 2142 { 2143 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::compress" ); 2144 if(!pSearchCondition) // no where condition at entry point 2145 return; 2146 2147 OSQLParseNode::eraseBraces(pSearchCondition); 2148 2149 if(SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) 2150 { 2151 OSQLParseNode* pLeft = pSearchCondition->getChild(0); 2152 compress(pLeft); 2153 2154 OSQLParseNode* pRight = pSearchCondition->getChild(2); 2155 compress(pRight); 2156 } 2157 else if( SQL_ISRULE(pSearchCondition,boolean_primary) || (pSearchCondition->count() == 3 && SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && 2158 SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")"))) 2159 { 2160 OSQLParseNode* pRight = pSearchCondition->getChild(1); 2161 compress(pRight); 2162 // if child is not a or or and tree then delete () around child 2163 if(!(SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || SQL_ISRULE(pSearchCondition->getChild(1),search_condition)) || 2164 (SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) && SQL_ISRULE(pSearchCondition->getParent(),boolean_term)) || 2165 (SQL_ISRULE(pSearchCondition->getChild(1),search_condition) && SQL_ISRULE(pSearchCondition->getParent(),search_condition))) 2166 { 2167 OSQLParseNode* pNode = pSearchCondition->removeAt(1); 2168 replaceAndReset(pSearchCondition,pNode); 2169 } 2170 } 2171 2172 // or with two and trees where one element of the and trees are equal 2173 if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(0),boolean_term) && SQL_ISRULE(pSearchCondition->getChild(2),boolean_term)) 2174 { 2175 if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)->getChild(0)) 2176 { 2177 OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt(2); 2178 OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt(2); 2179 OSQLParseNode* pNode = MakeORNode(pLeft,pRight); 2180 2181 OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); 2182 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION)); 2183 pNewRule->append(pNode); 2184 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION)); 2185 2186 OSQLParseNode::eraseBraces(pLeft); 2187 OSQLParseNode::eraseBraces(pRight); 2188 2189 pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt((sal_uInt32)0),pNewRule); 2190 replaceAndReset(pSearchCondition,pNode); 2191 } 2192 else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)->getChild(0)) 2193 { 2194 OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt((sal_uInt32)0); 2195 OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt(2); 2196 OSQLParseNode* pNode = MakeORNode(pLeft,pRight); 2197 2198 OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); 2199 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION)); 2200 pNewRule->append(pNode); 2201 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION)); 2202 2203 OSQLParseNode::eraseBraces(pLeft); 2204 OSQLParseNode::eraseBraces(pRight); 2205 2206 pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt(1),pNewRule); 2207 replaceAndReset(pSearchCondition,pNode); 2208 } 2209 else if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)->getChild(2)) 2210 { 2211 OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt(2); 2212 OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt((sal_uInt32)0); 2213 OSQLParseNode* pNode = MakeORNode(pLeft,pRight); 2214 2215 OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); 2216 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION)); 2217 pNewRule->append(pNode); 2218 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION)); 2219 2220 OSQLParseNode::eraseBraces(pLeft); 2221 OSQLParseNode::eraseBraces(pRight); 2222 2223 pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt((sal_uInt32)0),pNewRule); 2224 replaceAndReset(pSearchCondition,pNode); 2225 } 2226 else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)->getChild(2)) 2227 { 2228 OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt((sal_uInt32)0); 2229 OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt((sal_uInt32)0); 2230 OSQLParseNode* pNode = MakeORNode(pLeft,pRight); 2231 2232 OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); 2233 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION)); 2234 pNewRule->append(pNode); 2235 pNewRule->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION)); 2236 2237 OSQLParseNode::eraseBraces(pLeft); 2238 OSQLParseNode::eraseBraces(pRight); 2239 2240 pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt(1),pNewRule); 2241 replaceAndReset(pSearchCondition,pNode); 2242 } 2243 } 2244 } 2245 #if OSL_DEBUG_LEVEL > 0 2246 // ----------------------------------------------------------------------------- 2247 void OSQLParseNode::showParseTree( ::rtl::OUString& rString ) const 2248 { 2249 ::rtl::OUStringBuffer aBuf; 2250 showParseTree( aBuf, 0 ); 2251 rString = aBuf.makeStringAndClear(); 2252 } 2253 2254 // ----------------------------------------------------------------------------- 2255 void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uInt32 nLevel ) const 2256 { 2257 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::showParseTree" ); 2258 2259 for ( sal_uInt32 j=0; j<nLevel; ++j) 2260 _inout_rBuffer.appendAscii( " " ); 2261 2262 if ( !isToken() ) 2263 { 2264 // Regelnamen als rule: ... 2265 _inout_rBuffer.appendAscii( "RULE_ID: " ); 2266 _inout_rBuffer.append( (sal_Int32)getRuleID() ); 2267 _inout_rBuffer.append( sal_Unicode( '(' ) ); 2268 _inout_rBuffer.append( OSQLParser::RuleIDToStr( getRuleID() ) ); 2269 _inout_rBuffer.append( sal_Unicode( ')' ) ); 2270 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2271 2272 // hol dir den ersten Subtree 2273 for ( OSQLParseNodes::const_iterator i = m_aChildren.begin(); 2274 i != m_aChildren.end(); 2275 ++i 2276 ) 2277 (*i)->showParseTree( _inout_rBuffer, nLevel+1 ); 2278 } 2279 else 2280 { 2281 // ein Token gefunden 2282 switch (m_eNodeType) 2283 { 2284 2285 case SQL_NODE_KEYWORD: 2286 _inout_rBuffer.appendAscii( "SQL_KEYWORD: " ); 2287 _inout_rBuffer.append( ::rtl::OStringToOUString( OSQLParser::TokenIDToStr( getTokenID() ), RTL_TEXTENCODING_UTF8 ) ); 2288 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2289 break; 2290 2291 case SQL_NODE_COMPARISON: 2292 _inout_rBuffer.appendAscii( "SQL_COMPARISON: " ); 2293 _inout_rBuffer.append( m_aNodeValue ); 2294 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2295 break; 2296 2297 case SQL_NODE_NAME: 2298 _inout_rBuffer.appendAscii( "SQL_NAME: " ); 2299 _inout_rBuffer.append( sal_Unicode( '"' ) ); 2300 _inout_rBuffer.append( m_aNodeValue ); 2301 _inout_rBuffer.append( sal_Unicode( '"' ) ); 2302 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2303 break; 2304 2305 case SQL_NODE_STRING: 2306 _inout_rBuffer.appendAscii( "SQL_STRING: " ); 2307 _inout_rBuffer.append( sal_Unicode( '\'' ) ); 2308 _inout_rBuffer.append( m_aNodeValue ); 2309 _inout_rBuffer.append( sal_Unicode( '\'' ) ); 2310 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2311 break; 2312 2313 case SQL_NODE_INTNUM: 2314 _inout_rBuffer.appendAscii( "SQL_INTNUM: " ); 2315 _inout_rBuffer.append( m_aNodeValue ); 2316 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2317 break; 2318 2319 case SQL_NODE_APPROXNUM: 2320 _inout_rBuffer.appendAscii( "SQL_APPROXNUM: " ); 2321 _inout_rBuffer.append( m_aNodeValue ); 2322 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2323 break; 2324 2325 case SQL_NODE_PUNCTUATION: 2326 _inout_rBuffer.appendAscii( "SQL_PUNCTUATION: " ); 2327 _inout_rBuffer.append( m_aNodeValue ); 2328 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2329 break; 2330 2331 case SQL_NODE_AMMSC: 2332 _inout_rBuffer.appendAscii( "SQL_AMMSC: " ); 2333 _inout_rBuffer.append( m_aNodeValue ); 2334 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2335 break; 2336 2337 case SQL_NODE_EQUAL: 2338 case SQL_NODE_LESS: 2339 case SQL_NODE_GREAT: 2340 case SQL_NODE_LESSEQ: 2341 case SQL_NODE_GREATEQ: 2342 case SQL_NODE_NOTEQUAL: 2343 _inout_rBuffer.append( m_aNodeValue ); 2344 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2345 break; 2346 2347 case SQL_NODE_ACCESS_DATE: 2348 _inout_rBuffer.appendAscii( "SQL_ACCESS_DATE: " ); 2349 _inout_rBuffer.append( m_aNodeValue ); 2350 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2351 break; 2352 2353 case SQL_NODE_DATE: 2354 _inout_rBuffer.appendAscii( "SQL_DATE: " ); 2355 _inout_rBuffer.append( m_aNodeValue ); 2356 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2357 break; 2358 2359 case SQL_NODE_CONCAT: 2360 _inout_rBuffer.appendAscii( "||" ); 2361 _inout_rBuffer.append( sal_Unicode( '\n' ) ); 2362 break; 2363 2364 default: 2365 OSL_TRACE( "-- %i", int( m_eNodeType ) ); 2366 OSL_ENSURE( false, "OSQLParser::ShowParseTree: unzulaessiger NodeType" ); 2367 } 2368 } 2369 } 2370 #endif // OSL_DEBUG_LEVEL > 0 2371 // ----------------------------------------------------------------------------- 2372 // Insert-Methoden 2373 //----------------------------------------------------------------------------- 2374 void OSQLParseNode::insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree) 2375 { 2376 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::insert" ); 2377 OSL_ENSURE(pNewSubTree != NULL, "OSQLParseNode: ungueltiger NewSubTree"); 2378 OSL_ENSURE(pNewSubTree->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise"); 2379 2380 // stelle Verbindung zum getParent her: 2381 pNewSubTree->setParent( this ); 2382 m_aChildren.insert(m_aChildren.begin() + nPos, pNewSubTree); 2383 } 2384 2385 // removeAt-Methoden 2386 //----------------------------------------------------------------------------- 2387 OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos) 2388 { 2389 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::removeAt" ); 2390 OSL_ENSURE(nPos < m_aChildren.size(),"Illegal position for removeAt"); 2391 OSQLParseNodes::iterator aPos(m_aChildren.begin() + nPos); 2392 OSQLParseNode* pNode = *aPos; 2393 2394 // setze den getParent des removeten auf NULL 2395 pNode->setParent( NULL ); 2396 2397 m_aChildren.erase(aPos); 2398 return pNode; 2399 } 2400 //----------------------------------------------------------------------------- 2401 OSQLParseNode* OSQLParseNode::remove(OSQLParseNode* pSubTree) 2402 { 2403 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::remove" ); 2404 OSL_ENSURE(pSubTree != NULL, "OSQLParseNode: ungueltiger SubTree"); 2405 OSQLParseNodes::iterator aPos = ::std::find(m_aChildren.begin(), m_aChildren.end(), pSubTree); 2406 if (aPos != m_aChildren.end()) 2407 { 2408 // setze den getParent des removeten auf NULL 2409 pSubTree->setParent( NULL ); 2410 m_aChildren.erase(aPos); 2411 return pSubTree; 2412 } 2413 else 2414 return NULL; 2415 } 2416 2417 // Replace-Methoden 2418 //----------------------------------------------------------------------------- 2419 OSQLParseNode* OSQLParseNode::replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubNode) 2420 { 2421 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replaceAt" ); 2422 OSL_ENSURE(pNewSubNode != NULL, "OSQLParseNode: invalid nodes"); 2423 OSL_ENSURE(pNewSubNode->getParent() == NULL, "OSQLParseNode: node already has getParent"); 2424 OSL_ENSURE(nPos < m_aChildren.size(), "OSQLParseNode: invalid position"); 2425 OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewSubNode) == m_aChildren.end(), 2426 "OSQLParseNode::Replace() Node already element of parent"); 2427 2428 OSQLParseNode* pOldSubNode = m_aChildren[nPos]; 2429 2430 // stelle Verbindung zum getParent her: 2431 pNewSubNode->setParent( this ); 2432 pOldSubNode->setParent( NULL ); 2433 2434 m_aChildren[nPos] = pNewSubNode; 2435 return pOldSubNode; 2436 } 2437 2438 //----------------------------------------------------------------------------- 2439 OSQLParseNode* OSQLParseNode::replace (OSQLParseNode* pOldSubNode, OSQLParseNode* pNewSubNode ) 2440 { 2441 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replace " ); 2442 OSL_ENSURE(pOldSubNode != NULL && pNewSubNode != NULL, "OSQLParseNode: invalid nodes"); 2443 OSL_ENSURE(pNewSubNode->getParent() == NULL, "OSQLParseNode: node already has getParent"); 2444 OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pOldSubNode) != m_aChildren.end(), 2445 "OSQLParseNode::Replace() Node not element of parent"); 2446 OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewSubNode) == m_aChildren.end(), 2447 "OSQLParseNode::Replace() Node already element of parent"); 2448 2449 pOldSubNode->setParent( NULL ); 2450 pNewSubNode->setParent( this ); 2451 ::std::replace(m_aChildren.begin(), m_aChildren.end(), pOldSubNode, pNewSubNode); 2452 return pOldSubNode; 2453 } 2454 // ----------------------------------------------------------------------------- 2455 void OSQLParseNode::parseLeaf(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const 2456 { 2457 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseLeaf" ); 2458 // ein Blatt ist gefunden 2459 // Inhalt dem Ausgabestring anfuegen 2460 switch (m_eNodeType) 2461 { 2462 case SQL_NODE_KEYWORD: 2463 { 2464 if (rString.getLength()) 2465 rString.appendAscii(" "); 2466 2467 const ::rtl::OString sT = OSQLParser::TokenIDToStr(m_nNodeID, rParam.bInternational ? &rParam.m_rContext : NULL); 2468 rString.append(::rtl::OUString(sT,sT.getLength(),RTL_TEXTENCODING_UTF8)); 2469 } break; 2470 case SQL_NODE_STRING: 2471 if (rString.getLength()) 2472 rString.appendAscii(" "); 2473 rString.append(SetQuotation(m_aNodeValue,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'"))); 2474 break; 2475 case SQL_NODE_NAME: 2476 if (rString.getLength()) 2477 { 2478 switch(rString.charAt(rString.getLength()-1) ) 2479 { 2480 case ' ' : 2481 case '.' : break; 2482 default : 2483 if ( !rParam.aMetaData.getCatalogSeparator().getLength() 2484 || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() 2485 ) 2486 rString.appendAscii(" "); break; 2487 } 2488 } 2489 if (rParam.bQuote) 2490 { 2491 if (rParam.bPredicate) 2492 { 2493 rString.appendAscii("["); 2494 rString.append(m_aNodeValue); 2495 rString.appendAscii("]"); 2496 } 2497 else 2498 rString.append(SetQuotation(m_aNodeValue, 2499 rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); 2500 } 2501 else 2502 rString.append(m_aNodeValue); 2503 break; 2504 case SQL_NODE_ACCESS_DATE: 2505 if (rString.getLength()) 2506 rString.appendAscii(" "); 2507 rString.appendAscii("#"); 2508 rString.append(m_aNodeValue); 2509 rString.appendAscii("#"); 2510 break; 2511 2512 case SQL_NODE_INTNUM: 2513 case SQL_NODE_APPROXNUM: 2514 { 2515 ::rtl::OUString aTmp = m_aNodeValue; 2516 if (rParam.bInternational && rParam.bPredicate && rParam.cDecSep != '.') 2517 aTmp = aTmp.replace('.', rParam.cDecSep); 2518 2519 if (rString.getLength()) 2520 rString.appendAscii(" "); 2521 rString.append(aTmp); 2522 2523 } break; 2524 case SQL_NODE_PUNCTUATION: 2525 if ( getParent() && SQL_ISRULE(getParent(),cast_spec) && m_aNodeValue.toChar() == '(' ) // no spaces in front of '(' 2526 { 2527 rString.append(m_aNodeValue); 2528 break; 2529 } 2530 // fall through 2531 default: 2532 if (rString.getLength() && m_aNodeValue.toChar() != '.' && m_aNodeValue.toChar() != ':' ) 2533 { 2534 switch( rString.charAt(rString.getLength()-1) ) 2535 { 2536 case ' ' : 2537 case '.' : break; 2538 default : 2539 if ( !rParam.aMetaData.getCatalogSeparator().getLength() 2540 || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() 2541 ) 2542 rString.appendAscii(" "); break; 2543 } 2544 } 2545 rString.append(m_aNodeValue); 2546 } 2547 } 2548 2549 // ----------------------------------------------------------------------------- 2550 sal_Int32 OSQLParser::getFunctionReturnType(const ::rtl::OUString& _sFunctionName, const IParseContext* pContext) 2551 { 2552 sal_Int32 nType = DataType::VARCHAR; 2553 ::rtl::OString sFunctionName(_sFunctionName,_sFunctionName.getLength(),RTL_TEXTENCODING_UTF8); 2554 2555 if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ASCII,pContext))) nType = DataType::INTEGER; 2556 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_BIT_LENGTH,pContext))) nType = DataType::INTEGER; 2557 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CHAR,pContext))) nType = DataType::VARCHAR; 2558 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CHAR_LENGTH,pContext))) nType = DataType::INTEGER; 2559 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CONCAT,pContext))) nType = DataType::VARCHAR; 2560 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DIFFERENCE,pContext))) nType = DataType::VARCHAR; 2561 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_INSERT,pContext))) nType = DataType::VARCHAR; 2562 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LCASE,pContext))) nType = DataType::VARCHAR; 2563 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LEFT,pContext))) nType = DataType::VARCHAR; 2564 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LENGTH,pContext))) nType = DataType::INTEGER; 2565 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOCATE,pContext))) nType = DataType::VARCHAR; 2566 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOCATE_2,pContext))) nType = DataType::VARCHAR; 2567 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LTRIM,pContext))) nType = DataType::VARCHAR; 2568 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_OCTET_LENGTH,pContext))) nType = DataType::INTEGER; 2569 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_POSITION,pContext))) nType = DataType::INTEGER; 2570 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_REPEAT,pContext))) nType = DataType::VARCHAR; 2571 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_REPLACE,pContext))) nType = DataType::VARCHAR; 2572 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RIGHT,pContext))) nType = DataType::VARCHAR; 2573 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RTRIM,pContext))) nType = DataType::VARCHAR; 2574 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SOUNDEX,pContext))) nType = DataType::VARCHAR; 2575 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SPACE,pContext))) nType = DataType::VARCHAR; 2576 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SUBSTRING,pContext))) nType = DataType::VARCHAR; 2577 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_UCASE,pContext))) nType = DataType::VARCHAR; 2578 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_DATE,pContext))) nType = DataType::DATE; 2579 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_TIME,pContext))) nType = DataType::TIME; 2580 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_TIMESTAMP,pContext))) nType = DataType::TIMESTAMP; 2581 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURDATE,pContext))) nType = DataType::DATE; 2582 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DATEDIFF,pContext))) nType = DataType::INTEGER; 2583 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DATEVALUE,pContext))) nType = DataType::DATE; 2584 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURTIME,pContext))) nType = DataType::TIME; 2585 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYNAME,pContext))) nType = DataType::VARCHAR; 2586 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFMONTH,pContext))) nType = DataType::INTEGER; 2587 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFWEEK,pContext))) nType = DataType::INTEGER; 2588 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFYEAR,pContext))) nType = DataType::INTEGER; 2589 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_EXTRACT,pContext))) nType = DataType::VARCHAR; 2590 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_HOUR,pContext))) nType = DataType::INTEGER; 2591 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MINUTE,pContext))) nType = DataType::INTEGER; 2592 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MONTH,pContext))) nType = DataType::INTEGER; 2593 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MONTHNAME,pContext))) nType = DataType::VARCHAR; 2594 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_NOW,pContext))) nType = DataType::TIMESTAMP; 2595 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_QUARTER,pContext))) nType = DataType::INTEGER; 2596 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SECOND,pContext))) nType = DataType::INTEGER; 2597 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMESTAMPADD,pContext))) nType = DataType::TIMESTAMP; 2598 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMESTAMPDIFF,pContext))) nType = DataType::TIMESTAMP; 2599 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMEVALUE,pContext))) nType = DataType::TIMESTAMP; 2600 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_WEEK,pContext))) nType = DataType::INTEGER; 2601 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_YEAR,pContext))) nType = DataType::INTEGER; 2602 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ABS,pContext))) nType = DataType::DOUBLE; 2603 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ACOS,pContext))) nType = DataType::DOUBLE; 2604 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ASIN,pContext))) nType = DataType::DOUBLE; 2605 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ATAN,pContext))) nType = DataType::DOUBLE; 2606 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ATAN2,pContext))) nType = DataType::DOUBLE; 2607 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CEILING,pContext))) nType = DataType::DOUBLE; 2608 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COS,pContext))) nType = DataType::DOUBLE; 2609 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COT,pContext))) nType = DataType::DOUBLE; 2610 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DEGREES,pContext))) nType = DataType::DOUBLE; 2611 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_EXP,pContext))) nType = DataType::DOUBLE; 2612 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_FLOOR,pContext))) nType = DataType::DOUBLE; 2613 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOGF,pContext))) nType = DataType::DOUBLE; 2614 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOG,pContext))) nType = DataType::DOUBLE; 2615 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOG10,pContext))) nType = DataType::DOUBLE; 2616 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LN,pContext))) nType = DataType::DOUBLE; 2617 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MOD,pContext))) nType = DataType::DOUBLE; 2618 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_PI,pContext))) nType = DataType::DOUBLE; 2619 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_POWER,pContext))) nType = DataType::DOUBLE; 2620 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RADIANS,pContext))) nType = DataType::DOUBLE; 2621 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RAND,pContext))) nType = DataType::DOUBLE; 2622 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ROUND,pContext))) nType = DataType::DOUBLE; 2623 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ROUNDMAGIC,pContext))) nType = DataType::DOUBLE; 2624 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SIGN,pContext))) nType = DataType::DOUBLE; 2625 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SIN,pContext))) nType = DataType::DOUBLE; 2626 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SQRT,pContext))) nType = DataType::DOUBLE; 2627 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TAN,pContext))) nType = DataType::DOUBLE; 2628 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TRUNCATE,pContext))) nType = DataType::DOUBLE; 2629 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COUNT,pContext))) nType = DataType::INTEGER; 2630 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MAX,pContext))) nType = DataType::DOUBLE; 2631 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MIN,pContext))) nType = DataType::DOUBLE; 2632 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_AVG,pContext))) nType = DataType::DOUBLE; 2633 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SUM,pContext))) nType = DataType::DOUBLE; 2634 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOWER,pContext))) nType = DataType::VARCHAR; 2635 else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_UPPER,pContext))) nType = DataType::VARCHAR; 2636 2637 return nType; 2638 } 2639 // ----------------------------------------------------------------------------- 2640 sal_Int32 OSQLParser::getFunctionParameterType(sal_uInt32 _nTokenId, sal_uInt32 _nPos) 2641 { 2642 sal_Int32 nType = DataType::VARCHAR; 2643 2644 if(_nTokenId == SQL_TOKEN_CHAR) nType = DataType::INTEGER; 2645 else if(_nTokenId == SQL_TOKEN_INSERT) 2646 { 2647 if ( _nPos == 2 || _nPos == 3 ) 2648 nType = DataType::INTEGER; 2649 } 2650 else if(_nTokenId == SQL_TOKEN_LEFT) 2651 { 2652 if ( _nPos == 2 ) 2653 nType = DataType::INTEGER; 2654 } 2655 else if(_nTokenId == SQL_TOKEN_LOCATE) 2656 { 2657 if ( _nPos == 3 ) 2658 nType = DataType::INTEGER; 2659 } 2660 else if(_nTokenId == SQL_TOKEN_LOCATE_2) 2661 { 2662 if ( _nPos == 3 ) 2663 nType = DataType::INTEGER; 2664 } 2665 else if( _nTokenId == SQL_TOKEN_REPEAT || _nTokenId == SQL_TOKEN_RIGHT ) 2666 { 2667 if ( _nPos == 2 ) 2668 nType = DataType::INTEGER; 2669 } 2670 else if(_nTokenId == SQL_TOKEN_SPACE ) 2671 { 2672 nType = DataType::INTEGER; 2673 } 2674 else if(_nTokenId == SQL_TOKEN_SUBSTRING) 2675 { 2676 if ( _nPos != 1 ) 2677 nType = DataType::INTEGER; 2678 } 2679 else if(_nTokenId == SQL_TOKEN_DATEDIFF) 2680 { 2681 if ( _nPos != 1 ) 2682 nType = DataType::TIMESTAMP; 2683 } 2684 else if(_nTokenId == SQL_TOKEN_DATEVALUE) 2685 nType = DataType::DATE; 2686 else if(_nTokenId == SQL_TOKEN_DAYNAME) 2687 nType = DataType::DATE; 2688 else if(_nTokenId == SQL_TOKEN_DAYOFMONTH) 2689 nType = DataType::DATE; 2690 else if(_nTokenId == SQL_TOKEN_DAYOFWEEK) 2691 nType = DataType::DATE; 2692 else if(_nTokenId == SQL_TOKEN_DAYOFYEAR) 2693 nType = DataType::DATE; 2694 else if(_nTokenId == SQL_TOKEN_EXTRACT) nType = DataType::VARCHAR; 2695 else if(_nTokenId == SQL_TOKEN_HOUR) nType = DataType::TIME; 2696 else if(_nTokenId == SQL_TOKEN_MINUTE) nType = DataType::TIME; 2697 else if(_nTokenId == SQL_TOKEN_MONTH) nType = DataType::DATE; 2698 else if(_nTokenId == SQL_TOKEN_MONTHNAME) nType = DataType::DATE; 2699 else if(_nTokenId == SQL_TOKEN_NOW) nType = DataType::TIMESTAMP; 2700 else if(_nTokenId == SQL_TOKEN_QUARTER) nType = DataType::DATE; 2701 else if(_nTokenId == SQL_TOKEN_SECOND) nType = DataType::TIME; 2702 else if(_nTokenId == SQL_TOKEN_TIMESTAMPADD) nType = DataType::TIMESTAMP; 2703 else if(_nTokenId == SQL_TOKEN_TIMESTAMPDIFF) nType = DataType::TIMESTAMP; 2704 else if(_nTokenId == SQL_TOKEN_TIMEVALUE) nType = DataType::TIMESTAMP; 2705 else if(_nTokenId == SQL_TOKEN_WEEK) nType = DataType::DATE; 2706 else if(_nTokenId == SQL_TOKEN_YEAR) nType = DataType::DATE; 2707 2708 else if(_nTokenId == SQL_TOKEN_ABS) nType = DataType::DOUBLE; 2709 else if(_nTokenId == SQL_TOKEN_ACOS) nType = DataType::DOUBLE; 2710 else if(_nTokenId == SQL_TOKEN_ASIN) nType = DataType::DOUBLE; 2711 else if(_nTokenId == SQL_TOKEN_ATAN) nType = DataType::DOUBLE; 2712 else if(_nTokenId == SQL_TOKEN_ATAN2) nType = DataType::DOUBLE; 2713 else if(_nTokenId == SQL_TOKEN_CEILING) nType = DataType::DOUBLE; 2714 else if(_nTokenId == SQL_TOKEN_COS) nType = DataType::DOUBLE; 2715 else if(_nTokenId == SQL_TOKEN_COT) nType = DataType::DOUBLE; 2716 else if(_nTokenId == SQL_TOKEN_DEGREES) nType = DataType::DOUBLE; 2717 else if(_nTokenId == SQL_TOKEN_EXP) nType = DataType::DOUBLE; 2718 else if(_nTokenId == SQL_TOKEN_FLOOR) nType = DataType::DOUBLE; 2719 else if(_nTokenId == SQL_TOKEN_LOGF) nType = DataType::DOUBLE; 2720 else if(_nTokenId == SQL_TOKEN_LOG) nType = DataType::DOUBLE; 2721 else if(_nTokenId == SQL_TOKEN_LOG10) nType = DataType::DOUBLE; 2722 else if(_nTokenId == SQL_TOKEN_LN) nType = DataType::DOUBLE; 2723 else if(_nTokenId == SQL_TOKEN_MOD) nType = DataType::DOUBLE; 2724 else if(_nTokenId == SQL_TOKEN_PI) nType = DataType::DOUBLE; 2725 else if(_nTokenId == SQL_TOKEN_POWER) nType = DataType::DOUBLE; 2726 else if(_nTokenId == SQL_TOKEN_RADIANS) nType = DataType::DOUBLE; 2727 else if(_nTokenId == SQL_TOKEN_RAND) nType = DataType::DOUBLE; 2728 else if(_nTokenId == SQL_TOKEN_ROUND) nType = DataType::DOUBLE; 2729 else if(_nTokenId == SQL_TOKEN_ROUNDMAGIC) nType = DataType::DOUBLE; 2730 else if(_nTokenId == SQL_TOKEN_SIGN) nType = DataType::DOUBLE; 2731 else if(_nTokenId == SQL_TOKEN_SIN) nType = DataType::DOUBLE; 2732 else if(_nTokenId == SQL_TOKEN_SQRT) nType = DataType::DOUBLE; 2733 else if(_nTokenId == SQL_TOKEN_TAN) nType = DataType::DOUBLE; 2734 else if(_nTokenId == SQL_TOKEN_TRUNCATE) nType = DataType::DOUBLE; 2735 else if(_nTokenId == SQL_TOKEN_COUNT) nType = DataType::INTEGER; 2736 else if(_nTokenId == SQL_TOKEN_MAX) nType = DataType::DOUBLE; 2737 else if(_nTokenId == SQL_TOKEN_MIN) nType = DataType::DOUBLE; 2738 else if(_nTokenId == SQL_TOKEN_AVG) nType = DataType::DOUBLE; 2739 else if(_nTokenId == SQL_TOKEN_SUM) nType = DataType::DOUBLE; 2740 2741 else if(_nTokenId == SQL_TOKEN_LOWER) nType = DataType::VARCHAR; 2742 else if(_nTokenId == SQL_TOKEN_UPPER) nType = DataType::VARCHAR; 2743 2744 return nType; 2745 } 2746 2747 // ----------------------------------------------------------------------------- 2748 const SQLError& OSQLParser::getErrorHelper() const 2749 { 2750 return m_pData->aErrors; 2751 } 2752 2753 // ----------------------------------------------------------------------------- 2754 OSQLParseNode::Rule OSQLParseNode::getKnownRuleID() const 2755 { 2756 if ( !isRule() ) 2757 return UNKNOWN_RULE; 2758 return OSQLParser::RuleIDToRule( getRuleID() ); 2759 } 2760 // ----------------------------------------------------------------------------- 2761 ::rtl::OUString OSQLParseNode::getTableRange(const OSQLParseNode* _pTableRef) 2762 { 2763 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableRange" ); 2764 OSL_ENSURE(_pTableRef && _pTableRef->count() > 1 && _pTableRef->getKnownRuleID() == OSQLParseNode::table_ref,"Invalid node give, only table ref is allowed!"); 2765 const sal_uInt32 nCount = _pTableRef->count(); 2766 ::rtl::OUString sTableRange; 2767 if ( nCount == 2 || (nCount == 3 && !_pTableRef->getChild(0)->isToken()) || nCount == 5 ) 2768 { 2769 const OSQLParseNode* pNode = _pTableRef->getChild(nCount - (nCount == 2 ? 1 : 2)); 2770 OSL_ENSURE(pNode && (pNode->getKnownRuleID() == OSQLParseNode::table_primary_as_range_column 2771 || pNode->getKnownRuleID() == OSQLParseNode::range_variable) 2772 ,"SQL grammar changed!"); 2773 if ( !pNode->isLeaf() ) 2774 sTableRange = pNode->getChild(1)->getTokenValue(); 2775 } // if ( nCount == 2 || nCount == 3 || nCount == 5) 2776 2777 return sTableRange; 2778 } 2779 // ----------------------------------------------------------------------------- 2780 OSQLParseNodesContainer::OSQLParseNodesContainer() 2781 { 2782 } 2783 // ----------------------------------------------------------------------------- 2784 OSQLParseNodesContainer::~OSQLParseNodesContainer() 2785 { 2786 } 2787 // ----------------------------------------------------------------------------- 2788 void OSQLParseNodesContainer::push_back(OSQLParseNode* _pNode) 2789 { 2790 ::osl::MutexGuard aGuard(m_aMutex); 2791 m_aNodes.push_back(_pNode); 2792 } 2793 // ----------------------------------------------------------------------------- 2794 void OSQLParseNodesContainer::erase(OSQLParseNode* _pNode) 2795 { 2796 ::osl::MutexGuard aGuard(m_aMutex); 2797 if ( !m_aNodes.empty() ) 2798 { 2799 ::std::vector< OSQLParseNode* >::iterator aFind = ::std::find(m_aNodes.begin(), m_aNodes.end(),_pNode); 2800 if ( aFind != m_aNodes.end() ) 2801 m_aNodes.erase(aFind); 2802 } 2803 } 2804 // ----------------------------------------------------------------------------- 2805 bool OSQLParseNodesContainer::empty() const 2806 { 2807 return m_aNodes.empty(); 2808 } 2809 // ----------------------------------------------------------------------------- 2810 void OSQLParseNodesContainer::clear() 2811 { 2812 ::osl::MutexGuard aGuard(m_aMutex); 2813 m_aNodes.clear(); 2814 } 2815 // ----------------------------------------------------------------------------- 2816 void OSQLParseNodesContainer::clearAndDelete() 2817 { 2818 ::osl::MutexGuard aGuard(m_aMutex); 2819 // clear the garbage collector 2820 while ( !m_aNodes.empty() ) 2821 { 2822 OSQLParseNode* pNode = m_aNodes[0]; 2823 while ( pNode->getParent() ) 2824 { 2825 pNode = pNode->getParent(); 2826 } 2827 delete pNode; 2828 } 2829 } 2830 } // namespace connectivity 2831