Tag: cws_src680_qiq User: fs Date: 06/05/10 03:53:24 Modified: /dba/connectivity/source/parse/ sqliterator.cxx
Log: primary change: #i51143# allow the iterator to also recognize queries secondary change: some code cleanup: - removed unused code - "warnings" replaced with "errors" (since this is what they are) File Changes: Directory: /dba/connectivity/source/parse/ ========================================== File [changed]: sqliterator.cxx Url: http://dba.openoffice.org/source/browse/dba/connectivity/source/parse/sqliterator.cxx?r1=1.46&r2=1.46.78.1 Delta lines: +380 -414 ----------------------- --- sqliterator.cxx 21 Dec 2005 13:18:40 -0000 1.46 +++ sqliterator.cxx 10 May 2006 10:53:22 -0000 1.46.78.1 @@ -4,9 +4,9 @@ * * $RCSfile: sqliterator.cxx,v $ * - * $Revision: 1.46 $ + * $Revision: 1.46.78.1 $ * - * last change: $Author: obo $ $Date: 2005/12/21 13:18:40 $ + * last change: $Author: fs $ $Date: 2006/05/10 10:53:22 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. @@ -55,6 +55,9 @@ #ifndef _COM_SUN_STAR_SDBC_XROW_HPP_ #include <com/sun/star/sdbc/XRow.hpp> #endif +#ifndef _COM_SUN_STAR_SDB_XQUERIESSUPPLIER_HPP_ +#include <com/sun/star/sdb/XQueriesSupplier.hpp> +#endif #ifdef SQL_TEST_PARSETREEITERATOR #include <iostream> #endif @@ -92,49 +95,78 @@ { struct OSQLParseTreeIteratorImpl { - ::com::sun::star::uno::Reference< - ::com::sun::star::container::XNameAccess> m_xTables; - OSQLTables m_aSubTables; // contains all tables from sub queries not the tables from the select tables - OSQLParseTreeIteratorImpl(const Reference< XNameAccess>& _xTables - ,const Reference< XDatabaseMetaData>& _xDatabaseMetaData) - : m_xTables(_xTables) - , m_aSubTables(_xDatabaseMetaData.is() && _xDatabaseMetaData->storesMixedCaseQuotedIdentifiers()) - {} + Reference< XDatabaseMetaData > m_xDatabaseMetaData; + Reference< XNameAccess > m_xTableContainer; + Reference< XNameAccess > m_xQueryContainer; + + ::std::auto_ptr< OSQLTables > m_pTables; /// all tables which participate in the SQL statement + ::std::auto_ptr< OSQLTables > m_pSubTables; /// all tables from sub queries not the tables from the select tables + + bool m_bIsCaseSensitive; + + OSQLParseTreeIteratorImpl( const Reference< XConnection >& _rxConnection, const Reference< XNameAccess >& _rxTables ) + { + OSL_PRECOND( _rxConnection.is(), "OSQLParseTreeIteratorImpl::OSQLParseTreeIteratorImpl: invalid connection!" ); + m_xDatabaseMetaData = _rxConnection->getMetaData(); + + m_bIsCaseSensitive = m_xDatabaseMetaData.is() && m_xDatabaseMetaData->storesMixedCaseQuotedIdentifiers(); + m_pTables.reset( new OSQLTables( m_bIsCaseSensitive ) ); + m_pSubTables.reset( new OSQLTables( m_bIsCaseSensitive ) ); + + m_xTableContainer = _rxTables; + + bool bSupportsSubQueries = m_xDatabaseMetaData.is() + && ( m_xDatabaseMetaData->supportsSubqueriesInComparisons() + || m_xDatabaseMetaData->supportsSubqueriesInExists() + || m_xDatabaseMetaData->supportsSubqueriesInIns() + || m_xDatabaseMetaData->supportsSubqueriesInQuantifieds() + || m_xDatabaseMetaData->supportsCorrelatedSubqueries() + ); + // TODO: is there a better way to determine this? The above is not really true, since + // in theory, there might be DBs which support sub queries in FROM (which is what we're really + // interested in), but none of the above. + + if ( bSupportsSubQueries ) + { + // connections might support the XQueriesSupplier interface, if they implement the css.sdb.Connection + // service + Reference< XQueriesSupplier > xSuppQueries( _rxConnection, UNO_QUERY ); + if ( xSuppQueries.is() ) + m_xQueryContainer = xSuppQueries->getQueries(); + } + } OSQLParseTreeIteratorImpl(){} }; } //----------------------------------------------------------------------------- -OSQLParseTreeIterator::OSQLParseTreeIterator(const Reference< XNameAccess>& _xTables , - const Reference< XDatabaseMetaData>& _xDatabaseMetaData, +OSQLParseTreeIterator::OSQLParseTreeIterator(const Reference< XConnection >& _rxConnection, + const Reference< XNameAccess >& _rxTables, const OSQLParseNode* pRoot, - const OSQLParser* _pParser) - : m_xDatabaseMetaData(_xDatabaseMetaData) - , m_aTables(_xDatabaseMetaData.is() && _xDatabaseMetaData->storesMixedCaseQuotedIdentifiers()) - ,m_pImpl(new OSQLParseTreeIteratorImpl(_xTables ,_xDatabaseMetaData)) - , m_aCaseEqual(_xDatabaseMetaData.is() && _xDatabaseMetaData->storesMixedCaseQuotedIdentifiers()) - ,m_pParser(_pParser) + const OSQLParser* _pParser ) + :m_pImpl( new OSQLParseTreeIteratorImpl( _rxConnection, _rxTables ) ) + ,m_pParser( _pParser ) { -// m_aSelectColumns = new OSQLColumns();// must be done because we need an empty column at zero -// m_aParameters = new OSQLColumns(); setParseTree(pRoot); } //----------------------------------------------------------------------------- -OSQLParseTreeIterator::OSQLParseTreeIterator(const OSQLParseTreeIterator & rIter) - :m_pImpl(NULL) - ,m_pParseTree(NULL) - ,m_xDatabaseMetaData(NULL) - ,m_pParser(NULL) +OSQLParseTreeIterator::~OSQLParseTreeIterator() { - OSL_ASSERT("OSQLParseTreeIterator: Copy-Konstruktor nicht implementiert!"); + dispose(); } -//----------------------------------------------------------------------------- -OSQLParseTreeIterator::~OSQLParseTreeIterator() +// ----------------------------------------------------------------------------- +const OSQLTables& OSQLParseTreeIterator::getTables() const { - dispose(); - delete m_pImpl; + return *m_pImpl->m_pTables; } + +// ----------------------------------------------------------------------------- +bool OSQLParseTreeIterator::isCaseSensitive() const +{ + return m_pImpl->m_bIsCaseSensitive; +} + // ----------------------------------------------------------------------------- void OSQLParseTreeIterator::dispose() { @@ -142,18 +174,18 @@ m_aGroupColumns = NULL; m_aOrderColumns = NULL; m_aParameters = NULL; - m_pImpl->m_xTables = NULL; - m_xDatabaseMetaData = NULL; + m_pImpl->m_xTableContainer = NULL; + m_pImpl->m_xDatabaseMetaData = NULL; m_pParser = NULL; m_aCreateColumns = NULL; - m_aTables.clear(); - m_pImpl->m_aSubTables.clear(); + m_pImpl->m_pTables->clear(); + m_pImpl->m_pSubTables->clear(); } //----------------------------------------------------------------------------- void OSQLParseTreeIterator::setParseTree(const OSQLParseNode * pNewParseTree) { - m_aTables.clear(); - m_pImpl->m_aSubTables.clear(); + m_pImpl->m_pTables->clear(); + m_pImpl->m_pSubTables->clear(); m_aSelectColumns = new OSQLColumns(); m_aGroupColumns = new OSQLColumns(); @@ -169,13 +201,10 @@ } // falls m_pParseTree aber keine Connection, dann Fehler - if(!m_pImpl->m_xTables.is()) - { + if ( !m_pImpl->m_xTableContainer.is() ) return; - } - m_aWarning = SQLWarning(); - // m_aTables.setCaseSensitive(TablesAreSensitive()); + m_aErrors = SQLException(); // Statement-Typ ermitteln ... @@ -213,144 +242,178 @@ } //----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseOneTableName(OSQLTables& _rTables,const OSQLParseNode * pTableName, const ::rtl::OUString & rTableRange, const sal_Bool bIsCreateTable) +namespace { - - - OSL_ENSURE(pTableName != NULL,"OSQLParseTreeIterator::traverseOneTableName: pTableName == NULL"); - - Any aCatalog; - ::rtl::OUString aSchema,aTableName,aComposedName; - ::rtl::OUString aTableRange(rTableRange); - - // Tabellenname abholen - OSQLParseNode::getTableComponents(pTableName,aCatalog,aSchema,aTableName); - - // create the composed name like DOMAIN.USER.TABLE1 - ::dbtools::composeTableName(m_xDatabaseMetaData, - aCatalog.hasValue() ? ::comphelper::getString(aCatalog) : ::rtl::OUString(), - aSchema, - aTableName, - aComposedName, - sal_False, - ::dbtools::eInDataManipulation); - // if there is no alias for the table name assign the orignal name to it - if (!aTableRange.getLength()) - aTableRange = aComposedName; - - if(aComposedName.getLength()) + //......................................................................... + static void impl_getRowString( const Reference< XRow >& _rxRow, const sal_Int32 _nColumnIndex, ::rtl::OUString& _out_rString ) { - try - { - if(!m_pImpl->m_xTables->hasByName(aComposedName)) // name not in XNameAccess + _out_rString = _rxRow->getString( _nColumnIndex ); + if ( _rxRow->wasNull() ) + _out_rString= ::rtl::OUString(); + } + + //......................................................................... + static ::rtl::OUString lcl_findTableInMetaData( + const Reference< XDatabaseMetaData >& _rxDBMeta, const ::rtl::OUString& _rCatalog, + const ::rtl::OUString& _rSchema, const ::rtl::OUString& _rTableName ) { - // exists the name in the metadata ?! - if(!aSchema.getLength()) - aSchema = ::rtl::OUString::createFromAscii("%"); + ::rtl::OUString sComposedName; static const ::rtl::OUString s_sTableTypeView(RTL_CONSTASCII_USTRINGPARAM("VIEW")); static const ::rtl::OUString s_sTableTypeTable(RTL_CONSTASCII_USTRINGPARAM("TABLE")); + static const ::rtl::OUString s_sWildcard = ::rtl::OUString::createFromAscii("%"); + + ::rtl::OUString sSchema( _rSchema ); + if ( !sSchema.getLength() ) + sSchema = s_sWildcard; // we want all catalogues, all schemas, all tables Sequence< ::rtl::OUString > sTableTypes(3); - static const ::rtl::OUString sWildcard = ::rtl::OUString::createFromAscii("%"); sTableTypes[0] = s_sTableTypeView; sTableTypes[1] = s_sTableTypeTable; - sTableTypes[2] = sWildcard; // just to be sure to include anything else .... + sTableTypes[2] = s_sWildcard; // just to be sure to include anything else .... - if ( m_xDatabaseMetaData.is() ) + if ( _rxDBMeta.is() ) { - Reference< XResultSet> xRes = m_xDatabaseMetaData->getTables(aCatalog,aSchema,aTableName,sTableTypes); - aComposedName = ::rtl::OUString(); // now clear the name to avoid reassignment - if(xRes.is() && xRes->next()) + sComposedName = ::rtl::OUString(); + + Reference< XResultSet> xRes = _rxDBMeta->getTables( + _rCatalog.getLength() ? makeAny( _rCatalog ) : Any(), sSchema, _rTableName, sTableTypes ); + + Reference< XRow > xCurrentRow( xRes, UNO_QUERY ); + if ( xCurrentRow.is() && xRes->next() ) { ::rtl::OUString sCatalog, sSchema, sName; - Reference< XRow > xCurrentRow(xRes, UNO_QUERY); - sCatalog = xCurrentRow->getString(1); - if(xCurrentRow->wasNull()) - sCatalog= ::rtl::OUString(); - - sSchema = xCurrentRow->getString(2); - if(xCurrentRow->wasNull()) - sSchema= ::rtl::OUString(); - sName = xCurrentRow->getString(3); - if(xCurrentRow->wasNull()) - sName= ::rtl::OUString(); - ::dbtools::composeTableName(m_xDatabaseMetaData, sCatalog, + + impl_getRowString( xCurrentRow, 1, sCatalog ); + impl_getRowString( xCurrentRow, 2, sSchema ); + impl_getRowString( xCurrentRow, 3, sName ); + + ::dbtools::composeTableName( + _rxDBMeta, + sCatalog, sSchema, sName, - aComposedName, + sComposedName, sal_False, - ::dbtools::eInDataManipulation); + ::dbtools::eInDataManipulation + ); } } + return sComposedName; } +} - sal_Bool bHasByName=m_pImpl->m_xTables->hasByName(aComposedName); - if(!bIsCreateTable) //for select statement etc. +//----------------------------------------------------------------------------- +OSQLTable OSQLParseTreeIterator::impl_locateRecordSource( const ::rtl::OUString& _rComposedName, const ::rtl::OUString& _rAlias ) +{ + if ( !_rComposedName.getLength() ) { - if (bHasByName) - m_pImpl->m_xTables->getByName(aComposedName) >>= _rTables[aTableRange]; - else if(m_pParser) - { - ::rtl::OUString sErrMsg = m_pParser->getContext().getErrorMessage(IParseContext::ERROR_INVALID_TABLE); - sErrMsg = sErrMsg.replaceAt(sErrMsg.indexOf('#'),1,aTableName); - appendWarning(sErrMsg); - } - } - else //for create table or view, can't have the same name - { - if (!bHasByName) - setTableName(aTableName - ,aCatalog.hasValue() ? ::comphelper::getString(aCatalog) : ::rtl::OUString() - ,aSchema - ,aTableRange); - else if(m_pParser) - { - ::rtl::OUString sErrMsg = m_pParser->getContext().getErrorMessage(IParseContext::ERROR_INVALID_TABLE_EXIST); - sErrMsg = sErrMsg.replaceAt(sErrMsg.indexOf('#'),1,aTableName); - appendWarning(sErrMsg); - } + OSL_ENSURE( false, "OSQLParseTreeIterator::impl_locateRecordSource: no object name at all?" ); + return OSQLTable(); } - } - catch(Exception&) + OSQLTable aReturn; + ::rtl::OUString sComposedName( _rComposedName ); + + try + { + ::rtl::OUString sCatalog, sSchema, sName; + qualifiedNameComponents( m_pImpl->m_xDatabaseMetaData, sComposedName, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation ); + + // check whether there is a query with the given name + bool bQueryDoesExist = m_pImpl->m_xQueryContainer.is() && m_pImpl->m_xQueryContainer->hasByName( sComposedName ); + + // check whether the table container contains an object with the given name + if ( !bQueryDoesExist && !m_pImpl->m_xTableContainer->hasByName( sComposedName ) ) + sComposedName = lcl_findTableInMetaData( m_pImpl->m_xDatabaseMetaData, sCatalog, sSchema, sName ); + bool bTableDoesExist = m_pImpl->m_xTableContainer->hasByName( sComposedName ); + + // now obtain the object + + // if we're creating a table, and there already is a table or query with the same name, + // this is worth an error + if ( SQL_STATEMENT_CREATE_TABLE == m_eStatementType ) { - if(m_pParser) + if ( bQueryDoesExist || bTableDoesExist ) + impl_appendError( IParseContext::ERROR_INVALID_TABLE_EXIST, &sName ); + else + aReturn = impl_createTableObject( sName, sCatalog, sSchema ); + } + else { - ::rtl::OUString sErrMsg = m_pParser->getContext().getErrorMessage(IParseContext::ERROR_INVALID_TABLE); - sErrMsg = sErrMsg.replaceAt(sErrMsg.indexOf('#'),1,aTableName); - appendWarning(sErrMsg); + // queries win over tables, so if there's a query with this name, take this, no matter if + // there's a table, too + if ( bQueryDoesExist ) + m_pImpl->m_xQueryContainer->getByName( sComposedName ) >>= aReturn; + else if ( bTableDoesExist ) + m_pImpl->m_xTableContainer->getByName( sComposedName ) >>= aReturn; + else + impl_appendError( IParseContext::ERROR_INVALID_TABLE, &sName ); } } - + catch(Exception&) + { + impl_appendError( IParseContext::ERROR_INVALID_TABLE, &sComposedName ); } + + return aReturn; } + //----------------------------------------------------------------------------- -OSQLParseNode * OSQLParseTreeIterator::getQualified_join(OSQLTables& _rTables,OSQLParseNode *pTableRef,::rtl::OUString& aTableRange) +void OSQLParseTreeIterator::traverseOneTableName( OSQLTables& _rTables,const OSQLParseNode * pTableName, const ::rtl::OUString & rTableRange ) +{ + OSL_ENSURE(pTableName != NULL,"OSQLParseTreeIterator::traverseOneTableName: pTableName == NULL"); + + Any aCatalog; + ::rtl::OUString aSchema,aTableName,aComposedName; + ::rtl::OUString aTableRange(rTableRange); + + // Tabellenname abholen + OSQLParseNode::getTableComponents(pTableName,aCatalog,aSchema,aTableName); + + // create the composed name like DOMAIN.USER.TABLE1 + ::dbtools::composeTableName(m_pImpl->m_xDatabaseMetaData, + aCatalog.hasValue() ? ::comphelper::getString(aCatalog) : ::rtl::OUString(), + aSchema, + aTableName, + aComposedName, + sal_False, + ::dbtools::eInDataManipulation); + + // if there is no alias for the table name assign the orignal name to it + if ( !aTableRange.getLength() ) + aTableRange = aComposedName; + + // get the object representing this table/query + OSQLTable aTable = impl_locateRecordSource( aComposedName, aTableRange ); + if ( aTable.is() ) + _rTables[ aTableRange ] = aTable; +} + +//----------------------------------------------------------------------------- +void OSQLParseTreeIterator::getQualified_join( OSQLTables& _rTables, const OSQLParseNode *pTableRef, ::rtl::OUString& aTableRange ) { aTableRange = ::rtl::OUString(); - OSQLParseNode *pNode = getTableRef(_rTables,pTableRef->getChild(0),aTableRange); + const OSQLParseNode* pNode = getTableRef(_rTables,pTableRef->getChild(0),aTableRange); if(isTableNode(pNode)) - traverseOneTableName(_rTables,pNode,aTableRange,sal_False); + traverseOneTableName( _rTables, pNode, aTableRange ); sal_uInt32 nPos = 4; if(SQL_ISRULE(pTableRef,cross_union) || pTableRef->getChild(1)->getTokenID() != SQL_TOKEN_NATURAL) nPos = 3; pNode = getTableRef(_rTables,pTableRef->getChild(nPos),aTableRange); - if(isTableNode(pNode)) - traverseOneTableName(_rTables,pNode,aTableRange,sal_False); - - return pNode; + if ( isTableNode( pNode ) ) + traverseOneTableName( _rTables, pNode, aTableRange ); } //----------------------------------------------------------------------------- -OSQLParseNode * OSQLParseTreeIterator::getTableRef(OSQLTables& _rTables,OSQLParseNode *pTableRef,::rtl::OUString& aTableRange) +const OSQLParseNode* OSQLParseTreeIterator::getTableRef( OSQLTables& _rTables, const OSQLParseNode *pTableRef,::rtl::OUString& aTableRange ) { - OSQLParseNode *pTableName = pTableRef; + const OSQLParseNode *pTableName = pTableRef; if (pTableName->count() == 4 ) { if(SQL_ISPUNCTUATION(pTableName->getChild(0),"{")) @@ -401,9 +464,8 @@ return pTableName; } //----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getSelect_statement(OSQLTables& _rTables,OSQLParseNode *pSelect) +void OSQLParseTreeIterator::getSelect_statement(OSQLTables& _rTables,const OSQLParseNode* pSelect) { - if(SQL_ISRULE(pSelect,union_statement)) { getSelect_statement(_rTables,pSelect->getChild(0)); @@ -415,41 +477,41 @@ OSL_ENSURE(pTableRefCommalist != NULL,"OSQLParseTreeIterator: Fehler im Parse Tree"); OSL_ENSURE(SQL_ISRULE(pTableRefCommalist,table_ref_commalist),"OSQLParseTreeIterator: Fehler im Parse Tree"); - OSQLParseNode * pTableName = NULL; + const OSQLParseNode* pTableName = NULL; ::rtl::OUString aTableRange; for (sal_uInt32 i = 0; i < pTableRefCommalist->count(); i++) { // from clause durchlaufen aTableRange = ::rtl::OUString(); - if (isTableNode(pTableRefCommalist->getChild(i))) + const OSQLParseNode* pTableListElement = pTableRefCommalist->getChild(i); + if ( isTableNode( pTableListElement ) ) { - pTableName = pTableRefCommalist->getChild(i); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_False);// aTableRange will be set inside to the tablename + traverseOneTableName( _rTables, pTableListElement, aTableRange ); } - else if (SQL_ISRULE(pTableRefCommalist->getChild(i),table_ref)) + else if ( SQL_ISRULE( pTableListElement, table_ref ) ) { // Tabellenreferenz kann aus Tabellennamen, Tabellennamen (+),'('joined_table')'(+) bestehen - pTableName = pTableRefCommalist->getChild(i)->getChild(0); - if(isTableNode(pTableName)) + pTableName = pTableListElement->getChild(0); + if( isTableNode( pTableName ) ) { // Tabellennamen gefunden - if(pTableRefCommalist->getChild(i)->count() == 4) // Tabellenrange an Pos 2 - aTableRange = pTableRefCommalist->getChild(i)->getChild(2)->getTokenValue(); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_False); + if ( pTableListElement->count() == 4 ) // Tabellenrange an Pos 2 + aTableRange = pTableListElement->getChild(2)->getTokenValue(); + traverseOneTableName( _rTables, pTableName, aTableRange ); } else if(SQL_ISPUNCTUATION(pTableName,"{")) - getQualified_join(_rTables,pTableRefCommalist->getChild(i)->getChild(2),aTableRange); + getQualified_join( _rTables, pTableListElement->getChild(2), aTableRange ); else // '(' joined_table ')' as range_variable op_column_commalist - getTableRef(_rTables,pTableRefCommalist->getChild(i),aTableRange); + getTableRef( _rTables, pTableListElement, aTableRange ); } - else if (SQL_ISRULE(pTableRefCommalist->getChild(i),qualified_join) || SQL_ISRULE(pTableRefCommalist->getChild(i),cross_union) ) + else if (SQL_ISRULE( pTableListElement, qualified_join ) || SQL_ISRULE( pTableListElement, cross_union ) ) { // qualified_join oder cross_union vorhanden - getQualified_join(_rTables,pTableRefCommalist->getChild(i),aTableRange); + getQualified_join( _rTables, pTableListElement, aTableRange ); } - else if (SQL_ISRULE(pTableRefCommalist->getChild(i),joined_table)) + else if ( SQL_ISRULE( pTableListElement, joined_table ) ) { // '(' qualified_join ')' - getQualified_join(_rTables,pTableRefCommalist->getChild(i)->getChild(1),aTableRange); + getQualified_join( _rTables, pTableListElement->getChild(1), aTableRange ); } // if (! aIteratorStatus.IsSuccessful()) break; @@ -466,38 +528,35 @@ return; } - OSQLParseNode * pTableName = NULL; - ::rtl::OUString aTableRange; + OSQLParseNode* pTableName = NULL; + bool bIsCreateTable = false; // pTableName auf den (einzigen) Tabellennamen im Statement setzen. // Je nach Statement (SELECT, INSERT, UPDATE, DELETE) an anderer Position. // Bei Select koennen mehrere Tabellennamen auftreten, bei den uebrigen Statements // ist ohnehin immer nur einer moeglich. - if (m_eStatementType == SQL_STATEMENT_SELECT) - { - OSQLParseNode *pTmp = (OSQLParseNode *)m_pParseTree; - getSelect_statement(_rTables,pTmp); - } - else if (m_eStatementType == SQL_STATEMENT_INSERT) + switch ( m_eStatementType ) { + case SQL_STATEMENT_SELECT: + getSelect_statement( _rTables, m_pParseTree ); + break; + + case SQL_STATEMENT_CREATE_TABLE: + case SQL_STATEMENT_INSERT: + case SQL_STATEMENT_DELETE: pTableName = m_pParseTree->getChild(2); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_False); - } - else if (m_eStatementType == SQL_STATEMENT_UPDATE) - { + break; + + case SQL_STATEMENT_UPDATE: pTableName = m_pParseTree->getChild(1); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_False); - } - else if (m_eStatementType == SQL_STATEMENT_DELETE) - { - pTableName = m_pParseTree->getChild(2); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_False); + break; } - else if (m_eStatementType == SQL_STATEMENT_CREATE_TABLE) + + if ( pTableName ) { - pTableName = m_pParseTree->getChild(2); - traverseOneTableName(_rTables,pTableName,aTableRange,sal_True); + ::rtl::OUString sTableRange; + traverseOneTableName( _rTables, pTableName, sTableRange ); } } //----------------------------------------------------------------------------- @@ -516,7 +575,7 @@ ::rtl::OUString &_rColumnName, ::rtl::OUString& _rTableRange) const { - getColumnRange( _pColumnRef,m_xDatabaseMetaData,_rColumnName,_rTableRange); + getColumnRange( _pColumnRef, m_pImpl->m_xDatabaseMetaData, _rColumnName, _rTableRange ); } //----------------------------------------------------------------------------- @@ -559,7 +618,7 @@ if (!aTableRange.getLength()) // keinen gefunden { // dann die Spalte in den Tabellen suchen - for (ConstOSQLTablesIterator aIter = m_aTables.begin(); aIter != m_aTables.end(); ++aIter) + for (ConstOSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end(); ++aIter) { if (aIter->second.is()) { @@ -608,10 +667,9 @@ { // aIteratorStatus.Clear(); - if (!pSelectNode || m_eStatementType != SQL_STATEMENT_CREATE_TABLE || m_aTables.empty()) + if (!pSelectNode || m_eStatementType != SQL_STATEMENT_CREATE_TABLE || m_pImpl->m_pTables->empty()) { - if(m_pParser) - appendWarning(m_pParser->getContext().getErrorMessage(IParseContext::ERROR_GENERAL)); + impl_appendError( IParseContext::ERROR_GENERAL ); return; } if (!SQL_ISRULE(pSelectNode,base_table_element_commalist)) @@ -653,7 +711,7 @@ { //TO DO:Create a new class for create statement to handle field length OParseColumn* pColumn = new OParseColumn(aColumnName,aTypeName,::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,nType,sal_False,sal_False,m_aCaseEqual.isCaseSensitive()); + ColumnValue::NULLABLE_UNKNOWN,0,0,nType,sal_False,sal_False,isCaseSensitive()); pColumn->setFunction(sal_False); pColumn->setRealName(aColumnName); @@ -670,10 +728,9 @@ // aIteratorStatus.Clear(); - if (!pSelectNode || m_eStatementType != SQL_STATEMENT_SELECT || m_aTables.empty()) + if (!pSelectNode || m_eStatementType != SQL_STATEMENT_SELECT || m_pImpl->m_pTables->empty()) { - if(m_pParser) - appendWarning(m_pParser->getContext().getErrorMessage(IParseContext::ERROR_GENERAL)); + impl_appendError( IParseContext::ERROR_GENERAL ); return; } @@ -707,7 +764,7 @@ { // alle Spalten der Tabelle ::rtl::OUString aTableRange; - pColumnRef->getChild(0)->parseNodeToStr(aTableRange,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pColumnRef->getChild(0)->parseNodeToStr( aTableRange, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); setSelectColumnName(m_aSelectColumns,::rtl::OUString::createFromAscii("*"), aEmptyString,aTableRange); continue; } @@ -737,16 +794,16 @@ SQL_ISRULE(pColumnRef,num_value_exp) || SQL_ISRULE(pColumnRef,term))*/ { /* Funktionsaufruf vorhanden */ - pColumnRef->parseNodeToStr(sColumnName,m_xDatabaseMetaData,NULL,sal_False,sal_True); + pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_True ); ::rtl::OUString sTableRange; // check if the column is also a parameter traverseORCriteria(pColumnRef); // num_value_exp traverseParameter(pColumnRef,NULL,sColumnName,sTableRange); // gehoeren alle beteiligten Spalten der Funktion zu einer Tabelle - if (m_aTables.size() == 1) + if (m_pImpl->m_pTables->size() == 1) { - aTableRange = m_aTables.begin()->first; + aTableRange = m_pImpl->m_pTables->begin()->first; } else { @@ -763,9 +820,11 @@ { ::rtl::OUString sFunctionName; if ( SQL_ISRULE(pColumnRef,length_exp) ) - pColumnRef->getChild(0)->getChild(0)->parseNodeToStr(sFunctionName,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pColumnRef->getChild(0)->getChild(0)->parseNodeToStr( + sFunctionName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); else - pColumnRef->getChild(0)->parseNodeToStr(sFunctionName,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pColumnRef->getChild(0)->parseNodeToStr( + sFunctionName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); nType = ::connectivity::OSQLParser::getFunctionReturnType(sFunctionName,m_pParser ? &m_pParser->getContext() : NULL); } } @@ -858,13 +917,13 @@ if(SQL_ISRULE(pColumnRef,column_ref)) getColumnRange(pColumnRef,sColumnName,aTableRange); else // eine Expression - pColumnRef->parseNodeToStr(sColumnName,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); OSL_ENSURE(sColumnName.getLength(),"sColumnName darf nicht leer sein"); } else { // here I found a predicate - pColumnRef->parseNodeToStr(sColumnName,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); } OSL_ENSURE(pColumnRef != NULL,"OSQLParseTreeIterator: Fehler im Parse Tree"); if ( _bOrder ) @@ -949,15 +1008,10 @@ // // Und nun die Vergleichskriterien abarbeiten (rekursiv, alles ist erstmal ein OR-Kriterium): // - setORCriteriaPre(); - // if (! aIteratorStatus.IsSuccessful()) return; traverseORCriteria(pComparisonPredicate); // if (! aIteratorStatus.IsSuccessful()) return; - setORCriteriaPost(); - - // Fehler wird ggf. einfach weitergereicht. } //----------------------------------------------------------------------------- @@ -993,13 +1047,8 @@ } else { // AND-Kriterien ... - setANDCriteriaPre(); - // if (! aIteratorStatus.IsSuccessful()) break; - traverseANDCriteria(pSearchCondition->getChild(i)); // if (! aIteratorStatus.IsSuccessful()) break; - - setANDCriteriaPost(); } // if (! aIteratorStatus.IsSuccessful()) break; @@ -1007,13 +1056,8 @@ } else { // Nur *ein* Kriterium oder eine AND-Verknuepfung von Kriterien. // Direkt die AND-Kriterien behandeln. - setANDCriteriaPre(); - // if (! aIteratorStatus.IsSuccessful()) return; - traverseANDCriteria(pSearchCondition); // if (! aIteratorStatus.IsSuccessful()) return; - - setANDCriteriaPost(); } // Fehler einfach weiterreichen. @@ -1075,7 +1119,7 @@ ePredicateType = SQLFilterOperator::GREATER; ::rtl::OUString aValue; - pSearchCondition->getChild(2)->parseNodeToStr(aValue,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pSearchCondition->getChild(2)->parseNodeToStr( aValue, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); traverseOnePredicate(pSearchCondition->getChild(0),ePredicateType,aValue,sal_False,pSearchCondition->getChild(2)); // if (! aIteratorStatus.IsSuccessful()) // return; @@ -1114,7 +1158,7 @@ aValue = pNum_value_exp->getTokenValue(); else { - pNum_value_exp->parseNodeToStr(aValue,m_xDatabaseMetaData,NULL,sal_False,sal_False); + pNum_value_exp->parseNodeToStr( aValue, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); pParam = pNum_value_exp; } @@ -1125,18 +1169,14 @@ else if (SQL_ISRULE(pSearchCondition,in_predicate)) { OSL_ENSURE(pSearchCondition->count() == 4,"OSQLParseTreeIterator: Fehler im Parse Tree"); - setORCriteriaPre(); - // if (! aIteratorStatus.IsSuccessful()) return; traverseORCriteria(pSearchCondition->getChild(0)); // if (! aIteratorStatus.IsSuccessful()) return; - setORCriteriaPost(); - OSQLParseNode* pChild = pSearchCondition->getChild(3); if ( SQL_ISRULE(pChild->getChild(0),subquery) ) { - traverseTableNames(m_pImpl->m_aSubTables); + traverseTableNames( *m_pImpl->m_pSubTables ); traverseSelectionCriteria(pChild->getChild(0)->getChild(1)); } else @@ -1213,7 +1253,7 @@ if ( _pColumnRef && (SQL_ISRULE(_pColumnRef,general_set_fct) || SQL_ISRULE(_pColumnRef,set_fct_spec)) ) {// found a function as column_ref ::rtl::OUString sFunctionName; - _pColumnRef->getChild(0)->parseNodeToStr(sFunctionName,m_xDatabaseMetaData,NULL,sal_False,sal_False); + _pColumnRef->getChild(0)->parseNodeToStr( sFunctionName, m_pImpl->m_xDatabaseMetaData, NULL, sal_False, sal_False ); sal_Int32 nType = ::connectivity::OSQLParser::getFunctionReturnType(sFunctionName,m_pParser ? &m_pParser->getContext() : NULL); OParseColumn* pColumn = new OParseColumn( rValue , @@ -1225,7 +1265,7 @@ nType, sal_False, sal_False, - m_aCaseEqual.isCaseSensitive()); + isCaseSensitive()); pColumn->setFunction(sal_True); pColumn->setAggregateFunction(sal_True); pColumn->setRealName(sFunctionName); @@ -1234,10 +1274,14 @@ else { sal_Bool bNotFound = sal_True; - OSQLColumns::const_iterator aIter = ::connectivity::find(m_aSelectColumns->begin(),m_aSelectColumns->end(),_aColumnName,m_aCaseEqual); + OSQLColumns::const_iterator aIter = ::connectivity::find( + m_aSelectColumns->begin(), + m_aSelectColumns->end(), + _aColumnName,::comphelper::UStringMixEqual( isCaseSensitive() ) + ); if(aIter != m_aSelectColumns->end()) { - OParseColumn* pNewColumn = new OParseColumn(*aIter,m_aCaseEqual.isCaseSensitive()); + OParseColumn* pNewColumn = new OParseColumn(*aIter,isCaseSensitive()); pNewColumn->setName(rValue); pNewColumn->setRealName(_aColumnName); m_aParameters->push_back(pNewColumn); @@ -1246,13 +1290,11 @@ else if(_aColumnName.getLength())// search in the tables for the right one { - Reference<XPropertySet> xColumn = findColumn(m_aTables,_aColumnName,_aTableRange); - if ( !xColumn.is() ) - xColumn = findColumn(m_pImpl->m_aSubTables,_aColumnName,_aTableRange); + Reference<XPropertySet> xColumn = findColumn( _aColumnName, _aTableRange, true ); if ( xColumn.is() ) { - OParseColumn* pNewColumn = new OParseColumn(xColumn,m_aCaseEqual.isCaseSensitive()); + OParseColumn* pNewColumn = new OParseColumn(xColumn,isCaseSensitive()); pNewColumn->setName(rValue); pNewColumn->setRealName(_aColumnName); m_aParameters->push_back(pNewColumn); @@ -1272,7 +1314,7 @@ DataType::VARCHAR, sal_False, sal_False, - m_xDatabaseMetaData.is() && m_xDatabaseMetaData->storesMixedCaseQuotedIdentifiers()); + isCaseSensitive() ); pColumn->setName(rValue); pColumn->setRealName(rValue); m_aParameters->push_back(pColumn); @@ -1304,42 +1346,23 @@ getColumnRange(pParseNode,aName,rValue); else { - setORCriteriaPre(); - // if (! aIteratorStatus.IsSuccessful()) return; - traverseORCriteria(pParseNode); // if (! aIteratorStatus.IsSuccessful()) return; - - setORCriteriaPost(); } } - // "set"-Routine aufrufen ... - if (bCompareNull) { - // nyi: was soll das? Vergleich auf NULL geht nur ueber IS NULL oder IS NOT NULL! - setPredicate(aColumnName, aTableRange,ePredicateType, ::rtl::OUString(), ::rtl::OUString()); - } else { - setPredicate(aColumnName, aTableRange, ePredicateType, rValue, aName); - } - // Fehler einfach weiterreichen ... } //----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseAssignments() -{ - - - OSL_ASSERT("OSQLParseTreeIterator::traverseAssignments: noch nicht implementiert"); -} - -//----------------------------------------------------------------------------- void OSQLParseTreeIterator::traverseAll() { - traverseTableNames(m_aTables); + traverseTableNames( *m_pImpl->m_pTables ); // if (! aIteratorStatus.IsSuccessful()) return; - if (m_eStatementType == SQL_STATEMENT_SELECT) + switch ( m_eStatementType ) + { + case SQL_STATEMENT_SELECT: { const OSQLParseNode* pSelectNode = m_pParseTree; traverseSelectColumnNames(pSelectNode); @@ -1353,43 +1376,44 @@ // if (! aIteratorStatus.IsSuccessful()) // return; } - else if (m_eStatementType == SQL_STATEMENT_INSERT || m_eStatementType == SQL_STATEMENT_UPDATE) + break; + case SQL_STATEMENT_CREATE_TABLE: { - traverseAssignments(); - // if (! aIteratorStatus.IsSuccessful()) - // return; - } else if (m_eStatementType == SQL_STATEMENT_INSERT) { - // schon alles erledigt - } else if (m_eStatementType == SQL_STATEMENT_CREATE_TABLE) { //0 | 1 | 2 |3| 4 |5 //create table sc.foo ( a char(20), b char ) const OSQLParseNode* pCreateNode = m_pParseTree->getChild(4); traverseCreateColumns(pCreateNode); } + break; + + case SQL_STATEMENT_INSERT: + case SQL_STATEMENT_UPDATE: + OSL_ENSURE( false, "OSQLParseTreeIterator::traverseAll: not yet implemented for this statement type!" ); + break; + } } // Dummy-Implementationen: //----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setTableName(const ::rtl::OUString & rTableName, const ::rtl::OUString & rCatalogName, const ::rtl::OUString& rSchemaName, - const ::rtl::OUString & rTableRange) +OSQLTable OSQLParseTreeIterator::impl_createTableObject( const ::rtl::OUString& rTableName, + const ::rtl::OUString& rCatalogName, const ::rtl::OUString& rSchemaName ) { + OSL_PRECOND( m_eStatementType == SQL_STATEMENT_CREATE_TABLE, + "OSQLParseTreeIterator::impl_createTableObject: only to be called for CREATE TABLE statements!" ); + // (in all other cases, m_pTables is to contain the table objects as obtained from the tables + // container of the connection (m_xTablesContainer) - // nichts zu tun ... - OTable * xTab=new OTable(NULL,sal_False,rTableName - ,::rtl::OUString::createFromAscii("Table") - ,::rtl::OUString::createFromAscii("New Created Table") - ,rSchemaName,rCatalogName); - - m_aTables[rTableRange] = xTab; -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setTableName" - << (const char *) rTableName << ", " - << (const char *) rCatalogName << ", " - << (const char *) rSchemaName << ", " - << (const char *) rTableRange - << "\n"; -#endif + OSQLTable aReturnTable = new OTable( + NULL, + sal_False, + rTableName, + ::rtl::OUString::createFromAscii("Table"), + ::rtl::OUString::createFromAscii("New Created Table"), + rSchemaName, + rCatalogName + ); + return aReturnTable; } //----------------------------------------------------------------------------- void OSQLParseTreeIterator::appendColumns(::vos::ORef<OSQLColumns>& _rColumns,const ::rtl::OUString& _rTableAlias,const OSQLTable& _rTable) @@ -1406,7 +1430,6 @@ const ::rtl::OUString* pBegin = aColNames.getConstArray(); const ::rtl::OUString* pEnd = pBegin + aColNames.getLength(); - sal_Bool bCase = m_xDatabaseMetaData.is() && m_xDatabaseMetaData->storesMixedCaseQuotedIdentifiers(); for(;pBegin != pEnd;++pBegin) { @@ -1423,21 +1446,15 @@ , getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))) , getBOOL(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))) , getBOOL(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY))) - , bCase); + , isCaseSensitive() ); pColumn->setTableName(_rTableAlias); pColumn->setRealName(*pBegin); Reference< XPropertySet> xCol = pColumn; _rColumns->push_back(xCol); } - else if(m_pParser) - { - ::rtl::OUString sErrMsg = m_pParser->getContext().getErrorMessage(IParseContext::ERROR_INVALID_COLUMN); - sErrMsg = sErrMsg.replaceAt(sErrMsg.indexOf('#'),1,*pBegin); - sErrMsg = sErrMsg.replaceAt(sErrMsg.indexOf('#'),1,_rTableAlias); - appendWarning(sErrMsg); - } - + else + impl_appendError( IParseContext::ERROR_INVALID_COLUMN, pBegin, &_rTableAlias ); } } //----------------------------------------------------------------------------- @@ -1446,15 +1463,15 @@ if(rColumnName.toChar() == '*' && !rTableRange.getLength()) { // Suche "uber alle vorkommenden Tabellen OSL_ENSURE(_rColumns == m_aSelectColumns,"Invalid columns used here!"); - for(ConstOSQLTablesIterator aIter = m_aTables.begin(); aIter != m_aTables.end();++aIter) + for(ConstOSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end();++aIter) appendColumns(_rColumns,aIter->first,aIter->second); } else if(rColumnName.toChar() == '*' && rTableRange.getLength()) // alle Columns aus dieser Tabelle { OSL_ENSURE(_rColumns == m_aSelectColumns,"Invalid columns used here!"); - ConstOSQLTablesIterator aFind = m_aTables.find(rTableRange); + ConstOSQLTablesIterator aFind = m_pImpl->m_pTables->find(rTableRange); - if(aFind == m_aTables.end()) + if(aFind == m_pImpl->m_pTables->end()) { ::rtl::OUString strExpression = rTableRange; strExpression += ::rtl::OUString::createFromAscii("."); @@ -1469,7 +1486,7 @@ { sal_uInt32 ncount = _rColumns->size(); - for(OSQLTablesIterator aIter = m_aTables.begin(); aIter != m_aTables.end(); ++aIter) + for(OSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end(); ++aIter) { if (aIter->second.is()) { @@ -1482,7 +1499,7 @@ ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); Reference< XPropertySet> xCol; - OParseColumn* pColumn = new OParseColumn(xColumn,m_aCaseEqual.isCaseSensitive()); + OParseColumn* pColumn = new OParseColumn(xColumn,isCaseSensitive()); xCol = pColumn; pColumn->setTableName(aIter->first); pColumn->setName(aNewColName); @@ -1506,7 +1523,7 @@ ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); OParseColumn* pColumn = new OParseColumn(aNewColName,::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,m_aCaseEqual.isCaseSensitive()); + ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,isCaseSensitive()); pColumn->setFunction(bFkt); pColumn->setAggregateFunction(bAggFkt); pColumn->setRealName(rColumnName); @@ -1517,17 +1534,17 @@ } else // ColumnName und Tablename vorhanden { - ConstOSQLTablesIterator aFind = m_aTables.find(rTableRange); + ConstOSQLTablesIterator aFind = m_pImpl->m_pTables->find(rTableRange); sal_Bool bError = sal_False; - if (aFind != m_aTables.end() && aFind->second.is()) + if (aFind != m_pImpl->m_pTables->end() && aFind->second.is()) { if (bFkt) { ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); OParseColumn* pColumn = new OParseColumn(aNewColName,::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,m_aCaseEqual.isCaseSensitive()); + ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,isCaseSensitive()); pColumn->setFunction(sal_True); pColumn->setAggregateFunction(bAggFkt); pColumn->setRealName(rColumnName); @@ -1543,7 +1560,7 @@ { ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); - OParseColumn* pColumn = new OParseColumn(xColumn,m_aCaseEqual.isCaseSensitive()); + OParseColumn* pColumn = new OParseColumn(xColumn,isCaseSensitive()); pColumn->setName(aNewColName); pColumn->setRealName(rColumnName); pColumn->setTableName(aFind->first); @@ -1569,7 +1586,7 @@ ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); OParseColumn* pColumn = new OParseColumn(aNewColName,::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,DataType::VARCHAR,sal_False,sal_False,m_aCaseEqual.isCaseSensitive()); + ColumnValue::NULLABLE_UNKNOWN,0,0,DataType::VARCHAR,sal_False,sal_False,isCaseSensitive()); pColumn->setFunction(sal_True); pColumn->setAggregateFunction(bAggFkt); @@ -1583,26 +1600,36 @@ { ::rtl::OUString aAlias(rColumnName); - OSQLColumns::const_iterator aIter = find(m_aSelectColumns->begin(),m_aSelectColumns->end(),aAlias,m_aCaseEqual); + OSQLColumns::const_iterator aIter = find( + m_aSelectColumns->begin(), + m_aSelectColumns->end(), + aAlias, + ::comphelper::UStringMixEqual( isCaseSensitive() ) + ); sal_Int32 i=1; while(aIter != m_aSelectColumns->end()) { (aAlias = rColumnName) += ::rtl::OUString::valueOf(i++); - aIter = find(m_aSelectColumns->begin(),m_aSelectColumns->end(),aAlias,m_aCaseEqual); + aIter = find( + m_aSelectColumns->begin(), + m_aSelectColumns->end(), + aAlias, + ::comphelper::UStringMixEqual( isCaseSensitive() ) + ); } return aAlias; } //----------------------------------------------------------------------------- void OSQLParseTreeIterator::setOrderByColumnName(const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange,sal_Bool bAscending) { - Reference<XPropertySet> xColumn = findColumn(m_aTables,rColumnName,rTableRange); + Reference<XPropertySet> xColumn = findColumn( rColumnName, rTableRange, false ); if ( xColumn.is() ) - m_aOrderColumns->push_back(new OOrderColumn(xColumn,m_aCaseEqual.isCaseSensitive(),bAscending)); + m_aOrderColumns->push_back(new OOrderColumn(xColumn,isCaseSensitive(),bAscending)); else { sal_Int32 nId = rColumnName.toInt32(); if ( nId > 0 && nId < static_cast<sal_Int32>(m_aSelectColumns->size()) ) - m_aOrderColumns->push_back(new OOrderColumn((*m_aSelectColumns)[nId-1],m_aCaseEqual.isCaseSensitive(),bAscending)); + m_aOrderColumns->push_back(new OOrderColumn((*m_aSelectColumns)[nId-1],isCaseSensitive(),bAscending)); } #ifdef SQL_TEST_PARSETREEITERATOR @@ -1616,14 +1643,14 @@ //----------------------------------------------------------------------------- void OSQLParseTreeIterator::setGroupByColumnName(const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange) { - Reference<XPropertySet> xColumn = findColumn(m_aTables,rColumnName,rTableRange); + Reference<XPropertySet> xColumn = findColumn( rColumnName, rTableRange, false ); if ( xColumn.is() ) - m_aGroupColumns->push_back(new OParseColumn(xColumn,m_aCaseEqual.isCaseSensitive())); + m_aGroupColumns->push_back(new OParseColumn(xColumn,isCaseSensitive())); else { sal_Int32 nId = rColumnName.toInt32(); if ( nId > 0 && nId < static_cast<sal_Int32>(m_aSelectColumns->size()) ) - m_aGroupColumns->push_back(new OParseColumn((*m_aSelectColumns)[nId-1],m_aCaseEqual.isCaseSensitive())); + m_aGroupColumns->push_back(new OParseColumn((*m_aSelectColumns)[nId-1],isCaseSensitive())); } #ifdef SQL_TEST_PARSETREEITERATOR @@ -1634,89 +1661,6 @@ << "\n"; #endif } -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setORCriteriaPre() -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setORCriteriaPre\n"; -#endif -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setORCriteriaPost() -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setORCriteriaPost\n"; -#endif -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setANDCriteriaPre() -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setANDCriteriaPre\n"; -#endif -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setANDCriteriaPost() -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setANDCriteriaPost\n"; -#endif -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setPredicate(const ::rtl::OUString & rColumnName, - const ::rtl::OUString & rTableRange, - sal_Int32 ePredicateType, - const ::rtl::OUString & rValue, - const ::rtl::OUString & rParameterName) -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setPredicate: " - << (const char *) rColumnName << ", " - << (const char *) rTableRange << ", " - << (char) ePredicateType << ", " - << (const char *) rValue << ", " - << (const char *) rParameterName - << "\n"; -#endif -} - - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setAssign(const ::rtl::OUString & rColumnName, - const ::rtl::OUString & rValue, sal_Bool bsetNull, - const ::rtl::OUString & rParameterName) -{ - - // nichts zu tun ... - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setAssign: " - << (const char *) rColumnName << ", " - << (const char *) rValue << ", " - << (bsetNull ? "sal_True" : "sal_False") << ", " - << (const char *) rParameterName - << "\n"; -#endif -} //----------------------------------------------------------------------------- const OSQLParseNode* OSQLParseTreeIterator::getWhereTree() const @@ -1822,23 +1766,6 @@ SQL_ISRULE(_pTableNode,table_name)); } // ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::appendWarning(const ::rtl::OUString& _sErrMsg) -{ - OSL_ENSURE(m_pParser,"This should normally be checked outside!"); - if(m_pParser) - { - if(m_aWarning.Message.getLength()) - { - SQLWarning aWarning = m_aWarning; - while(aWarning.NextException.hasValue()) - aWarning.NextException >>= aWarning; - aWarning.NextException <<= SQLWarning(_sErrMsg,NULL,OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_HY0000),1000,Any()); - } - else - m_aWarning = SQLWarning(_sErrMsg,NULL,OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_HY0000),1000,Any()); - } -} -// ----------------------------------------------------------------------------- const OSQLParseNode* OSQLParseTreeIterator::getSimpleWhereTree() const { const OSQLParseNode* pNode = getWhereTree(); @@ -1862,6 +1789,16 @@ const OSQLParseNode* pNode = getHavingTree(); return pNode ? pNode->getChild(1) : NULL; } + +// ----------------------------------------------------------------------------- +Reference< XPropertySet > OSQLParseTreeIterator::findColumn( const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange, bool _bLookInSubTables ) +{ + Reference< XPropertySet > xColumn = findColumn( *m_pImpl->m_pTables, rColumnName, rTableRange ); + if ( !xColumn.is() && _bLookInSubTables ) + xColumn = findColumn( *m_pImpl->m_pSubTables, rColumnName, rTableRange ); + return xColumn; +} + // ----------------------------------------------------------------------------- Reference< XPropertySet > OSQLParseTreeIterator::findColumn(const OSQLTables& _rTables,const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange) { @@ -1894,4 +1831,33 @@ } return xColumn; } + // ----------------------------------------------------------------------------- +void OSQLParseTreeIterator::impl_appendError( IParseContext::ErrorCode _eError, const ::rtl::OUString* _pReplaceToken1, const ::rtl::OUString* _pReplaceToken2 ) +{ + OSL_ENSURE( m_pParser, "OSQLParseTreeIterator::impl_appendError: no parser!" ); + // Is this really a valid scenario? Calling this method without a parser? + if ( !m_pParser ) + return; + + ::rtl::OUString sErrorMessage = m_pParser->getContext().getErrorMessage( _eError ); + if ( _pReplaceToken1 ) + { + sErrorMessage = sErrorMessage.replaceAt( sErrorMessage.indexOf('#'), 1, *_pReplaceToken1 ); + if ( _pReplaceToken2 ) + sErrorMessage = sErrorMessage.replaceAt( sErrorMessage.indexOf('#'), 1, *_pReplaceToken2 ); + } + + SQLException aAppendError( + sErrorMessage, NULL, OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_HY0000 ), 1000, Any() ); + + if ( m_aErrors.Message.getLength() ) + { + SQLException* pErrorChain = &m_aErrors; + while ( pErrorChain->NextException.hasValue() ) + pErrorChain = static_cast< SQLException* >( pErrorChain->NextException.pData ); + pErrorChain->NextException <<= aAppendError; + } + else + m_aErrors = aAppendError; +} --------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]
