diff options
Diffstat (limited to 'connectivity/source/parse/sqlnode.cxx')
| -rw-r--r-- | connectivity/source/parse/sqlnode.cxx | 574 |
1 files changed, 383 insertions, 191 deletions
diff --git a/connectivity/source/parse/sqlnode.cxx b/connectivity/source/parse/sqlnode.cxx index 4f8517d41703..a1fd44014314 100644 --- a/connectivity/source/parse/sqlnode.cxx +++ b/connectivity/source/parse/sqlnode.cxx @@ -76,6 +76,7 @@ #include <algorithm> #include <functional> #include <rtl/logfile.hxx> +#include <rtl/ustrbuf.hxx> using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::util; @@ -303,9 +304,10 @@ void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, if ( _rxConnection.is() ) { + ::rtl::OUStringBuffer sBuffer = rString; try { - OSQLParseNode::impl_parseNodeToString_throw( rString, + OSQLParseNode::impl_parseNodeToString_throw( sBuffer, SQLParseNodeParameter( _rxConnection, xFormatter, _xField, rIntl, pContext, _bIntl, _bQuote, _cDecSep, _bPredicate, _bSubstitute @@ -319,6 +321,7 @@ void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, // in the sub queries, but this cannot be the case here, as we do not parse to // SDBC level. } + rString = sBuffer.makeStringAndClear(); } } //----------------------------------------------------------------------------- @@ -341,10 +344,11 @@ bool OSQLParseNode::parseNodeToExecutableStatement( ::rtl::OUString& _out_rStrin aParseParam.pParser = &_rParser; _out_rString = ::rtl::OUString(); + ::rtl::OUStringBuffer sBuffer; bool bSuccess = false; try { - impl_parseNodeToString_throw( _out_rString, aParseParam ); + impl_parseNodeToString_throw( sBuffer, aParseParam ); bSuccess = true; } catch( const SQLException& e ) @@ -352,6 +356,7 @@ bool OSQLParseNode::parseNodeToExecutableStatement( ::rtl::OUString& _out_rStrin if ( _pErrorHolder ) *_pErrorHolder = e; } + _out_rString = sBuffer.makeStringAndClear(); return bSuccess; } @@ -365,7 +370,7 @@ namespace } //----------------------------------------------------------------------------- -void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const SQLParseNodeParameter& rParam) const +void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableRange" ); if ( isToken() ) @@ -384,19 +389,19 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const case parameter: { if(rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); + rString.appendAscii(" "); if (nCount == 1) // ? - m_aChilds[0]->impl_parseNodeToString_throw( rString, rParam ); + m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); else if (nCount == 2) // :Name { - m_aChilds[0]->impl_parseNodeToString_throw( rString, rParam ); - rString += m_aChilds[1]->m_aNodeValue; + m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); + rString.append(m_aChildren[1]->m_aNodeValue); } // [Name] else { - m_aChilds[0]->impl_parseNodeToString_throw( rString, rParam ); - rString += m_aChilds[1]->m_aNodeValue; - rString += m_aChilds[2]->m_aNodeValue; + m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); + rString.append(m_aChildren[1]->m_aNodeValue); + rString.append(m_aChildren[2]->m_aNodeValue); } bHandled = true; } @@ -418,7 +423,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const case as: if ( rParam.aMetaData.generateASBeforeCorrelationName() ) - rString += ::rtl::OUString::createFromAscii( " AS" ); + rString.append(::rtl::OUString::createFromAscii( " AS" )); bHandled = true; break; @@ -443,26 +448,25 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const SQLParseNodeParameter aNewParam(rParam); aNewParam.bQuote = ( SQL_ISRULE(this,length_exp) || SQL_ISRULE(this,char_value_fct) ); - m_aChilds[0]->impl_parseNodeToString_throw( rString, aNewParam ); + m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); aNewParam.bQuote = rParam.bQuote; //aNewParam.bPredicate = sal_False; // disable [ ] around names // look at i73215 - ::rtl::OUString aStringPara; + ::rtl::OUStringBuffer aStringPara; for (sal_uInt32 i=1; i<nCount; i++) { - const OSQLParseNode * pSubTree = m_aChilds[i]; + const OSQLParseNode * pSubTree = m_aChildren[i]; if (pSubTree) { pSubTree->impl_parseNodeToString_throw( aStringPara, aNewParam ); // bei den CommaListen zwischen alle Subtrees Commas setzen if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i < (nCount - 1))) - aStringPara += ::rtl::OUString::createFromAscii(","); + aStringPara.appendAscii(","); } else i++; } - aStringPara.trim(); - rString += aStringPara; + rString.append(aStringPara.makeStringAndClear()); } bHandled = true; } @@ -473,8 +477,8 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const if ( !bHandled ) { - for (OSQLParseNodes::const_iterator i = m_aChilds.begin(); - i != m_aChilds.end();) + for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); + i != m_aChildren.end();) { const OSQLParseNode* pSubTree = *i; if ( !pSubTree ) @@ -508,7 +512,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const if(pSubTree->count()) { - const OSQLParseNode* pCol = pSubTree->m_aChilds[pSubTree->count()-1]; + const OSQLParseNode* pCol = pSubTree->m_aChildren[pSubTree->count()-1]; if ( ( SQL_ISRULE(pCol,column_val) && pCol->getChild(0)->getTokenValue().equalsIgnoreAsciiCase(aFieldName) ) @@ -524,7 +528,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const if (SQL_ISRULE(this, comparison_predicate)) { ++i; - if(i != m_aChilds.end()) + if(i != m_aChildren.end()) { pSubTree = *i; if (pSubTree && pSubTree->getNodeType() == SQL_NODE_EQUAL) @@ -540,8 +544,8 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const i++; // bei den CommaListen zwischen alle Subtrees Commas setzen - if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChilds.end())) - rString += ::rtl::OUString::createFromAscii(","); + if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) + rString.appendAscii(","); } } else @@ -550,12 +554,12 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const i++; // bei den CommaListen zwischen alle Subtrees Commas setzen - if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChilds.end())) + if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) { if (SQL_ISRULE(this,value_exp_commalist) && rParam.bPredicate) - rString += ::rtl::OUString::createFromAscii(";"); + rString.appendAscii(";"); else - rString += ::rtl::OUString::createFromAscii(","); + rString.appendAscii(","); } } } @@ -563,7 +567,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUString& rString, const } //----------------------------------------------------------------------------- -bool OSQLParseNode::impl_parseTableNameNodeToString_throw( ::rtl::OUString& rString, const SQLParseNodeParameter& rParam ) const +bool OSQLParseNode::impl_parseTableNameNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseTableNameNodeToString_throw" ); // is the table_name part of a table_ref? @@ -622,25 +626,25 @@ bool OSQLParseNode::impl_parseTableNameNodeToString_throw( ::rtl::OUString& rStr if ( pSubQueryNode.get() ) { // parse the sub-select to SDBC level, too - ::rtl::OUString sSubSelect; + ::rtl::OUStringBuffer sSubSelect; pSubQueryNode->impl_parseNodeToString_throw( sSubSelect, rParam ); if ( sSubSelect.getLength() ) - sCommand = sSubSelect; + sCommand = sSubSelect.makeStringAndClear(); } } - rString += ::rtl::OUString::createFromAscii( " ( " ); - rString += sCommand; - rString += ::rtl::OUString::createFromAscii( " )" ); + rString.appendAscii( " ( " ); + rString.append(sCommand); + rString.appendAscii( " )" ); // append the query name as table alias, since it might be referenced in other // parts of the statement - but only if there's no other alias name present if ( !lcl_isAliasNamePresent( *this ) ) { - rString += ::rtl::OUString::createFromAscii( " AS " ); + rString.appendAscii( " AS " ); if ( rParam.bQuote ) - rString += SetQuotation( sTableOrQueryName, - rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() ); + rString.append(SetQuotation( sTableOrQueryName, + rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); } // don't forget to remove the query name from the history, else multiple inclusions @@ -662,18 +666,18 @@ bool OSQLParseNode::impl_parseTableNameNodeToString_throw( ::rtl::OUString& rStr } //----------------------------------------------------------------------------- -void OSQLParseNode::impl_parseTableRangeNodeToString_throw(::rtl::OUString& rString, const SQLParseNodeParameter& rParam) const +void OSQLParseNode::impl_parseTableRangeNodeToString_throw(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseTableRangeNodeToString_throw" ); OSL_PRECOND( ( count() == 2 ) || ( count() == 3 ) || ( count() == 5 ) ,"Illegal count"); // rString += ::rtl::OUString::createFromAscii(" "); - ::std::for_each(m_aChilds.begin(),m_aChilds.end(), + ::std::for_each(m_aChildren.begin(),m_aChildren.end(), boost::bind( &OSQLParseNode::impl_parseNodeToString_throw, _1, boost::ref( rString ), boost::cref( rParam ) )); } //----------------------------------------------------------------------------- -void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUString& rString, const SQLParseNodeParameter& rParam ) const +void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseLikeNodeToString_throw" ); OSL_ENSURE(count() >= 4,"count != 5: Prepare for GPF"); @@ -701,9 +705,9 @@ void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUString& rString, { OSL_ENSURE( false, "OSQLParseNode::impl_parseLikeNodeToString_throw Exception occured!" ); } - if ( !m_aChilds[0]->isLeaf() ) + if ( !m_aChildren[0]->isLeaf() ) { - const OSQLParseNode* pCol = m_aChilds[0]->getChild(m_aChilds[0]->count()-1); + const OSQLParseNode* pCol = m_aChildren[0]->getChild(m_aChildren[0]->count()-1); if ((SQL_ISRULE(pCol,column_val) && pCol->getChild(0)->getTokenValue().equalsIgnoreAsciiCase(aFieldName)) || pCol->getTokenValue().equalsIgnoreAsciiCase(aFieldName) ) bAddName = sal_False; @@ -711,21 +715,21 @@ void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUString& rString, } if (bAddName) - m_aChilds[0]->impl_parseNodeToString_throw( rString, aNewParam ); + m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); - m_aChilds[1]->impl_parseNodeToString_throw( rString, aNewParam ); + m_aChildren[1]->impl_parseNodeToString_throw( rString, aNewParam ); if(count() == 5) - m_aChilds[2]->impl_parseNodeToString_throw( rString, aNewParam ); + m_aChildren[2]->impl_parseNodeToString_throw( rString, aNewParam ); - sal_Int32 nCurentPos = m_aChilds.size()-2; - pParaNode = m_aChilds[nCurentPos]; - pEscNode = m_aChilds[nCurentPos+1]; + sal_Int32 nCurentPos = m_aChildren.size()-2; + pParaNode = m_aChildren[nCurentPos]; + pEscNode = m_aChildren[nCurentPos+1]; if (pParaNode->isToken()) { ::rtl::OUString aStr = ConvertLikeToken(pParaNode, pEscNode, rParam.bInternational); - rString += ::rtl::OUString::createFromAscii(" "); - rString += SetQuotation(aStr,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'")); + rString.appendAscii(" "); + rString.append(SetQuotation(aStr,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'"))); } else pParaNode->impl_parseNodeToString_throw( rString, aNewParam ); @@ -738,12 +742,15 @@ void OSQLParseNode::impl_parseLikeNodeToString_throw( ::rtl::OUString& rString, sal_Bool OSQLParseNode::getTableComponents(const OSQLParseNode* _pTableNode, ::com::sun::star::uno::Any &_rCatalog, ::rtl::OUString &_rSchema, - ::rtl::OUString &_rTable) + ::rtl::OUString &_rTable, + const Reference< XDatabaseMetaData >& _xMetaData) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableComponents" ); OSL_ENSURE(_pTableNode,"Wrong use of getTableComponents! _pTableNode is not allowed to be null!"); if(_pTableNode) { + const sal_Bool bSupportsCatalog = _xMetaData.is() && _xMetaData->supportsCatalogsInDataManipulation(); + const sal_Bool bSupportsSchema = _xMetaData.is() && _xMetaData->supportsSchemasInDataManipulation(); const OSQLParseNode* pTableNode = _pTableNode; // clear the parameter given _rCatalog = Any(); @@ -758,7 +765,10 @@ sal_Bool OSQLParseNode::getTableComponents(const OSQLParseNode* _pTableNode, // check if we have schema_name rule if(SQL_ISRULE(pTableNode,schema_name)) { - _rSchema = pTableNode->getChild(0)->getTokenValue(); + if ( bSupportsCatalog && !bSupportsSchema ) + _rCatalog <<= pTableNode->getChild(0)->getTokenValue(); + else + _rSchema = pTableNode->getChild(0)->getTokenValue(); pTableNode = pTableNode->getChild(2); } // check if we have table_name rule @@ -1242,8 +1252,8 @@ OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const : if (SQLyyparse() != 0) { m_sFieldName= ::rtl::OUString(); - m_xField = NULL; - m_xFormatter = NULL; + m_xField.clear(); + m_xFormatter.clear(); m_nFormatKey = 0; m_nDateFormatKey = 0; @@ -1255,22 +1265,16 @@ OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const : rErrorMessage = m_sErrorMessage; // clear the garbage collector - while (!s_pGarbageCollector->empty()) - { - OSQLParseNode* pNode = *s_pGarbageCollector->begin(); - while (pNode->getParent()) - pNode = pNode->getParent(); - delete pNode; - } + (*s_pGarbageCollector)->clearAndDelete(); return NULL; } else { - s_pGarbageCollector->clear(); + (*s_pGarbageCollector)->clear(); m_sFieldName= ::rtl::OUString(); - m_xField = NULL; - m_xFormatter = NULL; + m_xField.clear(); + m_xFormatter.clear(); m_nFormatKey = 0; m_nDateFormatKey = 0; @@ -1309,7 +1313,7 @@ OSQLParser::OSQLParser(const ::com::sun::star::uno::Reference< ::com::sun::star: { s_pScanner = new OSQLScanner(); s_pScanner->setScanner(); - s_pGarbageCollector = new OSQLParseNodes(); + s_pGarbageCollector = new OSQLParseNodesGarbageCollector(); if(!s_xLocaleData.is()) s_xLocaleData = Reference<XLocaleData>(m_xServiceFactory->createInstance(::rtl::OUString::createFromAscii("com.sun.star.i18n.LocaleData")),UNO_QUERY); @@ -1620,8 +1624,8 @@ OSQLParseNode::OSQLParseNode(const OSQLParseNode& rParseNode) // Zeigers wieder eingehangen. // wenn kein Blatt, dann SubTrees bearbeiten - for (OSQLParseNodes::const_iterator i = rParseNode.m_aChilds.begin(); - i != rParseNode.m_aChilds.end(); i++) + for (OSQLParseNodes::const_iterator i = rParseNode.m_aChildren.begin(); + i != rParseNode.m_aChildren.end(); i++) append(new OSQLParseNode(**i)); } // ----------------------------------------------------------------------------- @@ -1635,14 +1639,14 @@ OSQLParseNode& OSQLParseNode::operator=(const OSQLParseNode& rParseNode) m_eNodeType = rParseNode.m_eNodeType; m_nNodeID = rParseNode.m_nNodeID; - for (OSQLParseNodes::const_iterator i = m_aChilds.begin(); - i != m_aChilds.end(); i++) + for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); + i != m_aChildren.end(); i++) delete *i; - m_aChilds.clear(); + m_aChildren.clear(); - for (OSQLParseNodes::const_iterator j = rParseNode.m_aChilds.begin(); - j != rParseNode.m_aChilds.end(); j++) + for (OSQLParseNodes::const_iterator j = rParseNode.m_aChildren.begin(); + j != rParseNode.m_aChildren.end(); j++) append(new OSQLParseNode(**j)); } return *this; @@ -1670,10 +1674,10 @@ sal_Bool OSQLParseNode::operator==(OSQLParseNode& rParseNode) const //----------------------------------------------------------------------------- OSQLParseNode::~OSQLParseNode() { - for (OSQLParseNodes::const_iterator i = m_aChilds.begin(); - i != m_aChilds.end(); i++) + for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); + i != m_aChildren.end(); i++) delete *i; - m_aChilds.clear(); + m_aChildren.clear(); } //----------------------------------------------------------------------------- @@ -1683,23 +1687,23 @@ void OSQLParseNode::append(OSQLParseNode* pNewNode) OSL_ENSURE(pNewNode != NULL, "OSQLParseNode: ungueltiger NewSubTree"); OSL_ENSURE(pNewNode->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise"); - OSL_ENSURE(::std::find(m_aChilds.begin(), m_aChilds.end(), pNewNode) == m_aChilds.end(), + OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewNode) == m_aChildren.end(), "OSQLParseNode::append() Node already element of parent"); // stelle Verbindung zum getParent her: pNewNode->setParent( this ); // und haenge den SubTree hinten an - m_aChilds.push_back(pNewNode); + m_aChildren.push_back(pNewNode); } // ----------------------------------------------------------------------------- -sal_Bool OSQLParseNode::addDateValue(::rtl::OUString& rString, const SQLParseNodeParameter& rParam) const +sal_Bool OSQLParseNode::addDateValue(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::addDateValue" ); // special display for date/time values - if (SQL_ISRULE(this,set_fct_spec) && SQL_ISPUNCTUATION(m_aChilds[0],"{")) + if (SQL_ISRULE(this,set_fct_spec) && SQL_ISPUNCTUATION(m_aChildren[0],"{")) { - const OSQLParseNode* pODBCNode = m_aChilds[1]; - const OSQLParseNode* pODBCNodeChild = pODBCNode->m_aChilds[0]; + const OSQLParseNode* pODBCNode = m_aChildren[1]; + const OSQLParseNode* pODBCNodeChild = pODBCNode->m_aChildren[0]; if (pODBCNodeChild->getNodeType() == SQL_NODE_KEYWORD && ( SQL_ISTOKEN(pODBCNodeChild, D) || @@ -1713,10 +1717,6 @@ sal_Bool OSQLParseNode::addDateValue(::rtl::OUString& rString, const SQLParseNod { suQuote = ::rtl::OUString::createFromAscii("#"); } - else - { - suQuote = ::rtl::OUString::createFromAscii("'"); - } } else { @@ -1725,29 +1725,25 @@ sal_Bool OSQLParseNode::addDateValue(::rtl::OUString& rString, const SQLParseNod // suQuote = ::rtl::OUString::createFromAscii("'"); return sal_False; } - else - { - suQuote = ::rtl::OUString::createFromAscii("'"); - } } if (rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); - rString += suQuote; - const ::rtl::OUString sTokenValue = pODBCNode->m_aChilds[1]->getTokenValue(); + rString.appendAscii(" "); + rString.append(suQuote); + const ::rtl::OUString sTokenValue = pODBCNode->m_aChildren[1]->getTokenValue(); if (SQL_ISTOKEN(pODBCNodeChild, D)) { - rString += rParam.bPredicate ? convertDateString(rParam, sTokenValue) : sTokenValue; + rString.append(rParam.bPredicate ? convertDateString(rParam, sTokenValue) : sTokenValue); } else if (SQL_ISTOKEN(pODBCNodeChild, T)) { - rString += rParam.bPredicate ? convertTimeString(rParam, sTokenValue) : sTokenValue; + rString.append(rParam.bPredicate ? convertTimeString(rParam, sTokenValue) : sTokenValue); } else { - rString += rParam.bPredicate ? convertDateTimeString(rParam, sTokenValue) : sTokenValue; + rString.append(rParam.bPredicate ? convertDateTimeString(rParam, sTokenValue) : sTokenValue); } - rString += suQuote; + rString.append(suQuote); return sal_True; } } @@ -1779,8 +1775,8 @@ OSQLParseNode* OSQLParseNode::getByRule(OSQLParseNode::Rule eRule) const pRetNode = (OSQLParseNode*)this; else { - for (OSQLParseNodes::const_iterator i = m_aChilds.begin(); - !pRetNode && i != m_aChilds.end(); i++) + for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); + !pRetNode && i != m_aChildren.end(); i++) pRetNode = (*i)->getByRule(eRule); } return pRetNode; @@ -1938,7 +1934,7 @@ void OSQLParseNode::negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_B OSQLParseNode *pNot = pSearchCondition->removeAt((sal_uInt32)0); delete pNot; OSQLParseNode *pBooleanTest = pSearchCondition->removeAt((sal_uInt32)0); - pBooleanTest->setParent(NULL); + // TODO is this needed // pBooleanTest->setParent(NULL); replaceAndReset(pSearchCondition,pBooleanTest); if (!bNegate) @@ -2007,7 +2003,7 @@ void OSQLParseNode::negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_B else if(bNegate && (SQL_ISRULE(pSearchCondition,like_predicate))) { OSQLParseNode* pCheckForNOT = pSearchCondition->getChild( 1 ); - if ( pCheckForNOT->getNodeType() == SQL_TOKEN_NOT ) + if ( SQL_ISTOKEN(pCheckForNOT,NOT) ) delete pSearchCondition->removeAt( 1 ); else { @@ -2238,89 +2234,128 @@ void OSQLParseNode::compress(OSQLParseNode *&pSearchCondition) } } } -#if OSL_DEBUG_LEVEL > 1 +#if OSL_DEBUG_LEVEL > 0 +// ----------------------------------------------------------------------------- +void OSQLParseNode::showParseTree( ::rtl::OUString& rString ) const +{ + ::rtl::OUStringBuffer aBuf; + showParseTree( aBuf, 0 ); + rString = aBuf.makeStringAndClear(); +} + // ----------------------------------------------------------------------------- -void OSQLParseNode::showParseTree(::rtl::OUString& rString, sal_uInt32 nLevel) +void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uInt32 nLevel ) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::showParseTree" ); - if (!isToken()) + for ( sal_uInt32 j=0; j<nLevel; ++j) + _inout_rBuffer.appendAscii( " " ); + + if ( !isToken() ) { - for (sal_uInt32 j=0; j<nLevel; j++) {rString+= ::rtl::OUString::createFromAscii("\t");}; // Regelnamen als rule: ... - rString+= ::rtl::OUString::createFromAscii("RULE_ID:\t "); - rString += ::rtl::OUString::valueOf( (sal_Int32)getRuleID()); - rString+= ::rtl::OUString::createFromAscii("("); - rString += OSQLParser::RuleIDToStr(getRuleID()); - rString+= ::rtl::OUString::createFromAscii(")"); - rString+= ::rtl::OUString::createFromAscii("\n"); + _inout_rBuffer.appendAscii( "RULE_ID: " ); + _inout_rBuffer.append( (sal_Int32)getRuleID() ); + _inout_rBuffer.append( sal_Unicode( '(' ) ); + _inout_rBuffer.append( OSQLParser::RuleIDToStr( getRuleID() ) ); + _inout_rBuffer.append( sal_Unicode( ')' ) ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); // hol dir den ersten Subtree - for (OSQLParseNodes::const_iterator i = m_aChilds.begin(); - i != m_aChilds.end(); i++) - (*i)->showParseTree(rString, nLevel+1); + for ( OSQLParseNodes::const_iterator i = m_aChildren.begin(); + i != m_aChildren.end(); + ++i + ) + (*i)->showParseTree( _inout_rBuffer, nLevel+1 ); } else { // ein Token gefunden - // tabs fuer das Einruecken entsprechend nLevel - for (sal_uInt32 j=0; j<nLevel; j++) {rString+= ::rtl::OUString::createFromAscii("\t");}; - - switch (m_eNodeType) { + switch (m_eNodeType) + { case SQL_NODE_KEYWORD: - {rString+= ::rtl::OUString::createFromAscii("SQL_KEYWORD:\t"); - ::rtl::OString sT = OSQLParser::TokenIDToStr(getTokenID()); - rString += ::rtl::OUString(sT,sT.getLength(),RTL_TEXTENCODING_UTF8); - rString+= ::rtl::OUString::createFromAscii("\n"); - break;} + _inout_rBuffer.appendAscii( "SQL_KEYWORD: " ); + _inout_rBuffer.append( ::rtl::OStringToOUString( OSQLParser::TokenIDToStr( getTokenID() ), RTL_TEXTENCODING_UTF8 ) ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_COMPARISON: - {rString+= ::rtl::OUString::createFromAscii("SQL_COMPARISON:\t"); - rString += m_aNodeValue; // haenge Nodevalue an - rString+= ::rtl::OUString::createFromAscii("\n"); // und beginne neu Zeile - break;} + _inout_rBuffer.appendAscii( "SQL_COMPARISON: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_NAME: - {rString+= ::rtl::OUString::createFromAscii("SQL_NAME:\t"); - rString+= ::rtl::OUString::createFromAscii("\""); - rString += m_aNodeValue; - rString+= ::rtl::OUString::createFromAscii("\""); - rString+= ::rtl::OUString::createFromAscii("\n"); - break;} + _inout_rBuffer.appendAscii( "SQL_NAME: " ); + _inout_rBuffer.append( sal_Unicode( '"' ) ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '"' ) ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_STRING: - {rString += ::rtl::OUString::createFromAscii("SQL_STRING:\t'"); - rString += m_aNodeValue; - rString += ::rtl::OUString::createFromAscii("'\n"); - break;} + _inout_rBuffer.appendAscii( "SQL_STRING: " ); + _inout_rBuffer.append( sal_Unicode( '\'' ) ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\'' ) ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_INTNUM: - {rString += ::rtl::OUString::createFromAscii("SQL_INTNUM:\t"); - rString += m_aNodeValue; - rString += ::rtl::OUString::createFromAscii("\n"); - break;} + _inout_rBuffer.appendAscii( "SQL_INTNUM: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_APPROXNUM: - {rString += ::rtl::OUString::createFromAscii("SQL_APPROXNUM:\t"); - rString += m_aNodeValue; - rString += ::rtl::OUString::createFromAscii("\n"); - break;} + _inout_rBuffer.appendAscii( "SQL_APPROXNUM: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_PUNCTUATION: - {rString += ::rtl::OUString::createFromAscii("SQL_PUNCTUATION:\t"); - rString += m_aNodeValue; // haenge Nodevalue an - rString += ::rtl::OUString::createFromAscii("\n"); // und beginne neu Zeile - break;} + _inout_rBuffer.appendAscii( "SQL_PUNCTUATION: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; case SQL_NODE_AMMSC: - {rString += ::rtl::OUString::createFromAscii("SQL_AMMSC:\t"); - rString += m_aNodeValue; // haenge Nodevalue an - rString += ::rtl::OUString::createFromAscii("\n"); // und beginne neu Zeile - break;} + _inout_rBuffer.appendAscii( "SQL_AMMSC: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; + + case SQL_NODE_EQUAL: + case SQL_NODE_LESS: + case SQL_NODE_GREAT: + case SQL_NODE_LESSEQ: + case SQL_NODE_GREATEQ: + case SQL_NODE_NOTEQUAL: + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; + + case SQL_NODE_ACCESS_DATE: + _inout_rBuffer.appendAscii( "SQL_ACCESS_DATE: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; + + case SQL_NODE_DATE: + _inout_rBuffer.appendAscii( "SQL_DATE: " ); + _inout_rBuffer.append( m_aNodeValue ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; + + case SQL_NODE_CONCAT: + _inout_rBuffer.appendAscii( "||" ); + _inout_rBuffer.append( sal_Unicode( '\n' ) ); + break; default: - OSL_ASSERT("OSQLParser::ShowParseTree: unzulaessiger NodeType"); + OSL_TRACE( "-- %i", int( m_eNodeType ) ); + OSL_ENSURE( false, "OSQLParser::ShowParseTree: unzulaessiger NodeType" ); } } } @@ -2336,7 +2371,7 @@ void OSQLParseNode::insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree) // stelle Verbindung zum getParent her: pNewSubTree->setParent( this ); - m_aChilds.insert(m_aChilds.begin() + nPos, pNewSubTree); + m_aChildren.insert(m_aChildren.begin() + nPos, pNewSubTree); } // removeAt-Methoden @@ -2344,14 +2379,14 @@ void OSQLParseNode::insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree) OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::removeAt" ); - OSL_ENSURE(nPos < m_aChilds.size(),"Illegal position for removeAt"); - OSQLParseNodes::iterator aPos(m_aChilds.begin() + nPos); + OSL_ENSURE(nPos < m_aChildren.size(),"Illegal position for removeAt"); + OSQLParseNodes::iterator aPos(m_aChildren.begin() + nPos); OSQLParseNode* pNode = *aPos; // setze den getParent des removeten auf NULL pNode->setParent( NULL ); - m_aChilds.erase(aPos); + m_aChildren.erase(aPos); return pNode; } //----------------------------------------------------------------------------- @@ -2359,12 +2394,12 @@ OSQLParseNode* OSQLParseNode::remove(OSQLParseNode* pSubTree) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::remove" ); OSL_ENSURE(pSubTree != NULL, "OSQLParseNode: ungueltiger SubTree"); - OSQLParseNodes::iterator aPos = ::std::find(m_aChilds.begin(), m_aChilds.end(), pSubTree); - if (aPos != m_aChilds.end()) + OSQLParseNodes::iterator aPos = ::std::find(m_aChildren.begin(), m_aChildren.end(), pSubTree); + if (aPos != m_aChildren.end()) { // setze den getParent des removeten auf NULL pSubTree->setParent( NULL ); - m_aChilds.erase(aPos); + m_aChildren.erase(aPos); return pSubTree; } else @@ -2378,17 +2413,17 @@ OSQLParseNode* OSQLParseNode::replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubN RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replaceAt" ); OSL_ENSURE(pNewSubNode != NULL, "OSQLParseNode: invalid nodes"); OSL_ENSURE(pNewSubNode->getParent() == NULL, "OSQLParseNode: node already has getParent"); - OSL_ENSURE(nPos < m_aChilds.size(), "OSQLParseNode: invalid position"); - OSL_ENSURE(::std::find(m_aChilds.begin(), m_aChilds.end(), pNewSubNode) == m_aChilds.end(), + OSL_ENSURE(nPos < m_aChildren.size(), "OSQLParseNode: invalid position"); + OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewSubNode) == m_aChildren.end(), "OSQLParseNode::Replace() Node already element of parent"); - OSQLParseNode* pOldSubNode = m_aChilds[nPos]; + OSQLParseNode* pOldSubNode = m_aChildren[nPos]; // stelle Verbindung zum getParent her: pNewSubNode->setParent( this ); pOldSubNode->setParent( NULL ); - m_aChilds[nPos] = pNewSubNode; + m_aChildren[nPos] = pNewSubNode; return pOldSubNode; } @@ -2398,18 +2433,18 @@ OSQLParseNode* OSQLParseNode::replace (OSQLParseNode* pOldSubNode, OSQLParseNode RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replace " ); OSL_ENSURE(pOldSubNode != NULL && pNewSubNode != NULL, "OSQLParseNode: invalid nodes"); OSL_ENSURE(pNewSubNode->getParent() == NULL, "OSQLParseNode: node already has getParent"); - OSL_ENSURE(::std::find(m_aChilds.begin(), m_aChilds.end(), pOldSubNode) != m_aChilds.end(), + OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pOldSubNode) != m_aChildren.end(), "OSQLParseNode::Replace() Node not element of parent"); - OSL_ENSURE(::std::find(m_aChilds.begin(), m_aChilds.end(), pNewSubNode) == m_aChilds.end(), + OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewSubNode) == m_aChildren.end(), "OSQLParseNode::Replace() Node already element of parent"); pOldSubNode->setParent( NULL ); pNewSubNode->setParent( this ); - ::std::replace(m_aChilds.begin(), m_aChilds.end(), pOldSubNode, pNewSubNode); + ::std::replace(m_aChildren.begin(), m_aChildren.end(), pOldSubNode, pNewSubNode); return pOldSubNode; } // ----------------------------------------------------------------------------- -void OSQLParseNode::parseLeaf(::rtl::OUString & rString, const SQLParseNodeParameter& rParam) const +void OSQLParseNode::parseLeaf(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseLeaf" ); // ein Blatt ist gefunden @@ -2419,51 +2454,51 @@ void OSQLParseNode::parseLeaf(::rtl::OUString & rString, const SQLParseNodeParam case SQL_NODE_KEYWORD: { if (rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); + rString.appendAscii(" "); - ::rtl::OString sT = OSQLParser::TokenIDToStr(m_nNodeID, &rParam.m_rContext); - rString += ::rtl::OUString(sT,sT.getLength(),RTL_TEXTENCODING_UTF8); + const ::rtl::OString sT = OSQLParser::TokenIDToStr(m_nNodeID, &rParam.m_rContext); + rString.append(::rtl::OUString(sT,sT.getLength(),RTL_TEXTENCODING_UTF8)); } break; case SQL_NODE_STRING: if (rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); - rString += SetQuotation(m_aNodeValue,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'")); + rString.appendAscii(" "); + rString.append(SetQuotation(m_aNodeValue,::rtl::OUString::createFromAscii("\'"),::rtl::OUString::createFromAscii("\'\'"))); break; case SQL_NODE_NAME: if (rString.getLength()) { - switch(rString.getStr()[rString.getLength()-1] ) + switch(rString.charAt(rString.getLength()-1) ) { case ' ' : case '.' : break; default : if ( !rParam.aMetaData.getCatalogSeparator().getLength() - || rString.getStr()[ rString.getLength()-1 ] != rParam.aMetaData.getCatalogSeparator().toChar() + || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() ) - rString += ::rtl::OUString::createFromAscii(" "); break; + rString.appendAscii(" "); break; } } if (rParam.bQuote) { if (rParam.bPredicate) { - rString+= ::rtl::OUString::createFromAscii("["); - rString += m_aNodeValue; - rString+= ::rtl::OUString::createFromAscii("]"); + rString.appendAscii("["); + rString.append(m_aNodeValue); + rString.appendAscii("]"); } else - rString += SetQuotation(m_aNodeValue, - rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() ); + rString.append(SetQuotation(m_aNodeValue, + rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); } else - rString += m_aNodeValue; + rString.append(m_aNodeValue); break; case SQL_NODE_ACCESS_DATE: if (rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); - rString += ::rtl::OUString::createFromAscii("#"); - rString += m_aNodeValue; - rString += ::rtl::OUString::createFromAscii("#"); + rString.appendAscii(" "); + rString.appendAscii("#"); + rString.append(m_aNodeValue); + rString.appendAscii("#"); break; case SQL_NODE_INTNUM: case SQL_NODE_APPROXNUM: @@ -2473,26 +2508,26 @@ void OSQLParseNode::parseLeaf(::rtl::OUString & rString, const SQLParseNodeParam aTmp = aTmp.replace('.', rParam.cDecSep); if (rString.getLength()) - rString += ::rtl::OUString::createFromAscii(" "); - rString += aTmp; + rString.appendAscii(" "); + rString.append(aTmp); } break; // fall through default: if (rString.getLength() && m_aNodeValue.toChar() != '.' && m_aNodeValue.toChar() != ':' ) { - switch( rString.getStr()[rString.getLength()-1] ) + switch( rString.charAt(rString.getLength()-1) ) { case ' ' : case '.' : break; default : if ( !rParam.aMetaData.getCatalogSeparator().getLength() - || rString.getStr()[ rString.getLength()-1 ] != rParam.aMetaData.getCatalogSeparator().toChar() + || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() ) - rString += ::rtl::OUString::createFromAscii(" "); break; + rString.appendAscii(" "); break; } } - rString += m_aNodeValue; + rString.append(m_aNodeValue); } } @@ -2587,6 +2622,113 @@ sal_Int32 OSQLParser::getFunctionReturnType(const ::rtl::OUString& _sFunctionNam return nType; } +// ----------------------------------------------------------------------------- +sal_Int32 OSQLParser::getFunctionParameterType(sal_uInt32 _nTokenId, sal_uInt32 _nPos) +{ + sal_Int32 nType = DataType::VARCHAR; + + if(_nTokenId == SQL_TOKEN_CHAR) nType = DataType::INTEGER; + else if(_nTokenId == SQL_TOKEN_INSERT) + { + if ( _nPos == 2 || _nPos == 3 ) + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_LEFT) + { + if ( _nPos == 2 ) + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_LOCATE) + { + if ( _nPos == 3 ) + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_LOCATE_2) + { + if ( _nPos == 3 ) + nType = DataType::INTEGER; + } + else if( _nTokenId == SQL_TOKEN_REPEAT || _nTokenId == SQL_TOKEN_RIGHT ) + { + if ( _nPos == 2 ) + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_SPACE ) + { + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_SUBSTRING) + { + if ( _nPos != 1 ) + nType = DataType::INTEGER; + } + else if(_nTokenId == SQL_TOKEN_DATEDIFF) + { + if ( _nPos != 1 ) + nType = DataType::TIMESTAMP; + } + else if(_nTokenId == SQL_TOKEN_DATEVALUE) + nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_DAYNAME) + nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_DAYOFMONTH) + nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_DAYOFWEEK) + nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_DAYOFYEAR) + nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_EXTRACT) nType = DataType::VARCHAR; + else if(_nTokenId == SQL_TOKEN_HOUR) nType = DataType::TIME; + else if(_nTokenId == SQL_TOKEN_MINUTE) nType = DataType::TIME; + else if(_nTokenId == SQL_TOKEN_MONTH) nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_MONTHNAME) nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_NOW) nType = DataType::TIMESTAMP; + else if(_nTokenId == SQL_TOKEN_QUARTER) nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_SECOND) nType = DataType::TIME; + else if(_nTokenId == SQL_TOKEN_TIMESTAMPADD) nType = DataType::TIMESTAMP; + else if(_nTokenId == SQL_TOKEN_TIMESTAMPDIFF) nType = DataType::TIMESTAMP; + else if(_nTokenId == SQL_TOKEN_TIMEVALUE) nType = DataType::TIMESTAMP; + else if(_nTokenId == SQL_TOKEN_WEEK) nType = DataType::DATE; + else if(_nTokenId == SQL_TOKEN_YEAR) nType = DataType::DATE; + + else if(_nTokenId == SQL_TOKEN_ABS) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ACOS) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ASIN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ATAN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ATAN2) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_CEILING) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_COS) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_COT) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_DEGREES) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_EXP) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_FLOOR) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_LOGF) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_LOG) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_LOG10) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_LN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_MOD) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_PI) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_POWER) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_RADIANS) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_RAND) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ROUND) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_ROUNDMAGIC) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_SIGN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_SIN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_SQRT) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_TAN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_TRUNCATE) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_COUNT) nType = DataType::INTEGER; + else if(_nTokenId == SQL_TOKEN_MAX) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_MIN) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_AVG) nType = DataType::DOUBLE; + else if(_nTokenId == SQL_TOKEN_SUM) nType = DataType::DOUBLE; + + else if(_nTokenId == SQL_TOKEN_LOWER) nType = DataType::VARCHAR; + else if(_nTokenId == SQL_TOKEN_UPPER) nType = DataType::VARCHAR; + + return nType; +} // ----------------------------------------------------------------------------- const SQLError& OSQLParser::getErrorHelper() const @@ -2620,5 +2762,55 @@ OSQLParseNode::Rule OSQLParseNode::getKnownRuleID() const return sTableRange; } - +// ----------------------------------------------------------------------------- +OSQLParseNodesContainer::OSQLParseNodesContainer() +{ +} +// ----------------------------------------------------------------------------- +OSQLParseNodesContainer::~OSQLParseNodesContainer() +{ +} +// ----------------------------------------------------------------------------- +void OSQLParseNodesContainer::push_back(OSQLParseNode* _pNode) +{ + ::osl::MutexGuard aGuard(m_aMutex); + m_aNodes.push_back(_pNode); +} +// ----------------------------------------------------------------------------- +void OSQLParseNodesContainer::erase(OSQLParseNode* _pNode) +{ + ::osl::MutexGuard aGuard(m_aMutex); + if ( !m_aNodes.empty() ) + { + ::std::vector< OSQLParseNode* >::iterator aFind = ::std::find(m_aNodes.begin(), m_aNodes.end(),_pNode); + if ( aFind != m_aNodes.end() ) + m_aNodes.erase(aFind); + } +} +// ----------------------------------------------------------------------------- +bool OSQLParseNodesContainer::empty() const +{ + return m_aNodes.empty(); +} +// ----------------------------------------------------------------------------- +void OSQLParseNodesContainer::clear() +{ + ::osl::MutexGuard aGuard(m_aMutex); + m_aNodes.clear(); +} +// ----------------------------------------------------------------------------- +void OSQLParseNodesContainer::clearAndDelete() +{ + ::osl::MutexGuard aGuard(m_aMutex); + // clear the garbage collector + while ( !m_aNodes.empty() ) + { + OSQLParseNode* pNode = m_aNodes[0]; + while ( pNode->getParent() ) + { + pNode = pNode->getParent(); + } + delete pNode; + } +} } // namespace connectivity |