diff options
Diffstat (limited to 'connectivity/source/parse')
| -rw-r--r-- | connectivity/source/parse/PColumn.cxx | 298 | ||||
| -rw-r--r-- | connectivity/source/parse/internalnode.cxx | 88 | ||||
| -rwxr-xr-x | connectivity/source/parse/makefile.mk | 67 | ||||
| -rwxr-xr-x | connectivity/source/parse/sqlbison.y | 4828 | ||||
| -rwxr-xr-x | connectivity/source/parse/sqlflex.l | 836 | ||||
| -rw-r--r-- | connectivity/source/parse/sqliterator.cxx | 2249 | ||||
| -rw-r--r-- | connectivity/source/parse/sqlnode.cxx | 2838 | ||||
| -rw-r--r-- | connectivity/source/parse/wrap_sqlbison.cxx | 34 | ||||
| -rw-r--r-- | connectivity/source/parse/wrap_sqlflex.cxx | 38 |
9 files changed, 0 insertions, 11276 deletions
diff --git a/connectivity/source/parse/PColumn.cxx b/connectivity/source/parse/PColumn.cxx deleted file mode 100644 index 0c1c95fa7f..0000000000 --- a/connectivity/source/parse/PColumn.cxx +++ /dev/null @@ -1,298 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" - -#include "connectivity/PColumn.hxx" -#include "connectivity/dbtools.hxx" -#include "TConnection.hxx" - -#include <comphelper/types.hxx> -#include <tools/diagnose_ex.h> - -using namespace ::comphelper; -using namespace connectivity; -using namespace dbtools; -using namespace connectivity::parse; -using namespace ::com::sun::star::uno; -using namespace ::com::sun::star::sdbc; -using namespace ::com::sun::star::beans; -using namespace ::com::sun::star::container; - -// ------------------------------------------------------------------------- -OParseColumn::OParseColumn(const Reference<XPropertySet>& _xColumn,sal_Bool _bCase) - : connectivity::sdbcx::OColumn( getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))) - , getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))) - , getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE))) - , getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION))) - , getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))) - , getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))) - , getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))) - , getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))) - , getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))) - , sal_False - , getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY))) - , _bCase - ) - , m_bFunction(sal_False) - , m_bDbasePrecisionChanged(sal_False) - , m_bAggregateFunction(sal_False) - , m_bIsSearchable( sal_True ) -{ - construct(); -} - -// ------------------------------------------------------------------------- -OParseColumn::OParseColumn( const ::rtl::OUString& _Name, - const ::rtl::OUString& _TypeName, - const ::rtl::OUString& _DefaultValue, - const ::rtl::OUString& _Description, - sal_Int32 _IsNullable, - sal_Int32 _Precision, - sal_Int32 _Scale, - sal_Int32 _Type, - sal_Bool _IsAutoIncrement, - sal_Bool _IsCurrency, - sal_Bool _bCase - ) : connectivity::sdbcx::OColumn(_Name, - _TypeName, - _DefaultValue, - _Description, - _IsNullable, - _Precision, - _Scale, - _Type, - _IsAutoIncrement, - sal_False, - _IsCurrency, - _bCase) - , m_bFunction(sal_False) - , m_bDbasePrecisionChanged(sal_False) - , m_bAggregateFunction(sal_False) - , m_bIsSearchable( sal_True ) -{ - construct(); -} - -// ------------------------------------------------------------------------- -::rtl::Reference< OSQLColumns > OParseColumn::createColumnsForResultSet( const Reference< XResultSetMetaData >& _rxResMetaData, - const Reference< XDatabaseMetaData >& _rxDBMetaData,const Reference< XNameAccess>& i_xQueryColumns ) -{ - sal_Int32 nColumnCount = _rxResMetaData->getColumnCount(); - ::rtl::Reference< OSQLColumns > aReturn( new OSQLColumns ); aReturn->get().reserve( nColumnCount ); - - StringMap aColumnMap; - for ( sal_Int32 i = 1; i <= nColumnCount; ++i ) - { - OParseColumn* pColumn = createColumnForResultSet( _rxResMetaData, _rxDBMetaData, i,aColumnMap ); - aReturn->get().push_back( pColumn ); - if ( i_xQueryColumns.is() && i_xQueryColumns->hasByName(pColumn->getRealName()) ) - { - Reference<XPropertySet> xColumn(i_xQueryColumns->getByName(pColumn->getRealName()),UNO_QUERY_THROW); - ::rtl::OUString sLabel; - xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_LABEL)) >>= sLabel; - if ( sLabel.getLength() ) - pColumn->setLabel(sLabel); - } - } - - return aReturn; -} - -// ------------------------------------------------------------------------- -OParseColumn* OParseColumn::createColumnForResultSet( const Reference< XResultSetMetaData >& _rxResMetaData, - const Reference< XDatabaseMetaData >& _rxDBMetaData, sal_Int32 _nColumnPos,StringMap& _rColumns ) -{ - ::rtl::OUString sLabel = _rxResMetaData->getColumnLabel( _nColumnPos ); - // retrieve the name of the column - // check for duplicate entries - if(_rColumns.find(sLabel) != _rColumns.end()) - { - ::rtl::OUString sAlias(sLabel); - sal_Int32 searchIndex=1; - while(_rColumns.find(sAlias) != _rColumns.end()) - { - (sAlias = sLabel) += ::rtl::OUString::valueOf(searchIndex++); - } - sLabel = sAlias; - } - _rColumns.insert(StringMap::value_type(sLabel,0)); - OParseColumn* pColumn = new OParseColumn( - sLabel, - _rxResMetaData->getColumnTypeName( _nColumnPos ), - ::rtl::OUString(), - ::rtl::OUString(), - _rxResMetaData->isNullable( _nColumnPos ), - _rxResMetaData->getPrecision( _nColumnPos ), - _rxResMetaData->getScale( _nColumnPos ), - _rxResMetaData->getColumnType( _nColumnPos ), - _rxResMetaData->isAutoIncrement( _nColumnPos ), - _rxResMetaData->isCurrency( _nColumnPos ), - _rxDBMetaData->supportsMixedCaseQuotedIdentifiers() - ); - const ::rtl::OUString sTableName = _rxResMetaData->getTableName( _nColumnPos ); - if ( sTableName.getLength() ) - pColumn->setTableName( ::dbtools::composeTableName( _rxDBMetaData, - _rxResMetaData->getCatalogName( _nColumnPos ), - _rxResMetaData->getSchemaName( _nColumnPos ), - sTableName, - sal_False, - eComplete - ) ); - pColumn->setIsSearchable( _rxResMetaData->isSearchable( _nColumnPos ) ); - pColumn->setRealName(_rxResMetaData->getColumnName( _nColumnPos )); - pColumn->setLabel(sLabel); - return pColumn; -} - -// ------------------------------------------------------------------------- -OParseColumn::~OParseColumn() -{ -} -// ------------------------------------------------------------------------- -void OParseColumn::construct() -{ - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FUNCTION), PROPERTY_ID_FUNCTION, 0, &m_bFunction, ::getCppuType(reinterpret_cast< sal_Bool*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_AGGREGATEFUNCTION), PROPERTY_ID_AGGREGATEFUNCTION, 0, &m_bAggregateFunction, ::getCppuType(reinterpret_cast< sal_Bool*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TABLENAME), PROPERTY_ID_TABLENAME, 0, &m_aTableName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME), PROPERTY_ID_REALNAME, 0, &m_aRealName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DBASEPRECISIONCHANGED), PROPERTY_ID_DBASEPRECISIONCHANGED, 0, &m_bDbasePrecisionChanged, ::getCppuType(reinterpret_cast<sal_Bool*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISSEARCHABLE), PROPERTY_ID_ISSEARCHABLE, 0, &m_bIsSearchable, ::getCppuType(reinterpret_cast< sal_Bool*>(NULL))); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_LABEL), PROPERTY_ID_LABEL, 0, &m_sLabel, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); -} -// ----------------------------------------------------------------------------- -::cppu::IPropertyArrayHelper* OParseColumn::createArrayHelper() const -{ - return doCreateArrayHelper(); -} -// ----------------------------------------------------------------------------- -::cppu::IPropertyArrayHelper & SAL_CALL OParseColumn::getInfoHelper() -{ - OSL_ENSURE( !isNew(), "OParseColumn::getInfoHelper: a *new* ParseColumn?" ); - return *OParseColumn_PROP::getArrayHelper(); -} - -// ----------------------------------------------------------------------------- -namespace -{ - ::rtl::OUString lcl_getColumnTableName( const Reference< XPropertySet >& i_parseColumn ) - { - ::rtl::OUString sColumnTableName; - try - { - OSL_VERIFY( i_parseColumn->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_TABLENAME ) ) >>= sColumnTableName ); - } - catch( const Exception& ) - { - DBG_UNHANDLED_EXCEPTION(); - } - return sColumnTableName; - } -} - -// ----------------------------------------------------------------------------- -OOrderColumn::OOrderColumn( const Reference<XPropertySet>& _xColumn, const ::rtl::OUString& i_rOriginatingTableName, - sal_Bool _bCase, sal_Bool _bAscending ) - : connectivity::sdbcx::OColumn( - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))), - getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))), - sal_False, - getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY))), - _bCase - ) - ,m_bAscending(_bAscending) - ,m_sTableName( i_rOriginatingTableName ) -{ - construct(); -} - -// ----------------------------------------------------------------------------- -OOrderColumn::OOrderColumn( const Reference<XPropertySet>& _xColumn, sal_Bool _bCase, sal_Bool _bAscending ) - : connectivity::sdbcx::OColumn( - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE))), - getString(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))), - getINT32(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))), - getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))), - sal_False, - getBOOL(_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY))), - _bCase - ) - ,m_bAscending(_bAscending) - ,m_sTableName( lcl_getColumnTableName( _xColumn ) ) -{ - construct(); -} - -// ------------------------------------------------------------------------- -OOrderColumn::~OOrderColumn() -{ -} - -// ------------------------------------------------------------------------- -void OOrderColumn::construct() -{ - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISASCENDING), PROPERTY_ID_ISASCENDING, - PropertyAttribute::READONLY, const_cast< sal_Bool* >( &m_bAscending ), ::getCppuType( reinterpret_cast< sal_Bool* >( NULL ) ) ); - registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TABLENAME), PROPERTY_ID_TABLENAME, - PropertyAttribute::READONLY, const_cast< ::rtl::OUString* >( &m_sTableName ), ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); -} -// ----------------------------------------------------------------------------- -::cppu::IPropertyArrayHelper* OOrderColumn::createArrayHelper() const -{ - return doCreateArrayHelper(); -} -// ----------------------------------------------------------------------------- -::cppu::IPropertyArrayHelper & SAL_CALL OOrderColumn::getInfoHelper() -{ - OSL_ENSURE( !isNew(), "OOrderColumn::getInfoHelper: a *new* OrderColumn?" ); - return *OOrderColumn_PROP::getArrayHelper(); -} -// ----------------------------------------------------------------------------- -::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL OOrderColumn::getSupportedServiceNames( ) throw(::com::sun::star::uno::RuntimeException) -{ - ::com::sun::star::uno::Sequence< ::rtl::OUString > aSupported(1); - aSupported[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.OrderColumn")); - - return aSupported; -} -// ----------------------------------------------------------------------------- - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/parse/internalnode.cxx b/connectivity/source/parse/internalnode.cxx deleted file mode 100644 index a6c84f72a0..0000000000 --- a/connectivity/source/parse/internalnode.cxx +++ /dev/null @@ -1,88 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" -#include "internalnode.hxx" - -#include <algorithm> -#include <connectivity/sqlparse.hxx> - -using namespace connectivity; - -//----------------------------------------------------------------------------- -OSQLInternalNode::OSQLInternalNode(const sal_Char* pNewValue, - SQLNodeType eNodeType, - sal_uInt32 nNodeID) - : OSQLParseNode(pNewValue,eNodeType,nNodeID) -{ - OSL_ENSURE(OSQLParser::s_pGarbageCollector, "Collector not initialized"); - (*OSQLParser::s_pGarbageCollector)->push_back(this); -} - -//----------------------------------------------------------------------------- -OSQLInternalNode::OSQLInternalNode(const ::rtl::OString &_NewValue, - SQLNodeType eNodeType, - sal_uInt32 nNodeID) - :OSQLParseNode(_NewValue,eNodeType,nNodeID) -{ - OSL_ENSURE(OSQLParser::s_pGarbageCollector, "Collector not initialized"); - (*OSQLParser::s_pGarbageCollector)->push_back(this); -} - -//----------------------------------------------------------------------------- -OSQLInternalNode::OSQLInternalNode(const sal_Unicode* pNewValue, - SQLNodeType eNodeType, - sal_uInt32 nNodeID) - :OSQLParseNode(pNewValue,eNodeType,nNodeID) -{ - OSL_ENSURE(OSQLParser::s_pGarbageCollector, "Collector not initialized"); - (*OSQLParser::s_pGarbageCollector)->push_back(this); -} - -//----------------------------------------------------------------------------- -OSQLInternalNode::OSQLInternalNode(const ::rtl::OUString &_NewValue, - SQLNodeType eNodeType, - sal_uInt32 nNodeID) - :OSQLParseNode(_NewValue,eNodeType,nNodeID) -{ - OSL_ENSURE(OSQLParser::s_pGarbageCollector, "Collector not initialized"); - (*OSQLParser::s_pGarbageCollector)->push_back(this); -} - - -//----------------------------------------------------------------------------- -OSQLInternalNode::~OSQLInternalNode() -{ - // remove the node from the garbage list - - OSL_ENSURE(OSQLParser::s_pGarbageCollector, "Collector not initialized"); - (*OSQLParser::s_pGarbageCollector)->erase(this); -} - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/parse/makefile.mk b/connectivity/source/parse/makefile.mk deleted file mode 100755 index 510fbb2fc2..0000000000 --- a/connectivity/source/parse/makefile.mk +++ /dev/null @@ -1,67 +0,0 @@ -#************************************************************************* -# -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# Copyright 2000, 2010 Oracle and/or its affiliates. -# -# OpenOffice.org - a multi-platform office productivity suite -# -# This file is part of OpenOffice.org. -# -# OpenOffice.org is free software: you can redistribute it and/or modify -# it under the terms of the GNU Lesser General Public License version 3 -# only, as published by the Free Software Foundation. -# -# OpenOffice.org is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU Lesser General Public License version 3 for more details -# (a copy is included in the LICENSE file that accompanied this code). -# -# You should have received a copy of the GNU Lesser General Public License -# version 3 along with OpenOffice.org. If not, see -# <http://www.openoffice.org/license.html> -# for a copy of the LGPLv3 License. -# -#************************************************************************* - -PRJ=..$/.. - -PRJNAME=connectivity -TARGET=sql -INCPRE=$(MISC) - -# --- Settings ----------------------------------------------------- - -.INCLUDE : settings.mk -.INCLUDE : $(PRJ)$/dbtools.pmk - -# --- Files -------------------------------------------------------- - -YACCTARGET= $(MISC)$/sqlbison.cxx -YACCFILES= sqlbison.y -YACCFLAGS=-v -d -l -pSQLyy -bsql - -EXCEPTIONSFILES = \ - $(SLO)$/PColumn.obj \ - $(SLO)$/internalnode.obj \ - $(SLO)$/sqliterator.obj \ - $(SLO)$/sqlnode.obj \ - $(SLO)$/wrap_sqlbison.obj \ - $(SLO)$/wrap_sqlflex.obj - -SLOFILES = \ - $(EXCEPTIONSFILES) - - -# --- Targets ------------------------------------------------------- - -.INCLUDE : target.mk - -$(MISC)$/%.cxx: %.l - flex -i -8 -PSQLyy -L -o$(MISC)$/sqlflex.cxx sqlflex.l - -$(INCCOM)$/sqlbison.hxx : $(YACCTARGET) -$(EXCEPTIONSFILES) : $(INCCOM)$/sqlbison.hxx -$(SLO)$/wrap_sqlbison.obj : $(YACCTARGET) -$(SLO)$/wrap_sqlflex.obj : $(MISC)$/sqlflex.cxx $(INCCOM)$/sqlbison.hxx diff --git a/connectivity/source/parse/sqlbison.y b/connectivity/source/parse/sqlbison.y deleted file mode 100755 index 1f2c577b8d..0000000000 --- a/connectivity/source/parse/sqlbison.y +++ /dev/null @@ -1,4828 +0,0 @@ -%{ -//-------------------------------------------------------------------------- -// -// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -// -// Copyright 2000, 2010 Oracle and/or its affiliates. -// -// OpenOffice.org - a multi-platform office productivity suite -// -// This file is part of OpenOffice.org. -// -// OpenOffice.org is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License version 3 -// only, as published by the Free Software Foundation. -// -// OpenOffice.org is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License version 3 for more details -// (a copy is included in the LICENSE file that accompanied this code). -// -// You should have received a copy of the GNU Lesser General Public License -// version 3 along with OpenOffice.org. If not, see -// <http://www.openoffice.org/license.html> -// for a copy of the LGPLv3 License. -// -//-------------------------------------------------------------------------- - -#include <vector> -#include <string.h> - -#ifndef _CONNECTIVITY_SQLNODE_HXX -#include <connectivity/sqlnode.hxx> -#endif -#ifndef _CONNECTIVITY_SQLPARSE_HXX -#include <connectivity/sqlparse.hxx> -#endif -#ifndef _CONNECTIVITY_SQLINTERNALNODE_HXX -#include <internalnode.hxx> -#endif -#ifndef _COM_SUN_STAR_LANG_LOCALE_HPP_ -#include <com/sun/star/lang/Locale.hpp> -#endif -#ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ -#include <com/sun/star/sdbc/DataType.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_DATE_HPP_ -#include <com/sun/star/util/Date.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_DATETIME_HPP_ -#include <com/sun/star/util/DateTime.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_TIME_HPP_ -#include <com/sun/star/util/Time.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTER_HPP_ -#include <com/sun/star/util/XNumberFormatter.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATSSUPPLIER_HPP_ -#include <com/sun/star/util/XNumberFormatsSupplier.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATS_HPP_ -#include <com/sun/star/util/XNumberFormats.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_NUMBERFORMAT_HPP_ -#include <com/sun/star/util/NumberFormat.hpp> -#endif -#ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTYPES_HPP_ -#include <com/sun/star/util/XNumberFormatTypes.hpp> -#endif -#ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_ -#include <com/sun/star/beans/XPropertySet.hpp> -#endif -#ifndef _COM_SUN_STAR_I18N_KPARSETYPE_HPP_ -#include <com/sun/star/i18n/KParseType.hpp> -#endif -#ifndef _COM_SUN_STAR_I18N_KPARSETOKENS_HPP_ -#include <com/sun/star/i18n/KParseTokens.hpp> -#endif -#ifndef _CONNECTIVITY_SQLSCAN_HXX -#include "sqlscan.hxx" -#endif -#ifndef _OSL_DIAGNOSE_H_ -#include <osl/diagnose.h> -#endif -#ifndef _DBHELPER_DBCONVERSION_HXX_ -#include "connectivity/dbconversion.hxx" -#endif -#include <rtl/ustrbuf.hxx> -#include <sal/macros.h> - -#if defined __GNUC__ - #pragma GCC system_header -#elif defined __SUNPRO_CC -#pragma disable_warn -#elif defined _MSC_VER -#pragma warning(push, 1) -#pragma warning(disable:4273 4701 4706) -#endif - -static ::rtl::OUString aEmptyString; - -static connectivity::OSQLInternalNode* newNode(const sal_Char* pNewValue, - const connectivity::SQLNodeType eNodeType, - const sal_uInt32 nNodeID = 0) -{ - return new connectivity::OSQLInternalNode(pNewValue, eNodeType, nNodeID); -} - -static connectivity::OSQLInternalNode* newNode(const ::rtl::OString& _NewValue, - const connectivity::SQLNodeType eNodeType, - const sal_uInt32 nNodeID = 0) -{ - return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID); -} - -static connectivity::OSQLInternalNode* newNode(const ::rtl::OUString& _NewValue, - const connectivity::SQLNodeType eNodeType, - const sal_uInt32 nNodeID = 0) -{ - return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID); -} - - -// yyi ist die interne Nr. der Regel, die gerade reduziert wird. -// Ueber die Mapping-Tabelle yyrmap wird daraus eine externe Regel-Nr. -#define SQL_NEW_RULE newNode(aEmptyString, SQL_NODE_RULE, yyr1[yyn]) -#define SQL_NEW_LISTRULE newNode(aEmptyString, SQL_NODE_LISTRULE, yyr1[yyn]) -#define SQL_NEW_COMMALISTRULE newNode(aEmptyString, SQL_NODE_COMMALISTRULE, yyr1[yyn]) - - -connectivity::OSQLParser* xxx_pGLOBAL_SQLPARSER; - -#define YYERROR_VERBOSE - -#define SQLyyerror(s) \ -{ \ - xxx_pGLOBAL_SQLPARSER->error(s); \ -} - -using namespace connectivity; -#define SQLyylex xxx_pGLOBAL_SQLPARSER->SQLlex -%} - /* symbolic tokens */ - -%union { - connectivity::OSQLParseNode * pParseNode; -} -%type <pParseNode> '(' ')' ',' ':' ';' '?' '[' ']' '{' '}' '.' 'K' 'M' 'G' 'T' 'P' - -%token <pParseNode> SQL_TOKEN_STRING SQL_TOKEN_ACCESS_DATE SQL_TOKEN_INT SQL_TOKEN_REAL_NUM -%token <pParseNode> SQL_TOKEN_INTNUM SQL_TOKEN_APPROXNUM SQL_TOKEN_NOT SQL_TOKEN_NAME - - -%nonassoc <pParseNode> SQL_TOKEN_UMINUS - - - - /* literal keyword tokens */ - -%token <pParseNode> SQL_TOKEN_ALL SQL_TOKEN_ALTER SQL_TOKEN_AMMSC SQL_TOKEN_ANY SQL_TOKEN_AS SQL_TOKEN_ASC SQL_TOKEN_AT SQL_TOKEN_AUTHORIZATION SQL_TOKEN_AVG - -%token <pParseNode> SQL_TOKEN_BETWEEN SQL_TOKEN_BIT SQL_TOKEN_BOTH SQL_TOKEN_BY - -%token <pParseNode> SQL_TOKEN_CAST SQL_TOKEN_CHARACTER SQL_TOKEN_CHECK SQL_TOKEN_COLLATE SQL_TOKEN_COMMIT SQL_TOKEN_CONTINUE SQL_TOKEN_CONVERT SQL_TOKEN_COUNT SQL_TOKEN_CREATE SQL_TOKEN_CROSS -%token <pParseNode> SQL_TOKEN_CURRENT SQL_TOKEN_CURSOR - -%token <pParseNode> SQL_TOKEN_DATE SQL_TOKEN_DATEVALUE SQL_TOKEN_DAY SQL_TOKEN_DEC SQL_TOKEN_DECIMAL SQL_TOKEN_DECLARE SQL_TOKEN_DEFAULT SQL_TOKEN_DELETE SQL_TOKEN_DESC -%token <pParseNode> SQL_TOKEN_DISTINCT SQL_TOKEN_DOUBLE SQL_TOKEN_DROP - -%token <pParseNode> SQL_TOKEN_ESCAPE SQL_TOKEN_EXCEPT SQL_TOKEN_EXISTS SQL_TOKEN_FALSE SQL_TOKEN_FETCH SQL_TOKEN_FLOAT SQL_TOKEN_FOR SQL_TOKEN_FOREIGN SQL_TOKEN_FOUND SQL_TOKEN_FROM SQL_TOKEN_FULL - -%token <pParseNode> SQL_TOKEN_GRANT SQL_TOKEN_GROUP SQL_TOKEN_HAVING SQL_TOKEN_IN SQL_TOKEN_INDICATOR SQL_TOKEN_INNER SQL_TOKEN_INTEGER SQL_TOKEN_INTO SQL_TOKEN_IS SQL_TOKEN_INTERSECT - -%token <pParseNode> SQL_TOKEN_JOIN SQL_TOKEN_KEY SQL_TOKEN_LEADING SQL_TOKEN_LIKE SQL_TOKEN_LOCAL SQL_TOKEN_LOWER -%token <pParseNode> SQL_TOKEN_MAX SQL_TOKEN_MIN SQL_TOKEN_NATURAL SQL_TOKEN_NCHAR SQL_TOKEN_NULL SQL_TOKEN_NUMERIC - -%token <pParseNode> SQL_TOKEN_OCTET_LENGTH SQL_TOKEN_OF SQL_TOKEN_ON SQL_TOKEN_OPTION SQL_TOKEN_ORDER SQL_TOKEN_OUTER - -%token <pParseNode> SQL_TOKEN_PRECISION SQL_TOKEN_PRIMARY SQL_TOKEN_PRIVILEGES SQL_TOKEN_PROCEDURE SQL_TOKEN_PUBLIC -%token <pParseNode> SQL_TOKEN_REAL SQL_TOKEN_REFERENCES SQL_TOKEN_ROLLBACK - -%token <pParseNode> SQL_TOKEN_SCHEMA SQL_TOKEN_SELECT SQL_TOKEN_SET SQL_TOKEN_SIZE SQL_TOKEN_SMALLINT SQL_TOKEN_SOME SQL_TOKEN_SQLCODE SQL_TOKEN_SQLERROR SQL_TOKEN_SUM - -%token <pParseNode> SQL_TOKEN_TABLE SQL_TOKEN_TIME SQL_TOKEN_TIMESTAMP SQL_TOKEN_TIMEZONE_HOUR SQL_TOKEN_TIMEZONE_MINUTE SQL_TOKEN_TO SQL_TOKEN_TRAILING SQL_TOKEN_TRANSLATE SQL_TOKEN_TRIM SQL_TOKEN_TRUE SQL_TOKEN_UNION -%token <pParseNode> SQL_TOKEN_UNIQUE SQL_TOKEN_UNKNOWN SQL_TOKEN_UPDATE SQL_TOKEN_UPPER SQL_TOKEN_USAGE SQL_TOKEN_USER SQL_TOKEN_USING SQL_TOKEN_VALUES SQL_TOKEN_VIEW -%token <pParseNode> SQL_TOKEN_WHERE SQL_TOKEN_WITH SQL_TOKEN_WORK SQL_TOKEN_ZONE - -/* ODBC KEYWORDS */ -%token <pParseNode> SQL_TOKEN_CALL SQL_TOKEN_D SQL_TOKEN_FN SQL_TOKEN_T SQL_TOKEN_TS SQL_TOKEN_OJ -/* string functions */ -%token <pParseNode> SQL_TOKEN_ASCII SQL_TOKEN_BIT_LENGTH SQL_TOKEN_CHAR SQL_TOKEN_CHAR_LENGTH SQL_TOKEN_SQL_TOKEN_INTNUM -%token <pParseNode> SQL_TOKEN_CONCAT -%token <pParseNode> SQL_TOKEN_DIFFERENCE SQL_TOKEN_INSERT SQL_TOKEN_LCASE SQL_TOKEN_LEFT SQL_TOKEN_LENGTH SQL_TOKEN_LOCATE -%token <pParseNode> SQL_TOKEN_LOCATE_2 SQL_TOKEN_LTRIM SQL_TOKEN_POSITION SQL_TOKEN_REPEAT SQL_TOKEN_REPLACE -%token <pParseNode> SQL_TOKEN_RIGHT SQL_TOKEN_RTRIM SQL_TOKEN_SOUNDEX SQL_TOKEN_SPACE SQL_TOKEN_SUBSTRING SQL_TOKEN_UCASE - -/* time and date functions */ -%token <pParseNode> SQL_TOKEN_CURRENT_DATE SQL_TOKEN_CURRENT_TIME SQL_TOKEN_CURRENT_TIMESTAMP SQL_TOKEN_CURDATE SQL_TOKEN_CURTIME -%token <pParseNode> SQL_TOKEN_DAYNAME SQL_TOKEN_DAYOFMONTH SQL_TOKEN_DAYOFWEEK SQL_TOKEN_DAYOFYEAR SQL_TOKEN_EXTRACT -%token <pParseNode> SQL_TOKEN_HOUR SQL_TOKEN_MINUTE SQL_TOKEN_MONTH SQL_TOKEN_MONTHNAME SQL_TOKEN_NOW SQL_TOKEN_QUARTER SQL_TOKEN_DATEDIFF -%token <pParseNode> SQL_TOKEN_SECOND SQL_TOKEN_TIMESTAMPADD SQL_TOKEN_TIMESTAMPDIFF SQL_TOKEN_TIMEVALUE SQL_TOKEN_WEEK SQL_TOKEN_YEAR - -/* numeric functions */ -%token <pParseNode> SQL_TOKEN_ABS SQL_TOKEN_ACOS SQL_TOKEN_ASIN SQL_TOKEN_ATAN SQL_TOKEN_ATAN2 SQL_TOKEN_CEILING -%token <pParseNode> SQL_TOKEN_COS SQL_TOKEN_COT SQL_TOKEN_DEGREES SQL_TOKEN_EXP SQL_TOKEN_FLOOR SQL_TOKEN_LOGF SQL_TOKEN_LOG SQL_TOKEN_LN -%token <pParseNode> SQL_TOKEN_LOG10 SQL_TOKEN_MOD SQL_TOKEN_PI SQL_TOKEN_POWER SQL_TOKEN_RADIANS SQL_TOKEN_RAND SQL_TOKEN_ROUNDMAGIC -%token <pParseNode> SQL_TOKEN_ROUND SQL_TOKEN_SIGN SQL_TOKEN_SIN SQL_TOKEN_SQRT SQL_TOKEN_TAN SQL_TOKEN_TRUNCATE - -// computational operation -%token <pParseNode> SQL_TOKEN_EVERY SQL_TOKEN_INTERSECTION SQL_TOKEN_FUSION SQL_TOKEN_COLLECT SQL_TOKEN_VAR_POP SQL_TOKEN_VAR_SAMP -%token <pParseNode> SQL_TOKEN_STDDEV_SAMP SQL_TOKEN_STDDEV_POP - -%token <pParseNode> SQL_TOKEN_RANK SQL_TOKEN_DENSE_RANK SQL_TOKEN_PERCENT_RANK SQL_TOKEN_CUME_DIST SQL_TOKEN_PERCENTILE_CONT SQL_TOKEN_PERCENTILE_DISC SQL_TOKEN_WITHIN SQL_TOKEN_ARRAY_AGG -%token <pParseNode> SQL_TOKEN_CASE SQL_TOKEN_THEN SQL_TOKEN_END SQL_TOKEN_NULLIF SQL_TOKEN_COALESCE SQL_TOKEN_WHEN SQL_TOKEN_ELSE -%token <pParseNode> SQL_TOKEN_BEFORE SQL_TOKEN_AFTER SQL_TOKEN_INSTEAD SQL_TOKEN_EACH SQL_TOKEN_REFERENCING SQL_TOKEN_BEGIN SQL_TOKEN_ATOMIC SQL_TOKEN_TRIGGER SQL_TOKEN_ROW SQL_TOKEN_STATEMENT -%token <pParseNode> SQL_TOKEN_NEW SQL_TOKEN_OLD -%token <pParseNode> SQL_TOKEN_VALUE SQL_TOKEN_CURRENT_CATALOG SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP SQL_TOKEN_CURRENT_PATH SQL_TOKEN_CURRENT_ROLE SQL_TOKEN_CURRENT_SCHEMA SQL_TOKEN_CURRENT_USER -%token <pParseNode> SQL_TOKEN_SESSION_USER SQL_TOKEN_SYSTEM_USER SQL_TOKEN_VARCHAR SQL_TOKEN_VARBINARY SQL_TOKEN_VARYING SQL_TOKEN_OBJECT SQL_TOKEN_NCLOB SQL_TOKEN_NATIONAL -%token <pParseNode> SQL_TOKEN_LARGE SQL_TOKEN_CLOB SQL_TOKEN_BLOB SQL_TOKEN_BIGINT SQL_TOKEN_BINARY SQL_TOKEN_WITHOUT SQL_TOKEN_BOOLEAN SQL_TOKEN_INTERVAL -// window function -%token <pParseNode> SQL_TOKEN_OVER SQL_TOKEN_ROW_NUMBER SQL_TOKEN_NTILE SQL_TOKEN_LEAD SQL_TOKEN_LAG SQL_TOKEN_RESPECT SQL_TOKEN_IGNORE SQL_TOKEN_NULLS -%token <pParseNode> SQL_TOKEN_FIRST_VALUE SQL_TOKEN_LAST_VALUE SQL_TOKEN_NTH_VALUE SQL_TOKEN_FIRST SQL_TOKEN_LAST -%token <pParseNode> SQL_TOKEN_EXCLUDE SQL_TOKEN_OTHERS SQL_TOKEN_TIES SQL_TOKEN_FOLLOWING SQL_TOKEN_UNBOUNDED SQL_TOKEN_PRECEDING SQL_TOKEN_RANGE SQL_TOKEN_ROWS -%token <pParseNode> SQL_TOKEN_PARTITION SQL_TOKEN_WINDOW SQL_TOKEN_NO -// LIMIT and OFFSEt -%token <pParseNode> SQL_TOKEN_LIMIT SQL_TOKEN_OFFSET SQL_TOKEN_NEXT SQL_TOKEN_ONLY - - /* operators */ -%left SQL_TOKEN_NAME -%left <pParseNode> SQL_TOKEN_OR -%left <pParseNode> SQL_TOKEN_AND - -%left <pParseNode> SQL_LESSEQ SQL_GREATEQ SQL_NOTEQUAL SQL_LESS SQL_GREAT SQL_EQUAL /* '<' '>' = <> < > <= >= != */ -%left <pParseNode> '+' '-' SQL_CONCAT -%left <pParseNode> '*' '/' -%left SQL_TOKEN_NATURAL SQL_TOKEN_CROSS SQL_TOKEN_FULL SQL_TOKEN_LEFT SQL_TOKEN_RIGHT -%left ')' -%right '=' -%right '.' -%right '(' - - -%token <pParseNode> SQL_TOKEN_INVALIDSYMBOL - -/*%type <pParseNode> sql_single_statement */ - -%type <pParseNode> sql /*schema */ -%type <pParseNode> column_def_opt_list column_def_opt table_constraint_def column_commalist -%type <pParseNode> view_def opt_with_check_option opt_column_commalist privilege_def -%type <pParseNode> opt_with_grant_option privileges operation_commalist operation -%type <pParseNode> grantee_commalist grantee opt_order_by_clause ordering_spec_commalist -%type <pParseNode> ordering_spec opt_asc_desc manipulative_statement commit_statement -%type <pParseNode> /*delete_statement_positioned*/ delete_statement_searched fetch_statement -%type <pParseNode> insert_statement values_or_query_spec -%type <pParseNode> rollback_statement select_statement_into opt_all_distinct -%type <pParseNode> /*update_statement_positioned*/ assignment_commalist assignment -%type <pParseNode> update_statement_searched target_commalist target opt_where_clause -%type <pParseNode> select_statement selection table_exp from_clause table_ref_commalist table_ref -%type <pParseNode> where_clause opt_group_by_clause column_ref_commalist opt_having_clause -%type <pParseNode> search_condition predicate comparison_predicate comparison_predicate_part_2 between_predicate between_predicate_part_2 -%type <pParseNode> like_predicate opt_escape test_for_null null_predicate_part_2 in_predicate in_predicate_part_2 character_like_predicate_part_2 other_like_predicate_part_2 -%type <pParseNode> all_or_any_predicate any_all_some existence_test subquery quantified_comparison_predicate_part_2 -%type <pParseNode> scalar_exp_commalist parameter_ref literal parenthesized_boolean_value_expression -%type <pParseNode> column_ref data_type column cursor parameter range_variable user /*like_check*/ -/* neue Regeln bei OJ */ -%type <pParseNode> derived_column as_clause table_name num_primary term num_value_exp -%type <pParseNode> value_exp_primary num_value_fct unsigned_value_spec cast_spec set_fct_spec scalar_subquery -%type <pParseNode> position_exp extract_exp length_exp general_value_spec -%type <pParseNode> general_set_fct set_fct_type query_exp non_join_query_exp joined_table -%type <pParseNode> non_join_query_term non_join_query_primary simple_table -%type <pParseNode> table_value_const_list row_value_constructor row_value_const_list row_value_constructor_elem -%type <pParseNode> qualified_join value_exp query_term join_type outer_join_type join_condition boolean_term -%type <pParseNode> boolean_factor truth_value boolean_test boolean_primary named_columns_join join_spec -%type <pParseNode> cast_operand cast_target factor datetime_value_exp /*interval_value_exp*/ datetime_term datetime_factor -%type <pParseNode> datetime_primary datetime_value_fct time_zone time_zone_specifier /*interval_term*/ interval_qualifier -%type <pParseNode> start_field non_second_datetime_field end_field single_datetime_field extract_field datetime_field time_zone_field -%type <pParseNode> extract_source char_length_exp octet_length_exp bit_length_exp select_sublist string_value_exp -%type <pParseNode> char_value_exp concatenation char_factor char_primary string_value_fct char_substring_fct fold -%type <pParseNode> form_conversion char_translation trim_fct trim_operands trim_spec bit_value_fct bit_substring_fct op_column_commalist -%type <pParseNode> /*bit_concatenation*/ bit_value_exp bit_factor bit_primary collate_clause char_value_fct unique_spec value_exp_commalist in_predicate_value unique_test update_source -%type <pParseNode> function_arg_commalist3 string_function_3Argument function_arg_commalist4 string_function_4Argument function_arg_commalist2 string_function_1Argument string_function_2Argument -%type <pParseNode> date_function_0Argument date_function_1Argument function_name12 function_name23 function_name1 function_name2 function_name3 function_name0 numeric_function_0Argument numeric_function_1Argument numeric_function_2Argument -%type <pParseNode> all query_primary sql_not for_length upper_lower comparison column_val cross_union /*opt_schema_element_list*/ -%type <pParseNode> /*op_authorization op_schema*/ nil_fkt schema_element base_table_def base_table_element base_table_element_commalist -%type <pParseNode> column_def odbc_fct_spec odbc_call_spec odbc_fct_type op_parameter union_statement -%type <pParseNode> op_odbc_call_parameter odbc_parameter_commalist odbc_parameter function_args_commalist function_arg -%type <pParseNode> catalog_name schema_name table_node numeric_function string_function function_name date_function table_primary_as_range_column opt_as -%type <pParseNode> ordered_set_function inverse_distribution_function hypothetical_set_function hypothetical_set_function_value_expression_list rank_function_type within_group_specification inverse_distribution_function_type array_aggregate_function inverse_distribution_function_argument -%type <pParseNode> case_expression else_clause result_expression result case_abbreviation case_specification searched_when_clause simple_when_clause searched_case simple_case -%type <pParseNode> when_operand_list when_operand case_operand -%type <pParseNode> trigger_definition trigger_name trigger_action_time trigger_event transition_table_or_variable_list triggered_action trigger_column_list triggered_when_clause triggered_SQL_statement SQL_procedure_statement old_transition_variable_name new_transition_variable_name -%type <pParseNode> op_referencing op_trigger_columnlist op_triggered_action_for opt_row trigger_for SQL_procedure_statement_list transition_table_or_variable old_transition_table_name new_transition_table_name transition_table_name -%type <pParseNode> searched_when_clause_list simple_when_clause_list predefined_type opt_char_set_spec opt_collate_clause character_string_type national_character_string_type -%type <pParseNode> binary_string_type numeric_type boolean_type datetime_type interval_type opt_paren_precision paren_char_length opt_paren_char_large_length paren_character_large_object_length -%type <pParseNode> large_object_length opt_multiplier character_large_object_type national_character_large_object_type binary_large_object_string_type opt_with_or_without_time_zone -%type <pParseNode> approximate_numeric_type exact_numeric_type opt_paren_precision_scale -/* window function rules */ -%type <pParseNode> window_function window_function_type ntile_function number_of_tiles lead_or_lag_function lead_or_lag lead_or_lag_extent offset default_expression null_treatment -%type <pParseNode> first_or_last_value_function first_or_last_value nth_value_function nth_row from_first_or_last window_name_or_specification in_line_window_specification opt_lead_or_lag_function -%type <pParseNode> opt_null_treatment opt_from_first_or_last simple_value_specification dynamic_parameter_specification window_name window_clause window_definition_list window_definition -%type <pParseNode> new_window_name window_specification_details existing_window_name window_partition_clause window_partition_column_reference_list window_partition_column_reference window_frame_clause -%type <pParseNode> window_frame_units window_frame_extent window_frame_start window_frame_preceding window_frame_between window_frame_bound_1 window_frame_bound_2 window_frame_bound window_frame_following window_frame_exclusion -%type <pParseNode> opt_window_frame_clause opt_window_partition_clause opt_existing_window_name window_specification opt_window_frame_exclusion opt_window_clause opt_offset -%type <pParseNode> opt_fetch_first_row_count fetch_first_clause offset_row_count fetch_first_row_count first_or_next row_or_rows opt_result_offset_clause result_offset_clause -/* LIMIT and OFFSET */ -%type <pParseNode> opt_limit_offset_clause limit_offset_clause opt_fetch_first_clause -%% - -/* Parse Tree an OSQLParser zurueckliefern - * (der Zugriff ueber yyval nach Aufruf des Parsers scheitert, - * - */ -sql_single_statement: - sql - { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); } - | sql ';' - { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); } - ; - - /* schema definition language */ - /* Note: other ``sql:sal_Unicode() rules appear later in the grammar */ - -sql: - manipulative_statement - | schema_element - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; - -/*** - -op_authorization: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_AUTHORIZATION user - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -op_schema: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_NAME - | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - ; - -schema: - SQL_TOKEN_CREATE SQL_TOKEN_SCHEMA op_schema op_authorization opt_schema_element_list - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - ; - -opt_schema_element_list: - {$$ = SQL_NEW_RULE;} - | schema_glement_list - ; - -schema_element_list: - schema_element - {$$ = SQL_NEW_LISTRULE; - $$->append($1);} - | schema_element_list schema_element - {$1->append($2); - $$ = $1;} - ; -*/ - -schema_element: - base_table_def - | view_def - | privilege_def - | trigger_definition - ; - -base_table_def: - SQL_TOKEN_CREATE SQL_TOKEN_TABLE table_node '(' base_table_element_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));} - ; - -base_table_element_commalist: - base_table_element - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | base_table_element_commalist ',' base_table_element - {$1->append($3); - $$ = $1;} - ; - -base_table_element: - column_def - | table_constraint_def - ; - -column_def: - column data_type column_def_opt_list - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; - -column_def_opt_list: - /* empty */ {$$ = SQL_NEW_LISTRULE;} - | column_def_opt_list column_def_opt - {$1->append($2); - $$ = $1;} - ; - -nil_fkt: - datetime_value_fct - ; -unique_spec: - SQL_TOKEN_UNIQUE - | SQL_TOKEN_PRIMARY SQL_TOKEN_KEY - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -column_def_opt: - SQL_TOKEN_NOT SQL_TOKEN_NULL - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | unique_spec - | SQL_TOKEN_DEFAULT literal - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_DEFAULT SQL_TOKEN_NULL - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_DEFAULT SQL_TOKEN_USER - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_DEFAULT nil_fkt - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_CHECK - | SQL_TOKEN_CHECK '(' search_condition ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));} - | SQL_TOKEN_REFERENCES table_node - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_REFERENCES table_node '(' column_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));} - ; - -table_constraint_def: - unique_spec '(' column_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));} - | SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($6); - $$->append($7);} - | SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node '(' column_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($6); - $$->append($7); - $$->append($8 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($9); - $$->append($10 = newNode(")", SQL_NODE_PUNCTUATION));} - | SQL_TOKEN_CHECK '(' search_condition ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));} - ; -op_column_commalist: - /* empty */ {$$ = SQL_NEW_RULE;} - | '(' column_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -column_commalist: - column_commalist ',' column - {$1->append($3); - $$ = $1;} - | column - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - ; - -view_def: - SQL_TOKEN_CREATE SQL_TOKEN_VIEW table_node opt_column_commalist SQL_TOKEN_AS select_statement opt_with_check_option - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7);} - ; - -opt_with_check_option: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_WITH SQL_TOKEN_CHECK SQL_TOKEN_OPTION - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3);} - ; - -opt_column_commalist: - /* empty */ {$$ = SQL_NEW_RULE;} - | '(' column_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));} - ; - -privilege_def: - SQL_TOKEN_GRANT privileges SQL_TOKEN_ON table_node SQL_TOKEN_TO grantee_commalist - opt_with_grant_option - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7);} - ; - -opt_with_grant_option: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_WITH SQL_TOKEN_GRANT SQL_TOKEN_OPTION - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3);} - ; - -privileges: - SQL_TOKEN_ALL SQL_TOKEN_PRIVILEGES - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | operation_commalist - ; - -operation_commalist: - operation - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | operation_commalist ',' operation - {$1->append($3); - $$ = $1;} - ; - -operation: - SQL_TOKEN_SELECT - | SQL_TOKEN_INSERT opt_column_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_DELETE - | SQL_TOKEN_UPDATE opt_column_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_REFERENCES opt_column_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | SQL_TOKEN_USAGE - ; - - -grantee_commalist: - grantee - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | grantee_commalist ',' grantee - {$1->append($3); - $$ = $1;} - ; - -grantee: - SQL_TOKEN_PUBLIC - | user - ; - - /* module language */ - -opt_order_by_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ORDER SQL_TOKEN_BY ordering_spec_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3);} - ; - -ordering_spec_commalist: - ordering_spec - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | ordering_spec_commalist ',' ordering_spec - {$1->append($3); - $$ = $1;} - ; - -ordering_spec: -/* SQL_TOKEN_INTNUM opt_asc_desc - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} -*/ - predicate opt_asc_desc - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - - | row_value_constructor_elem opt_asc_desc - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; - -opt_asc_desc: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ASC - | SQL_TOKEN_DESC - ; - - -/*** -manipulative_statement_list: - manipulative_statement - {$$ = SQL_NEW_LISTRULE; - $$->append($1);} - | manipulative_statement_list manipulative_statement - {$1->append($2); - $$ = $1;} - ; -***/ - -sql_not: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_NOT - ; - -/* manipulative statements */ - -manipulative_statement: - commit_statement -/* | delete_statement_positioned*/ - | delete_statement_searched - | fetch_statement - | insert_statement - | rollback_statement - | select_statement_into -/* | update_statement_positioned*/ - | update_statement_searched - | union_statement - | '{' odbc_call_spec '}' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode("}", SQL_NODE_PUNCTUATION)); - } - ; - -union_statement: - select_statement - | union_statement SQL_TOKEN_UNION all select_statement - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -commit_statement: - SQL_TOKEN_COMMIT SQL_TOKEN_WORK - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; -/* -delete_statement_positioned: - SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7);} - ; -*/ -delete_statement_searched: - SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node opt_where_clause - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4);} - ; - -fetch_statement: - SQL_TOKEN_FETCH cursor SQL_TOKEN_INTO target_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4);} - ; - -insert_statement: - SQL_TOKEN_INSERT SQL_TOKEN_INTO table_node opt_column_commalist values_or_query_spec - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5);} - ; -values_or_query_spec: - SQL_TOKEN_VALUES '(' table_value_const_list ')' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; - -table_value_const_list: - row_value_constructor - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | table_value_const_list ',' row_value_constructor - {$1->append($3); - $$ = $1;} - ; -row_value_const_list: - row_value_constructor_elem - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | row_value_const_list ',' row_value_constructor_elem - {$1->append($3); - $$ = $1;} - ; -row_value_constructor: - row_value_constructor_elem -/* | '(' row_value_const_list ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - */ - ; -row_value_constructor_elem: - value_exp /*[^')']*/ - | SQL_TOKEN_DEFAULT - ; - - -rollback_statement: - SQL_TOKEN_ROLLBACK SQL_TOKEN_WORK - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; - - - /* INTO target_commalist herausgenommen */ -select_statement_into: - SQL_TOKEN_SELECT opt_all_distinct selection SQL_TOKEN_INTO target_commalist table_exp - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); } - ; - -opt_all_distinct: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ALL - | SQL_TOKEN_DISTINCT - - ; -/* -update_statement_positioned: - SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist - SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7); - $$->append($8);} - ; -*/ -assignment_commalist: - assignment - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | assignment_commalist ',' assignment - {$1->append($3); - $$ = $1;} - ; - -assignment: - column SQL_EQUAL update_source - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3);} - ; -update_source: - value_exp - | SQL_TOKEN_DEFAULT - ; -update_statement_searched: - SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist opt_where_clause - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5);} - ; - -target_commalist: - target - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | target_commalist ',' target - {$1->append($3); - $$ = $1;} - ; - -target: - parameter_ref - ; - -opt_where_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | where_clause - ; - - /* query expressions */ - -query_term: - non_join_query_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -/* SELECT STATEMENT */ -select_statement: - SQL_TOKEN_SELECT opt_all_distinct selection table_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; - -selection: - '*' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("*", SQL_NODE_PUNCTUATION)); - } - | scalar_exp_commalist - ; -opt_result_offset_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | result_offset_clause - ; -result_offset_clause: - SQL_TOKEN_OFFSET offset_row_count row_or_rows - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -opt_fetch_first_row_count: - /* empty */ {$$ = SQL_NEW_RULE;} - | fetch_first_row_count - ; -first_or_next: - SQL_TOKEN_FIRST - | SQL_TOKEN_NEXT - ; -row_or_rows: - SQL_TOKEN_ROW - | SQL_TOKEN_ROWS - ; -opt_fetch_first_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | fetch_first_clause - ; -fetch_first_clause: - SQL_TOKEN_FETCH first_or_next opt_fetch_first_row_count row_or_rows SQL_TOKEN_ONLY - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - ; -offset_row_count: - literal - ; -fetch_first_row_count: - literal - ; - -opt_limit_offset_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | limit_offset_clause - ; -opt_offset: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_OFFSET SQL_TOKEN_INTNUM - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -limit_offset_clause: - SQL_TOKEN_LIMIT SQL_TOKEN_INTNUM opt_offset - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -table_exp: - from_clause opt_where_clause opt_group_by_clause opt_having_clause opt_window_clause opt_order_by_clause opt_limit_offset_clause opt_result_offset_clause opt_fetch_first_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7); - $$->append($8); - $$->append($9); - } - ; - -from_clause: - SQL_TOKEN_FROM table_ref_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; - -table_ref_commalist: - - table_ref - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | table_ref_commalist ',' table_ref - {$1->append($3); - $$ = $1;} - ; - -opt_as: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_AS - ; -opt_row: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ROW - ; -table_primary_as_range_column: - {$$ = SQL_NEW_RULE;} - | opt_as SQL_TOKEN_NAME op_column_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -table_ref: - table_node table_primary_as_range_column - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | subquery range_variable op_column_commalist - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | joined_table - | '{' SQL_TOKEN_OJ joined_table '}' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3); - $$->append($4 = newNode("}", SQL_NODE_PUNCTUATION)); - } - | '(' joined_table ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -where_clause: - SQL_TOKEN_WHERE search_condition - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; - -opt_group_by_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_GROUP SQL_TOKEN_BY column_ref_commalist - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3);} - ; - -column_ref_commalist: - column_ref - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | set_fct_spec - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | column_ref_commalist ',' column_ref - {$1->append($3); - $$ = $1;} - | column_ref_commalist ',' set_fct_spec - {$1->append($3); - $$ = $1;} - ; - -opt_having_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_HAVING search_condition - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; - - /* search conditions */ -truth_value: - SQL_TOKEN_TRUE - | SQL_TOKEN_FALSE - | SQL_TOKEN_UNKNOWN - | SQL_TOKEN_NULL - ; -boolean_primary: - predicate - | '(' search_condition ')' - { // boolean_primary: rule 2 - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | row_value_constructor_elem /*[^')' ',']*/ - { - if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// boolean_primary: rule 3 - { - $$ = SQL_NEW_RULE; - sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$1); - if(nErg == 1) - { - OSQLParseNode* pTemp = $$; - $$ = pTemp->removeAt((sal_uInt32)0); - delete pTemp; - } - else - { - delete $$; - if(nErg) - YYERROR; - else - YYABORT; - } - } - else - YYERROR; - } - ; -parenthesized_boolean_value_expression: - '(' search_condition ')' - { // boolean_primary: rule 2 - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -boolean_test: - boolean_primary - | boolean_primary SQL_TOKEN_IS sql_not truth_value - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -boolean_factor: - boolean_test - | SQL_TOKEN_NOT boolean_test - { // boolean_factor: rule 1 - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -boolean_term: - boolean_factor - | boolean_term SQL_TOKEN_AND boolean_factor - { - $$ = SQL_NEW_RULE; // boolean_term: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -search_condition: - boolean_term - | search_condition SQL_TOKEN_OR boolean_term - { - $$ = SQL_NEW_RULE; // search_condition - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -predicate: - comparison_predicate - | between_predicate - | all_or_any_predicate - | existence_test - | unique_test - | test_for_null - | in_predicate - | like_predicate - ; -comparison_predicate_part_2: - comparison row_value_constructor - { - $$ = SQL_NEW_RULE; // comparison_predicate: rule 1 - $$->append($1); - $$->append($2); - } -comparison_predicate: - row_value_constructor comparison row_value_constructor - { - $$ = SQL_NEW_RULE; // comparison_predicate: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - } - | comparison row_value_constructor - { - if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // comparison_predicate: rule 2 - { - $$ = SQL_NEW_RULE; - sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$2,$1); - if(nErg == 1) - { - OSQLParseNode* pTemp = $$; - $$ = pTemp->removeAt((sal_uInt32)0); - delete pTemp; - } - else - { - delete $$; - YYABORT; - } - } - else - { - YYERROR; - } - } - ; -comparison: - SQL_LESS - | SQL_NOTEQUAL - | SQL_EQUAL - | SQL_GREAT - | SQL_LESSEQ - | SQL_GREATEQ - ; -between_predicate_part_2: - sql_not SQL_TOKEN_BETWEEN row_value_constructor SQL_TOKEN_AND row_value_constructor - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // between_predicate: rule 2 - { - $$ = SQL_NEW_RULE; - - sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$3,$2,$5); - if(nErg == 1) - { - OSQLParseNode* pTemp = $$; - $$ = pTemp->removeAt((sal_uInt32)0); - OSQLParseNode* pColumnRef = $$->removeAt((sal_uInt32)0); - $$->insert(0,$1); - OSQLParseNode* pBetween_predicate = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::between_predicate)); - pBetween_predicate->append(pColumnRef); - pBetween_predicate->append($$); - $$ = pBetween_predicate; - - delete pTemp; - delete $4; - } - else - { - delete $$; - YYABORT; - } - } - else - { - $$ = SQL_NEW_RULE; // between_predicate: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - } -between_predicate: - row_value_constructor between_predicate_part_2 - { - $$ = SQL_NEW_RULE; // between_predicate: rule 1 - $$->append($1); - $$->append($2); - } - | between_predicate_part_2 - ; -character_like_predicate_part_2: - sql_not SQL_TOKEN_LIKE string_value_exp opt_escape - { - $$ = SQL_NEW_RULE; // like_predicate: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -other_like_predicate_part_2: - sql_not SQL_TOKEN_LIKE value_exp_primary opt_escape - { - $$ = SQL_NEW_RULE; // like_predicate: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -like_predicate: - row_value_constructor character_like_predicate_part_2 - { - $$ = SQL_NEW_RULE; // like_predicate: rule 1 - $$->append($1); - $$->append($2); - } - | row_value_constructor other_like_predicate_part_2 - { - $$ = SQL_NEW_RULE; // like_predicate: rule 3 - $$->append($1); - $$->append($2); - } - | character_like_predicate_part_2 - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 5 - { - OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME)); - - $$ = SQL_NEW_RULE; - $$->append(pColumnRef); - $$->append($1); - OSQLParseNode* p2nd = $1->removeAt(2); - OSQLParseNode* p3rd = $1->removeAt(2); - if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) ) - { - delete $$; - YYABORT; - } - $1->append(p3rd); - } - else - YYERROR; - } - | other_like_predicate_part_2 - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 6 - { - OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME)); - - $$ = SQL_NEW_RULE; - $$->append(pColumnRef); - $$->append($1); - OSQLParseNode* p2nd = $1->removeAt(2); - OSQLParseNode* p3rd = $1->removeAt(2); - if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) ) - { - delete $$; - YYABORT; - } - $1->append(p3rd); - } - else - YYERROR; - } - ; - -opt_escape: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ESCAPE string_value_exp - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - | '{' SQL_TOKEN_ESCAPE SQL_TOKEN_STRING '}' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3); - $$->append($4 = newNode("}", SQL_NODE_PUNCTUATION)); - } - ; - -null_predicate_part_2: - SQL_TOKEN_IS sql_not SQL_TOKEN_NULL - { - $$ = SQL_NEW_RULE; // test_for_null: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -test_for_null: - row_value_constructor null_predicate_part_2 - { - $$ = SQL_NEW_RULE; // test_for_null: rule 1 - $$->append($1); - $$->append($2); - } - | null_predicate_part_2 - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// test_for_null: rule 2 - { - OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME)); - - $$ = SQL_NEW_RULE; - $$->append(pColumnRef); - $$->append($1); - } - else - YYERROR; - } - ; -in_predicate_value: - subquery - {$$ = SQL_NEW_RULE; - $$->append($1); - } - | '(' value_exp_commalist ')' - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -in_predicate_part_2: - sql_not SQL_TOKEN_IN in_predicate_value - { - $$ = SQL_NEW_RULE;// in_predicate: rule 1 - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -in_predicate: - row_value_constructor in_predicate_part_2 - { - $$ = SQL_NEW_RULE;// in_predicate: rule 1 - $$->append($1); - $$->append($2); - } - | in_predicate_part_2 - { - if ( xxx_pGLOBAL_SQLPARSER->inPredicateCheck() )// in_predicate: rule 2 - { - OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME)); - - $$ = SQL_NEW_RULE; - $$->append(pColumnRef); - $$->append($1); - } - else - YYERROR; - } - ; -quantified_comparison_predicate_part_2: - comparison any_all_some subquery - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -all_or_any_predicate: - row_value_constructor quantified_comparison_predicate_part_2 - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | quantified_comparison_predicate_part_2 - { - if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME)); - - $$ = SQL_NEW_RULE; - $$->append(pColumnRef); - $$->append($1); - } - else - YYERROR; - } - ; - -any_all_some: - SQL_TOKEN_ANY - | SQL_TOKEN_ALL - | SQL_TOKEN_SOME - ; - -existence_test: - SQL_TOKEN_EXISTS subquery - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; -unique_test: - SQL_TOKEN_UNIQUE subquery - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2);} - ; -subquery: - '(' query_exp ')' - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));} - ; - - /* scalar expressions */ -scalar_exp_commalist: - select_sublist - { - $$ = SQL_NEW_COMMALISTRULE; - $$->append($1); - } - | scalar_exp_commalist ',' select_sublist - { - $1->append($3); - $$ = $1; - } - ; -select_sublist: -/* table_node '.' '*' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION)); - } -*/ - derived_column - - ; - -parameter_ref: - parameter - ; - -/* -op_like: - '*' - { - $$ = newNode("*", SQL_NODE_PUNCTUATION); - } - | '?' - { - $$ = newNode("?", SQL_NODE_PUNCTUATION); - } - | op_like '*' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False); - } - | op_like '?' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("?", SQL_NODE_PUNCTUATION)); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False); - } - ; -*/ - -literal: -/* SQL_TOKEN_STRING - | */SQL_TOKEN_INT - | SQL_TOKEN_REAL_NUM - | SQL_TOKEN_INTNUM - | SQL_TOKEN_APPROXNUM - | SQL_TOKEN_ACCESS_DATE -/* rules for predicate check */ - | literal SQL_TOKEN_STRING - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); - } - else - YYERROR; - } - | literal SQL_TOKEN_INT - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); - } - else - YYERROR; - } - | literal SQL_TOKEN_REAL_NUM - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); - } - else - YYERROR; - } - | literal SQL_TOKEN_APPROXNUM - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); - } - else - YYERROR; - } - ; - - /* miscellaneous */ -as_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_AS column - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | column - ; -position_exp: - SQL_TOKEN_POSITION '(' value_exp SQL_TOKEN_IN value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_POSITION '(' value_exp_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -num_value_fct: - position_exp - | extract_exp - | length_exp - ; -char_length_exp: - SQL_TOKEN_CHAR_LENGTH '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_SQL_TOKEN_INTNUM '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - - ; -octet_length_exp: - SQL_TOKEN_OCTET_LENGTH '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -bit_length_exp: - SQL_TOKEN_BIT_LENGTH '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -length_exp: - char_length_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | octet_length_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | bit_length_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -datetime_field: - non_second_datetime_field - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_SECOND - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -extract_field: - time_zone_field - | datetime_field - | value_exp - ; -time_zone_field: - SQL_TOKEN_TIMEZONE_HOUR - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_TIMEZONE_MINUTE - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -extract_source: - datetime_value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } -/* | interval_value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } */ - ; -extract_exp: - SQL_TOKEN_EXTRACT '(' extract_field SQL_TOKEN_FROM value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -unsigned_value_spec: - general_value_spec - | literal - ; -general_value_spec: - parameter - | SQL_TOKEN_USER - /* | SQL_TOKEN_NULL*/ - | SQL_TOKEN_FALSE - | SQL_TOKEN_TRUE - | SQL_TOKEN_VALUE - | SQL_TOKEN_CURRENT_CATALOG - | SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP - | SQL_TOKEN_CURRENT_PATH - | SQL_TOKEN_CURRENT_ROLE - | SQL_TOKEN_CURRENT_SCHEMA - | SQL_TOKEN_CURRENT_USER - | SQL_TOKEN_SESSION_USER - | SQL_TOKEN_SYSTEM_USER - ; -set_fct_spec: - general_set_fct - | '{' odbc_fct_spec '}' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode("}", SQL_NODE_PUNCTUATION)); - } - | function_name '(' ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name0 '(' ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name1 '(' function_arg ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name2 '(' function_arg_commalist2 ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name3 '(' function_arg_commalist3 ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | string_function_4Argument '(' function_arg_commalist4 ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name '(' function_args_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | function_name12 '(' function_args_commalist ')' - { - if ( $3->count() == 1 || $3->count() == 2 ) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - else - YYERROR; - } - | function_name23 '(' function_args_commalist ')' - { - if ( $3->count() == 2 || $3->count() == 3) - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - else - YYERROR; - } - ; -function_name0: - date_function_0Argument - | numeric_function_0Argument - ; -function_name1: - string_function_1Argument - | date_function_1Argument - | numeric_function_1Argument - ; -function_name2: - string_function_2Argument - | numeric_function_2Argument - ; -function_name12: - SQL_TOKEN_ROUND - | SQL_TOKEN_WEEK - | SQL_TOKEN_LOGF - | SQL_TOKEN_LOG - ; -function_name23: - SQL_TOKEN_LOCATE - | SQL_TOKEN_DATEDIFF - ; -function_name3: - string_function_3Argument - ; -function_name: - string_function - | date_function - | numeric_function - | SQL_TOKEN_NAME - ; -string_function_1Argument: - SQL_TOKEN_LENGTH - | SQL_TOKEN_ASCII - | SQL_TOKEN_LCASE - | SQL_TOKEN_LTRIM - | SQL_TOKEN_RTRIM - | SQL_TOKEN_SPACE - | SQL_TOKEN_UCASE - ; - -string_function_2Argument: - SQL_TOKEN_REPEAT - | SQL_TOKEN_LEFT - | SQL_TOKEN_RIGHT - ; -string_function_3Argument: - SQL_TOKEN_REPLACE - ; -string_function_4Argument: - SQL_TOKEN_INSERT - ; - -string_function: - SQL_TOKEN_CHAR - | SQL_TOKEN_CONCAT - | SQL_TOKEN_DIFFERENCE - | SQL_TOKEN_LOCATE_2 - | SQL_TOKEN_SOUNDEX - ; -date_function_0Argument: - SQL_TOKEN_CURDATE - | SQL_TOKEN_CURTIME - | SQL_TOKEN_NOW - ; -date_function_1Argument: - SQL_TOKEN_DAYOFWEEK - | SQL_TOKEN_DAYOFMONTH - | SQL_TOKEN_DAYOFYEAR - | SQL_TOKEN_MONTH - | SQL_TOKEN_DAYNAME - | SQL_TOKEN_MONTHNAME - | SQL_TOKEN_QUARTER - | SQL_TOKEN_HOUR - | SQL_TOKEN_MINUTE - | SQL_TOKEN_SECOND - | SQL_TOKEN_YEAR - | SQL_TOKEN_DAY - | SQL_TOKEN_TIMEVALUE - | SQL_TOKEN_DATEVALUE - ; - -date_function: - SQL_TOKEN_TIMESTAMPADD - | SQL_TOKEN_TIMESTAMPDIFF - ; -numeric_function_0Argument: - SQL_TOKEN_PI - ; -numeric_function_1Argument: - SQL_TOKEN_ABS - | SQL_TOKEN_ACOS - | SQL_TOKEN_ASIN - | SQL_TOKEN_ATAN - | SQL_TOKEN_CEILING - | SQL_TOKEN_COS - | SQL_TOKEN_COT - | SQL_TOKEN_DEGREES - | SQL_TOKEN_FLOOR - | SQL_TOKEN_SIGN - | SQL_TOKEN_SIN - | SQL_TOKEN_SQRT - | SQL_TOKEN_TAN - | SQL_TOKEN_EXP - | SQL_TOKEN_LOG10 - | SQL_TOKEN_LN - | SQL_TOKEN_RADIANS - | SQL_TOKEN_ROUNDMAGIC - ; -numeric_function_2Argument: - SQL_TOKEN_ATAN2 - | SQL_TOKEN_MOD - | SQL_TOKEN_POWER - ; -numeric_function: - SQL_TOKEN_RAND - | SQL_TOKEN_TRUNCATE - ; - -window_function: - window_function_type SQL_TOKEN_OVER window_name_or_specification - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -window_function_type : - rank_function_type '(' ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_ROW_NUMBER '(' ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | general_set_fct - | ntile_function - | lead_or_lag_function - | first_or_last_value_function - | nth_value_function -; -ntile_function : - SQL_TOKEN_NTILE '(' number_of_tiles ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -dynamic_parameter_specification: - parameter - ; -simple_value_specification: - literal - ; -number_of_tiles : - simple_value_specification - | dynamic_parameter_specification - ; -opt_lead_or_lag_function: - /* empty */ {$$ = SQL_NEW_RULE;} - | ',' offset - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($2); - } - | ',' offset ',' default_expression - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($4); - } - ; -opt_null_treatment: - /* empty */ {$$ = SQL_NEW_RULE;} - | null_treatment - ; - -lead_or_lag_function: - lead_or_lag '(' lead_or_lag_extent opt_lead_or_lag_function ')' opt_null_treatment - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($6); - } - ; -lead_or_lag: - SQL_TOKEN_LEAD - | SQL_TOKEN_LAG - ; -lead_or_lag_extent: - value_exp - ; -offset: - SQL_TOKEN_INTNUM - ; -default_expression: - value_exp - ; -null_treatment: - SQL_TOKEN_RESPECT SQL_TOKEN_NULLS - | SQL_TOKEN_IGNORE SQL_TOKEN_NULLS - ; -first_or_last_value_function: - first_or_last_value '(' value_exp ')' opt_null_treatment - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($5); - } - ; -first_or_last_value : - SQL_TOKEN_FIRST_VALUE - | SQL_TOKEN_LAST_VALUE - ; -opt_from_first_or_last: - /* empty */ {$$ = SQL_NEW_RULE;} - | from_first_or_last - ; -nth_value_function: - SQL_TOKEN_NTH_VALUE '(' value_exp ',' nth_row ')' opt_from_first_or_last opt_null_treatment - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($7); - $$->append($8); - } - ; -nth_row: - simple_value_specification - | dynamic_parameter_specification - ; -from_first_or_last: - SQL_TOKEN_FROM SQL_TOKEN_FIRST - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_FROM SQL_TOKEN_LAST - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -window_name: - SQL_TOKEN_NAME - ; -window_name_or_specification: - window_name - | in_line_window_specification - ; -in_line_window_specification: - window_specification - ; -opt_window_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | window_clause - ; -window_clause: - SQL_TOKEN_WINDOW window_definition_list - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -window_definition_list: - window_definition_list ',' window_definition - {$1->append($3); - $$ = $1;} - | window_definition - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - ; -window_definition: - new_window_name SQL_TOKEN_AS window_specification - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -new_window_name: - window_name - ; -window_specification: - '(' window_specification_details ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -opt_existing_window_name: - /* empty */ {$$ = SQL_NEW_RULE;} - | existing_window_name - ; -opt_window_partition_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | window_partition_clause - ; -opt_window_frame_clause: - /* empty */ {$$ = SQL_NEW_RULE;} - | window_frame_clause - ; -window_specification_details: - opt_existing_window_name - opt_window_partition_clause - opt_order_by_clause - opt_window_frame_clause - ; -existing_window_name: - window_name - ; -window_partition_clause: - SQL_TOKEN_PARTITION SQL_TOKEN_BY window_partition_column_reference_list - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -window_partition_column_reference_list: - window_partition_column_reference_list ',' window_partition_column_reference - {$1->append($3); - $$ = $1;} - | window_partition_column_reference - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - ; -window_partition_column_reference: - column_ref opt_collate_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -opt_window_frame_exclusion: - /* empty */ {$$ = SQL_NEW_RULE;} - | window_frame_exclusion - ; -window_frame_clause: - window_frame_units window_frame_extent opt_window_frame_exclusion - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -window_frame_units: - SQL_TOKEN_ROWS - | SQL_TOKEN_RANGE - ; -window_frame_extent: - window_frame_start - | window_frame_between - ; -window_frame_start: - SQL_TOKEN_UNBOUNDED SQL_TOKEN_PRECEDING - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | window_frame_preceding - | SQL_TOKEN_CURRENT SQL_TOKEN_ROW - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -window_frame_preceding: - unsigned_value_spec SQL_TOKEN_PRECEDING - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -window_frame_between: - SQL_TOKEN_BETWEEN window_frame_bound_1 SQL_TOKEN_AND window_frame_bound_2 - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -window_frame_bound_1: - window_frame_bound - ; -window_frame_bound_2: - window_frame_bound - ; -window_frame_bound: - window_frame_start - | SQL_TOKEN_UNBOUNDED SQL_TOKEN_FOLLOWING - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | window_frame_following - ; -window_frame_following: - unsigned_value_spec SQL_TOKEN_FOLLOWING - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -window_frame_exclusion: - SQL_TOKEN_EXCLUDE SQL_TOKEN_CURRENT SQL_TOKEN_ROW - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_EXCLUDE SQL_TOKEN_GROUP - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_EXCLUDE SQL_TOKEN_TIES - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_EXCLUDE SQL_TOKEN_NO SQL_TOKEN_OTHERS - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -op_parameter: - {$$ = SQL_NEW_RULE;} - | '?' SQL_EQUAL - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("?", SQL_NODE_PUNCTUATION)); - $$->append($2); - } - ; -odbc_call_spec: - op_parameter SQL_TOKEN_CALL table_node op_odbc_call_parameter - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; - -op_odbc_call_parameter: - {$$ = SQL_NEW_RULE;} - | '(' odbc_parameter_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; - -odbc_parameter_commalist: - odbc_parameter - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | odbc_parameter_commalist ',' odbc_parameter - { - $1->append($3); - $$ = $1; - } - ; -odbc_parameter: - /* empty */ {$$ = SQL_NEW_RULE;} - | literal - | parameter - ; - -odbc_fct_spec: - odbc_fct_type SQL_TOKEN_STRING - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_FN set_fct_spec - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; - -odbc_fct_type: - SQL_TOKEN_D - | SQL_TOKEN_T - | SQL_TOKEN_TS - ; - -general_set_fct: - set_fct_type '(' opt_all_distinct function_arg ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_COUNT '(' '*' ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION)); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_COUNT '(' opt_all_distinct function_arg ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | ordered_set_function - | array_aggregate_function - ; -set_fct_type: - SQL_TOKEN_AVG - | SQL_TOKEN_MAX - | SQL_TOKEN_MIN - | SQL_TOKEN_SUM - | SQL_TOKEN_EVERY - | SQL_TOKEN_ANY - | SQL_TOKEN_SOME - | SQL_TOKEN_STDDEV_POP - | SQL_TOKEN_STDDEV_SAMP - | SQL_TOKEN_VAR_SAMP - | SQL_TOKEN_VAR_POP - | SQL_TOKEN_COLLECT - | SQL_TOKEN_FUSION - | SQL_TOKEN_INTERSECTION - ; - -ordered_set_function: - hypothetical_set_function - | inverse_distribution_function - ; -hypothetical_set_function: - rank_function_type '(' hypothetical_set_function_value_expression_list ')' within_group_specification - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($5); - } - | rank_function_type '(' hypothetical_set_function_value_expression_list SQL_TOKEN_BY value_exp_commalist ')' within_group_specification - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($7); - } - ; - -within_group_specification: - { - $$ = SQL_NEW_RULE; - } - | SQL_TOKEN_WITHIN SQL_TOKEN_GROUP '(' opt_order_by_clause ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -hypothetical_set_function_value_expression_list: - value_exp_commalist - ; - -inverse_distribution_function: - inverse_distribution_function_type '('inverse_distribution_function_argument ')' within_group_specification - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -inverse_distribution_function_argument: - num_value_exp - ; -inverse_distribution_function_type: - SQL_TOKEN_PERCENTILE_CONT - | SQL_TOKEN_PERCENTILE_DISC - ; - -array_aggregate_function: - SQL_TOKEN_ARRAY_AGG '(' value_exp opt_order_by_clause ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; - -rank_function_type: - SQL_TOKEN_RANK - | SQL_TOKEN_DENSE_RANK - | SQL_TOKEN_PERCENT_RANK - | SQL_TOKEN_CUME_DIST - ; -outer_join_type: - SQL_TOKEN_LEFT %prec SQL_TOKEN_LEFT - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_RIGHT %prec SQL_TOKEN_RIGHT - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_FULL %prec SQL_TOKEN_FULL - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -join_condition: - SQL_TOKEN_ON search_condition - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -join_spec: - join_condition - | named_columns_join - ; -join_type: - /* empty */ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_INNER - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | outer_join_type - | outer_join_type SQL_TOKEN_OUTER - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -cross_union: - table_ref SQL_TOKEN_CROSS SQL_TOKEN_JOIN table_ref - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; - -qualified_join: - /* wenn SQL_TOKEN_NATURAL, dann keine join_spec */ - table_ref SQL_TOKEN_NATURAL join_type SQL_TOKEN_JOIN table_ref - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - | table_ref join_type SQL_TOKEN_JOIN table_ref join_spec - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - | cross_union - ; -joined_table: - qualified_join - ; -named_columns_join: - SQL_TOKEN_USING '(' column_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -simple_table: - select_statement - | values_or_query_spec - ; - -non_join_query_primary: - simple_table - | '(' non_join_query_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -non_join_query_term: - non_join_query_primary - | query_term SQL_TOKEN_INTERSECT all query_primary - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -query_primary: - non_join_query_primary - ; -non_join_query_exp: - non_join_query_term - | query_exp SQL_TOKEN_UNION all query_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | query_exp SQL_TOKEN_EXCEPT all query_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -all: - /* empty*/ {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ALL - ; -query_exp: - non_join_query_exp /*[^')']*/ - ; -scalar_subquery: - subquery - ; -cast_operand: - value_exp - ; -cast_target: - table_node - | data_type - ; -cast_spec: - SQL_TOKEN_CAST '(' cast_operand SQL_TOKEN_AS cast_target ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -value_exp_primary: - unsigned_value_spec - | column_ref - | set_fct_spec - | scalar_subquery - | case_expression - | window_function - | '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | cast_spec - ; - -num_primary: - value_exp_primary - | num_value_fct - ; -factor: - num_primary - | '-' num_primary %prec SQL_TOKEN_UMINUS - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("-", SQL_NODE_PUNCTUATION)); - $$->append($2); - } - | '+' num_primary %prec SQL_TOKEN_UMINUS - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($2); - } - ; - -term: - factor - | term '*' factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | term '/' factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - ; - -num_value_exp: - term - | num_value_exp '+' term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | num_value_exp '-' term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - ; -datetime_primary: -/* value_exp_primary - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - |*/ datetime_value_fct - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -datetime_value_fct: - SQL_TOKEN_CURRENT_DATE - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_CURRENT_TIME - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | SQL_TOKEN_CURRENT_TIMESTAMP - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -time_zone: - SQL_TOKEN_AT time_zone_specifier - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -time_zone_specifier: - SQL_TOKEN_LOCAL - { - $$ = SQL_NEW_RULE; - $$->append($1); - } -/* | SQL_TOKEN_TIME SQL_TOKEN_ZONE interval_value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - }*/ - ; -datetime_factor: - datetime_primary - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | datetime_primary time_zone - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -datetime_term: - datetime_factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -/* -interval_term: - literal - | interval_term '*' factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | interval_term '/' factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - ; -*/ -datetime_value_exp: - datetime_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - } -/* | interval_value_exp '+' datetime_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | datetime_value_exp '+' interval_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | datetime_value_exp '-' interval_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); - $$->append($3); - } -*/ ; -/* -interval_value_exp: - interval_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | interval_value_exp '+' interval_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | interval_value_exp '-' interval_term - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | '(' datetime_value_exp '-' datetime_term ')' interval_qualifier - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode("-", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - $$->append($6); - } - ; -*/ -non_second_datetime_field: - SQL_TOKEN_YEAR - | SQL_TOKEN_MONTH - | SQL_TOKEN_DAY - | SQL_TOKEN_HOUR - | SQL_TOKEN_MINUTE - ; -start_field: - non_second_datetime_field opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -end_field: - non_second_datetime_field - | SQL_TOKEN_SECOND opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; - -single_datetime_field: - non_second_datetime_field opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_SECOND opt_paren_precision_scale - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; - -interval_qualifier: - start_field SQL_TOKEN_TO end_field - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | single_datetime_field - ; - -function_arg_commalist2: - function_arg ',' function_arg - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1); - $$->append($3);} - ; -function_arg_commalist3: - function_arg ',' function_arg ',' function_arg - { - $$ = SQL_NEW_COMMALISTRULE; - $$->append($1); - $$->append($3); - $$->append($5); - } - ; -function_arg_commalist4: - function_arg ',' function_arg ',' function_arg ',' function_arg - { - $$ = SQL_NEW_COMMALISTRULE; - $$->append($1); - $$->append($3); - $$->append($5); - $$->append($7); - } - ; -value_exp_commalist: - value_exp - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | value_exp_commalist ',' value_exp - {$1->append($3); - $$ = $1;} - /* this rule is only valid if we check predicates */ - | value_exp_commalist ';' value_exp - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $1->append($3); - $$ = $1; - } - else - YYERROR; - } - ; -function_arg: - result - | value_exp comparison value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | value_exp SQL_TOKEN_USING value_exp comparison value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | value_exp SQL_TOKEN_BY value_exp_commalist - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -function_args_commalist: - function_arg - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | function_args_commalist ',' function_arg - {$1->append($3); - $$ = $1;} - /* this rule is only valid if we check predicates */ - | function_args_commalist ';' function_arg - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) - { - $1->append($3); - $$ = $1; - } - else - YYERROR; - } - ; - -value_exp: - num_value_exp /*[^')']*/ - | string_value_exp - | datetime_value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -string_value_exp: - char_value_exp -/* | bit_value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - } -*/ ; -char_value_exp: - char_factor - | concatenation - ; -concatenation: - char_value_exp '+' char_factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | value_exp SQL_CONCAT value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; - -char_primary: - SQL_TOKEN_STRING - | string_value_fct - ; -collate_clause: - SQL_TOKEN_COLLATE table_node - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -char_factor: - char_primary - | char_primary collate_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -string_value_fct: - char_value_fct - | bit_value_fct - ; -bit_value_fct: - bit_substring_fct - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -bit_substring_fct: - SQL_TOKEN_SUBSTRING '(' bit_value_exp SQL_TOKEN_FROM string_value_exp for_length ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -bit_value_exp: - bit_factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -/* - bit_concatenation - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | -bit_concatenation: - bit_value_exp '+' bit_factor - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - ; -*/ -bit_factor: - bit_primary - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -bit_primary: - {$$ = SQL_NEW_RULE;} -/* value_exp_primary - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | string_value_fct - { - $$ = SQL_NEW_RULE; - $$->append($1); - }*/ - ; -char_value_fct: - char_substring_fct - | fold - | form_conversion - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | char_translation - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - | trim_fct - { - $$ = SQL_NEW_RULE; - $$->append($1); - } - ; -for_length: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_FOR value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -char_substring_fct: - SQL_TOKEN_SUBSTRING '(' value_exp SQL_TOKEN_FROM value_exp for_length ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_SUBSTRING '(' value_exp_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -upper_lower: - SQL_TOKEN_UPPER - | SQL_TOKEN_LOWER - ; -fold: - upper_lower '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -form_conversion: - SQL_TOKEN_CONVERT '(' string_value_exp SQL_TOKEN_USING table_node ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_CONVERT '(' cast_operand ',' cast_target ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($2 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -char_translation: - SQL_TOKEN_TRANSLATE '(' string_value_exp SQL_TOKEN_USING table_node ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -trim_fct: - SQL_TOKEN_TRIM '(' trim_operands ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -trim_operands: - trim_spec value_exp SQL_TOKEN_FROM value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | trim_spec SQL_TOKEN_FROM value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | value_exp SQL_TOKEN_FROM value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_FROM value_exp - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | value_exp - ; - -trim_spec: - SQL_TOKEN_BOTH - | SQL_TOKEN_LEADING - | SQL_TOKEN_TRAILING - ; - -derived_column: - value_exp as_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -/* Tabellenname */ -table_node: - table_name - | schema_name - | catalog_name -; -catalog_name: - SQL_TOKEN_NAME '.' schema_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | SQL_TOKEN_NAME ':' schema_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(":", SQL_NODE_PUNCTUATION)); - $$->append($3); - } -; -schema_name: - SQL_TOKEN_NAME '.' table_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - } -; - -table_name: - SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1);} -; -/* Columns */ -column_ref: - column - {$$ = SQL_NEW_RULE; - $$->append($1);} -/* | table_node '.' column_val %prec '.' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3);} -*/ - | SQL_TOKEN_NAME '.' column_val %prec '.' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - } - | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($5);} - | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2= newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($7); - } - | SQL_TOKEN_NAME ':' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2= newNode(":", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($7); - } -/* | SQL_TOKEN_NAME ';' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2= newNode(";", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($5); - $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); - $$->append($7); - } -*/ ; - - /* data types */ -column_val: - column - {$$ = SQL_NEW_RULE; - $$->append($1);} - | '*' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("*", SQL_NODE_PUNCTUATION)); - } - ; -data_type: - predefined_type - ; -opt_char_set_spec: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_CHARACTER SQL_TOKEN_SET SQL_TOKEN_NAME - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -opt_collate_clause: - {$$ = SQL_NEW_RULE;} - | collate_clause - ; -predefined_type: - character_string_type opt_char_set_spec opt_collate_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | national_character_string_type opt_collate_clause - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | binary_string_type - | numeric_type - | boolean_type - | datetime_type - | interval_type - ; -character_string_type: - SQL_TOKEN_CHARACTER opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_CHAR opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_VARCHAR paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | character_large_object_type - ; -opt_paren_precision: - {$$ = SQL_NEW_RULE;} - | paren_char_length - ; -paren_char_length: - '(' SQL_TOKEN_INTNUM ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -opt_paren_char_large_length: - {$$ = SQL_NEW_RULE;} - | paren_character_large_object_length - ; -paren_character_large_object_length: - '(' large_object_length ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; - -large_object_length: - SQL_TOKEN_INTNUM opt_multiplier - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -opt_multiplier: - {$$ = SQL_NEW_RULE;} - | 'K' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("K", SQL_NODE_PUNCTUATION)); - } - | 'M' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("M", SQL_NODE_PUNCTUATION)); - } - | 'G' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("G", SQL_NODE_PUNCTUATION)); - } - | 'T' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("T", SQL_NODE_PUNCTUATION)); - } - | 'P' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("P", SQL_NODE_PUNCTUATION)); - } - ; -character_large_object_type: - SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_CHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_CLOB opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -national_character_string_type: - SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_NCHAR opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_NCHAR SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | national_character_large_object_type - ; -national_character_large_object_type: - SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - | SQL_TOKEN_NCHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_NCLOB opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -binary_string_type: - SQL_TOKEN_BINARY opt_paren_precision - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_BINARY SQL_TOKEN_VARYING paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_VARBINARY paren_char_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | binary_large_object_string_type - ; -binary_large_object_string_type: - SQL_TOKEN_BINARY SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_BLOB opt_paren_char_large_length - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -numeric_type: - exact_numeric_type - | approximate_numeric_type - ; -opt_paren_precision_scale: - {$$ = SQL_NEW_RULE;} - | '(' SQL_TOKEN_INTNUM ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | '(' SQL_TOKEN_INTNUM ',' SQL_TOKEN_INTNUM ')' - { - $$ = SQL_NEW_RULE; - $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode(",", SQL_NODE_PUNCTUATION)); - $$->append($4); - $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -exact_numeric_type: - SQL_TOKEN_NUMERIC opt_paren_precision_scale - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_DECIMAL opt_paren_precision_scale - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_DEC opt_paren_precision_scale - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - | SQL_TOKEN_SMALLINT - | SQL_TOKEN_INTEGER - | SQL_TOKEN_INT - | SQL_TOKEN_BIGINT - ; -approximate_numeric_type: - SQL_TOKEN_FLOAT '(' SQL_TOKEN_INTNUM ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_FLOAT - | SQL_TOKEN_REAL - | SQL_TOKEN_DOUBLE - | SQL_TOKEN_DOUBLE SQL_TOKEN_PRECISION - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -boolean_type: - SQL_TOKEN_BOOLEAN -; -datetime_type: - SQL_TOKEN_DATE - | SQL_TOKEN_TIME opt_paren_precision opt_with_or_without_time_zone - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_TIMESTAMP opt_paren_precision opt_with_or_without_time_zone - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -opt_with_or_without_time_zone: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_WITH SQL_TOKEN_TIME SQL_TOKEN_ZONE - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - | SQL_TOKEN_WITHOUT SQL_TOKEN_TIME SQL_TOKEN_ZONE - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -interval_type: - SQL_TOKEN_INTERVAL interval_qualifier - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; - /* the various things you can name */ - -column: - SQL_TOKEN_NAME - | SQL_TOKEN_POSITION - { - sal_uInt32 nNod = $$->getRuleID(); - delete $$; - $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); - } - | SQL_TOKEN_CHAR_LENGTH - { - sal_uInt32 nNod = $$->getRuleID(); - delete $$; - $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); - } - | SQL_TOKEN_EXTRACT - { - sal_uInt32 nNod = $$->getRuleID(); - delete $$; - $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); - } - ; -case_expression: - case_abbreviation - | case_specification - ; -case_abbreviation: - SQL_TOKEN_NULLIF '(' value_exp_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_COALESCE '(' value_exp ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - | SQL_TOKEN_COALESCE '(' value_exp_commalist ')' - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); - $$->append($3); - $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); - } - ; -case_specification: - simple_case - | searched_case - ; -simple_case: - SQL_TOKEN_CASE case_operand simple_when_clause_list else_clause SQL_TOKEN_END - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - } - ; -searched_case: - SQL_TOKEN_CASE searched_when_clause_list else_clause SQL_TOKEN_END - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -simple_when_clause_list: - simple_when_clause - { - $$ = SQL_NEW_LISTRULE; - $$->append($1); - } - | searched_when_clause_list simple_when_clause - { - $1->append($2); - $$ = $1; - } - ; -simple_when_clause: - SQL_TOKEN_WHEN when_operand_list SQL_TOKEN_THEN result - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -when_operand_list: - when_operand - {$$ = SQL_NEW_COMMALISTRULE; - $$->append($1);} - | when_operand_list ',' when_operand - {$1->append($3); - $$ = $1;} - ; -when_operand: - row_value_constructor_elem - | comparison_predicate_part_2 - | between_predicate_part_2 - | in_predicate_part_2 - | character_like_predicate_part_2 - | null_predicate_part_2 -; -searched_when_clause_list: - searched_when_clause - { - $$ = SQL_NEW_LISTRULE; - $$->append($1); - } - | searched_when_clause_list searched_when_clause - { - $1->append($2); - $$ = $1; - } - ; -searched_when_clause: - SQL_TOKEN_WHEN search_condition SQL_TOKEN_THEN result - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - ; -else_clause: - {$$ = SQL_NEW_RULE;} - | SQL_TOKEN_ELSE result - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -result: - result_expression - | SQL_TOKEN_NULL - ; -result_expression: - value_exp - ; -case_operand: - row_value_constructor_elem - ; - -cursor: SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1);} - ; - -/*** -module: SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1);} - ; -***/ - -parameter: - ':' SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode(":", SQL_NODE_PUNCTUATION)); - $$->append($2);} - | '?' - {$$ = SQL_NEW_RULE; // test - $$->append($1 = newNode("?", SQL_NODE_PUNCTUATION));} - | '[' SQL_TOKEN_NAME ']' - {$$ = SQL_NEW_RULE; - $$->append($1 = newNode("[", SQL_NODE_PUNCTUATION)); - $$->append($2); - $$->append($3 = newNode("]", SQL_NODE_PUNCTUATION));} - ; - -/*** -procedure: SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1);} - ; -***/ - -range_variable: - {$$ = SQL_NEW_RULE;} - | opt_as SQL_TOKEN_NAME - {$$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; - -user: SQL_TOKEN_NAME - ; - -/* PREDICATECHECK RULES */ -sql: - search_condition /* checking predicats */ - { - if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // sql: rule 1 - { - $$ = $1; - if ( SQL_ISRULE($$,search_condition) ) - { - $$->insert(0,newNode("(", SQL_NODE_PUNCTUATION)); - $$->append(newNode(")", SQL_NODE_PUNCTUATION)); - } - } - else - YYERROR; - } - | '(' sql ')' /* checking predicats */ - ; -trigger_definition: - SQL_TOKEN_CREATE SQL_TOKEN_TRIGGER trigger_name trigger_action_time trigger_event SQL_TOKEN_ON table_name op_referencing triggered_action - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - $$->append($5); - $$->append($6); - $$->append($7); - $$->append($8); - $$->append($9); - } - ; -op_referencing: - { - $$ = SQL_NEW_RULE; - } - | SQL_TOKEN_REFERENCING transition_table_or_variable_list - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -trigger_action_time: - SQL_TOKEN_BEFORE - | SQL_TOKEN_AFTER - | SQL_TOKEN_INSTEAD SQL_TOKEN_OF - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } -; -trigger_event: - SQL_TOKEN_INSERT - | SQL_TOKEN_DELETE - | SQL_TOKEN_UPDATE op_trigger_columnlist - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -op_trigger_columnlist: - { - $$ = SQL_NEW_RULE; - } - | SQL_TOKEN_OF trigger_column_list - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -trigger_column_list: - column_commalist - ; -triggered_action: - op_triggered_action_for triggered_when_clause triggered_SQL_statement - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -op_triggered_action_for: - { - $$ = SQL_NEW_RULE; - } - | SQL_TOKEN_FOR SQL_TOKEN_EACH trigger_for - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - } - ; -trigger_for: - SQL_TOKEN_ROW - | SQL_TOKEN_STATEMENT - ; -triggered_when_clause: - { - $$ = SQL_NEW_RULE; - } - | SQL_TOKEN_WHEN parenthesized_boolean_value_expression - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - } - ; -triggered_SQL_statement: - SQL_procedure_statement - | SQL_TOKEN_BEGIN SQL_TOKEN_ATOMIC SQL_procedure_statement_list ';' SQL_TOKEN_END - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4 = newNode(";", SQL_NODE_PUNCTUATION)); - $$->append($5); - } - ; -SQL_procedure_statement_list: - SQL_procedure_statement - { - $$ = SQL_NEW_LISTRULE; - $$->append($1); - } - | SQL_procedure_statement_list ';' SQL_procedure_statement - { - $1->append($3); - $$ = $1; - } - ; -SQL_procedure_statement: - sql - ; - -transition_table_or_variable_list: - transition_table_or_variable - { - $$ = SQL_NEW_LISTRULE; - $$->append($1); - } - | transition_table_or_variable_list transition_table_or_variable - { - $1->append($2); - $$ = $1; - } - ; - -transition_table_or_variable: - SQL_TOKEN_OLD opt_row opt_as old_transition_variable_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_NEW opt_row opt_as new_transition_variable_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_OLD SQL_TOKEN_TABLE opt_as old_transition_table_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } - | SQL_TOKEN_NEW SQL_TOKEN_TABLE opt_as new_transition_table_name - { - $$ = SQL_NEW_RULE; - $$->append($1); - $$->append($2); - $$->append($3); - $$->append($4); - } -; -old_transition_table_name: - transition_table_name -; -new_transition_table_name: - transition_table_name -; -transition_table_name: - SQL_TOKEN_NAME -; -old_transition_variable_name: - SQL_TOKEN_NAME -; -new_transition_variable_name: - SQL_TOKEN_NAME -; -trigger_name: - SQL_TOKEN_NAME -; -%% - - -using namespace ::com::sun::star::sdbc; -using namespace ::com::sun::star::beans; -using namespace ::com::sun::star::uno; -using namespace ::com::sun::star::i18n; -using namespace ::com::sun::star::lang; -using namespace ::com::sun::star::util; -using namespace ::osl; -using namespace ::dbtools; - -//============================================================ -//= a helper for static ascii pseudo-unicode strings -//============================================================ -// string constants -struct _ConstAsciiString_ -{ - sal_Int32 length; - sal_Char const* str; - - operator rtl::OUString () const { return rtl::OUString(str, length, RTL_TEXTENCODING_ASCII_US); } - operator const sal_Char * () const { return str; } - operator ::rtl::OString() const { return str; } -}; - -#define IMPLEMENT_CONSTASCII_STRING( name, string ) \ - _ConstAsciiString_ const name = { sizeof(string)-1, string } - -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_GENERAL, "Syntax error in SQL expression"); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_VALUE_NO_LIKE, "The value #1 can not be used with LIKE."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_FIELD_NO_LIKE, "LIKE can not be used with this field."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COMPARE, "The entered criterion can not be compared with this field."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_DATE_COMPARE, "The field can not be compared with a date."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_REAL_COMPARE, "The field can not be compared with a floating point number."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_INT_COMPARE, "The field can not be compared with a number."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE, "The database does not contain a table named \"#\"."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_OR_QUERY, "The database does contain neither a table nor a query named \"#\"."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COLUMN, "The column \"#1\" is unknown in the table \"#2\"."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_EXIST, "The database already contains a table or view with name \"#\"."); -IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_QUERY_EXIST, "The database already contains a query with name \"#\"."); - -IMPLEMENT_CONSTASCII_STRING(KEY_STR_LIKE, "LIKE"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_NOT, "NOT"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_NULL, "NULL"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_TRUE, "True"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_FALSE, "False"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_IS, "IS"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_BETWEEN, "BETWEEN"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_OR, "OR"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_AND, "AND"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_AVG, "AVG"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_COUNT, "COUNT"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_MAX, "MAX"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_MIN, "MIN"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_SUM, "SUM"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_EVERY, "EVERY"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_ANY, "ANY"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_SOME, "SOME"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_POP, "STDDEV_POP"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_SAMP, "STDDEV_SAMP"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_SAMP, "VAR_SAMP"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_POP, "VAR_POP"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_COLLECT, "COLLECT"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_FUSION, "FUSION"); -IMPLEMENT_CONSTASCII_STRING(KEY_STR_INTERSECTION, "INTERSECTION"); - -IMPLEMENT_CONSTASCII_STRING(FIELD_STR_NULLDATE, "NullDate"); - -IMPLEMENT_CONSTASCII_STRING(STR_SQL_TOKEN, "SQL_TOKEN_"); - -//========================================================================== -//= OParseContext -//========================================================================== -//----------------------------------------------------------------------------- -OParseContext::OParseContext() -{ -} - -//----------------------------------------------------------------------------- -OParseContext::~OParseContext() -{ -} - -//----------------------------------------------------------------------------- -::rtl::OUString OParseContext::getErrorMessage(ErrorCode _eCode) const -{ - ::rtl::OUString aMsg; - switch (_eCode) - { - case ERROR_GENERAL: aMsg = ERROR_STR_GENERAL; break; - case ERROR_VALUE_NO_LIKE: aMsg = ERROR_STR_VALUE_NO_LIKE; break; - case ERROR_FIELD_NO_LIKE: aMsg = ERROR_STR_FIELD_NO_LIKE; break; - case ERROR_INVALID_COMPARE: aMsg = ERROR_STR_INVALID_COMPARE; break; - case ERROR_INVALID_INT_COMPARE: aMsg = ERROR_STR_INVALID_INT_COMPARE; break; - case ERROR_INVALID_DATE_COMPARE: aMsg = ERROR_STR_INVALID_DATE_COMPARE; break; - case ERROR_INVALID_REAL_COMPARE: aMsg = ERROR_STR_INVALID_REAL_COMPARE; break; - case ERROR_INVALID_TABLE: aMsg = ERROR_STR_INVALID_TABLE; break; - case ERROR_INVALID_TABLE_OR_QUERY: aMsg = ERROR_STR_INVALID_TABLE_OR_QUERY; break; - case ERROR_INVALID_COLUMN: aMsg = ERROR_STR_INVALID_COLUMN; break; - case ERROR_INVALID_TABLE_EXIST: aMsg = ERROR_STR_INVALID_TABLE_EXIST; break; - case ERROR_INVALID_QUERY_EXIST: aMsg = ERROR_STR_INVALID_QUERY_EXIST; break; - default: - OSL_FAIL( "OParseContext::getErrorMessage: unknown error code!" ); - break; - } - return aMsg; -} - -//----------------------------------------------------------------------------- -::rtl::OString OParseContext::getIntlKeywordAscii(InternationalKeyCode _eKey) const -{ - ::rtl::OString aKeyword; - switch (_eKey) - { - case KEY_LIKE: aKeyword = KEY_STR_LIKE; break; - case KEY_NOT: aKeyword = KEY_STR_NOT; break; - case KEY_NULL: aKeyword = KEY_STR_NULL; break; - case KEY_TRUE: aKeyword = KEY_STR_TRUE; break; - case KEY_FALSE: aKeyword = KEY_STR_FALSE; break; - case KEY_IS: aKeyword = KEY_STR_IS; break; - case KEY_BETWEEN: aKeyword = KEY_STR_BETWEEN; break; - case KEY_OR: aKeyword = KEY_STR_OR; break; - case KEY_AND: aKeyword = KEY_STR_AND; break; - case KEY_AVG: aKeyword = KEY_STR_AVG; break; - case KEY_COUNT: aKeyword = KEY_STR_COUNT; break; - case KEY_MAX: aKeyword = KEY_STR_MAX; break; - case KEY_MIN: aKeyword = KEY_STR_MIN; break; - case KEY_SUM: aKeyword = KEY_STR_SUM; break; - case KEY_EVERY: aKeyword = KEY_STR_EVERY; break; - case KEY_ANY: aKeyword = KEY_STR_ANY; break; - case KEY_SOME: aKeyword = KEY_STR_SOME; break; - case KEY_STDDEV_POP: aKeyword = KEY_STR_STDDEV_POP; break; - case KEY_STDDEV_SAMP: aKeyword = KEY_STR_STDDEV_SAMP; break; - case KEY_VAR_SAMP: aKeyword = KEY_STR_VAR_SAMP; break; - case KEY_VAR_POP: aKeyword = KEY_STR_VAR_POP; break; - case KEY_COLLECT: aKeyword = KEY_STR_COLLECT; break; - case KEY_FUSION: aKeyword = KEY_STR_FUSION; break; - case KEY_INTERSECTION:aKeyword = KEY_STR_INTERSECTION; break; - case KEY_NONE: break; - default: - OSL_FAIL( "OParseContext::getIntlKeywordAscii: unknown key!" ); - break; - } - return aKeyword; -} - -//----------------------------------------------------------------------------- -IParseContext::InternationalKeyCode OParseContext::getIntlKeyCode(const ::rtl::OString& rToken) const -{ - static IParseContext::InternationalKeyCode Intl_TokenID[] = - { - KEY_LIKE, KEY_NOT, KEY_NULL, KEY_TRUE, - KEY_FALSE, KEY_IS, KEY_BETWEEN, KEY_OR, - KEY_AND, KEY_AVG, KEY_COUNT, KEY_MAX, - KEY_MIN, KEY_SUM, KEY_EVERY,KEY_ANY,KEY_SOME, - KEY_STDDEV_POP,KEY_STDDEV_SAMP,KEY_VAR_SAMP, - KEY_VAR_POP,KEY_COLLECT,KEY_FUSION,KEY_INTERSECTION - }; - - sal_uInt32 nCount = SAL_N_ELEMENTS( Intl_TokenID ); - for (sal_uInt32 i = 0; i < nCount; i++) - { - ::rtl::OString aKey = getIntlKeywordAscii(Intl_TokenID[i]); - if (rToken.equalsIgnoreAsciiCase(aKey)) - return Intl_TokenID[i]; - } - - return KEY_NONE; -} - -//------------------------------------------------------------------------------ -static Locale& impl_getLocaleInstance( ) -{ - static Locale s_aLocale( - ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "en" ) ), - ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "US" ) ), - ::rtl::OUString( ) - ); - return s_aLocale; -} - -//------------------------------------------------------------------------------ -void OParseContext::setDefaultLocale( const ::com::sun::star::lang::Locale& _rLocale ) -{ - impl_getLocaleInstance() = _rLocale; -} - -//------------------------------------------------------------------------------ -Locale OParseContext::getPreferredLocale( ) const -{ - return getDefaultLocale(); -} - -//------------------------------------------------------------------------------ -const Locale& OParseContext::getDefaultLocale() -{ - return impl_getLocaleInstance(); -} - -//========================================================================== -//= misc -//========================================================================== -// Der (leider globale) yylval fuer die Uebergabe von -// Werten vom Scanner an den Parser. Die globale Variable -// wird nur kurzzeitig verwendet, der Parser liest die Variable -// sofort nach dem Scanner-Aufruf in eine gleichnamige eigene -// Member-Variable. - -const double fMilliSecondsPerDay = 86400000.0; - -//------------------------------------------------------------------------------ - - -//------------------------------------------------------------------ -::rtl::OUString ConvertLikeToken(const OSQLParseNode* pTokenNode, const OSQLParseNode* pEscapeNode, sal_Bool bInternational) -{ - ::rtl::OUStringBuffer aMatchStr; - if (pTokenNode->isToken()) - { - sal_Unicode cEscape = 0; - if (pEscapeNode->count()) - cEscape = pEscapeNode->getChild(1)->getTokenValue().toChar(); - - // Platzhalter austauschen - aMatchStr = pTokenNode->getTokenValue(); - const sal_Int32 nLen = aMatchStr.getLength(); - ::rtl::OUStringBuffer sSearch,sReplace; - if ( bInternational ) - { - sSearch.appendAscii("%_",2); - sReplace.appendAscii("*?",2); - } - else - { - sSearch.appendAscii("*?",2); - sReplace.appendAscii("%_",2); - } - - for (sal_Int32 i = 0; i < nLen; i++) - { - const sal_Unicode c = aMatchStr.charAt(i); - if (c == sSearch.charAt(0) || c == sSearch.charAt(1)) - { - if (i > 0 && aMatchStr.charAt(i-1) == cEscape) - continue; - else - { - const sal_Unicode cCharacter = sReplace.charAt( (c == sSearch.charAt(0)) ? 0 : 1); - aMatchStr.setCharAt(i , cCharacter); - } - } - } - } - return aMatchStr.makeStringAndClear(); -} - -//========================================================================== -//= OSQLParser -//========================================================================== - -sal_uInt32 OSQLParser::s_nRuleIDs[OSQLParseNode::rule_count + 1]; -OSQLParser::RuleIDMap OSQLParser::s_aReverseRuleIDLookup; -OParseContext OSQLParser::s_aDefaultContext; - -sal_Int32 OSQLParser::s_nRefCount = 0; -// ::osl::Mutex OSQLParser::s_aMutex; -OSQLScanner* OSQLParser::s_pScanner = 0; -OSQLParseNodesGarbageCollector* OSQLParser::s_pGarbageCollector = 0; -::com::sun::star::uno::Reference< ::com::sun::star::i18n::XLocaleData> OSQLParser::s_xLocaleData = NULL; -//----------------------------------------------------------------------------- -void setParser(OSQLParser* _pParser) -{ - xxx_pGLOBAL_SQLPARSER = _pParser; -} -// ------------------------------------------------------------------------- -void OSQLParser::setParseTree(OSQLParseNode * pNewParseTree) -{ - ::osl::MutexGuard aGuard(getMutex()); - m_pParseTree = pNewParseTree; -} -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::parseTree(::rtl::OUString& rErrorMessage, - const ::rtl::OUString& rStatement, - sal_Bool bInternational) -{ - - - // Guard the parsing - ::osl::MutexGuard aGuard(getMutex()); - // must be reset - setParser(this); - - // defines how to scan - s_pScanner->SetRule(s_pScanner->GetSQLRule()); // initial - s_pScanner->prepareScan(rStatement, m_pContext, bInternational); - - SQLyylval.pParseNode = NULL; - // SQLyypvt = NULL; - m_pParseTree = NULL; - m_sErrorMessage = ::rtl::OUString(); - - // ... und den Parser anwerfen ... - if (SQLyyparse() != 0) - { - // only set the error message, if it's not already set - if (!m_sErrorMessage.getLength()) - m_sErrorMessage = s_pScanner->getErrorMessage(); - if (!m_sErrorMessage.getLength()) - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_GENERAL); - - rErrorMessage = m_sErrorMessage; - - // clear the garbage collector - (*s_pGarbageCollector)->clearAndDelete(); - return NULL; - } - else - { - (*s_pGarbageCollector)->clear(); - - // Das Ergebnis liefern (den Root Parse Node): - - // OSL_ENSURE(Sdbyyval.pParseNode != NULL,"OSQLParser: Parser hat keinen ParseNode geliefert"); - // return Sdbyyval.pParseNode; - // geht nicht wegen Bug in MKS YACC-erzeugtem Code (es wird ein falscher ParseNode - // geliefert). - - // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree - // - einfach diesen zurueckliefern: - OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert"); - return m_pParseTree; - } -} -//----------------------------------------------------------------------------- -::rtl::OString OSQLParser::TokenIDToStr(sal_uInt32 nTokenID, const IParseContext* pContext) -{ - ::rtl::OString aStr; - if (pContext) - { - IParseContext::InternationalKeyCode eKeyCode = IParseContext::KEY_NONE; - switch( nTokenID ) - { - case SQL_TOKEN_LIKE: eKeyCode = IParseContext::KEY_LIKE; break; - case SQL_TOKEN_NOT: eKeyCode = IParseContext::KEY_NOT; break; - case SQL_TOKEN_NULL: eKeyCode = IParseContext::KEY_NULL; break; - case SQL_TOKEN_TRUE: eKeyCode = IParseContext::KEY_TRUE; break; - case SQL_TOKEN_FALSE: eKeyCode = IParseContext::KEY_FALSE; break; - case SQL_TOKEN_IS: eKeyCode = IParseContext::KEY_IS; break; - case SQL_TOKEN_BETWEEN: eKeyCode = IParseContext::KEY_BETWEEN; break; - case SQL_TOKEN_OR: eKeyCode = IParseContext::KEY_OR; break; - case SQL_TOKEN_AND: eKeyCode = IParseContext::KEY_AND; break; - case SQL_TOKEN_AVG: eKeyCode = IParseContext::KEY_AVG; break; - case SQL_TOKEN_COUNT: eKeyCode = IParseContext::KEY_COUNT; break; - case SQL_TOKEN_MAX: eKeyCode = IParseContext::KEY_MAX; break; - case SQL_TOKEN_MIN: eKeyCode = IParseContext::KEY_MIN; break; - case SQL_TOKEN_SUM: eKeyCode = IParseContext::KEY_SUM; break; - } - if ( eKeyCode != IParseContext::KEY_NONE ) - aStr = pContext->getIntlKeywordAscii(eKeyCode); - } - - if (!aStr.getLength()) - { - aStr = yytname[YYTRANSLATE(nTokenID)]; - if(!aStr.compareTo("SQL_TOKEN_",10)) - aStr = aStr.copy(10); - } - return aStr; -} - -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParser::RuleIDToStr(sal_uInt32 nRuleID) -{ - OSL_ENSURE(nRuleID < SAL_N_ELEMENTS(yytname), "OSQLParser::RuleIDToStr: Invalid nRuleId!"); - return ::rtl::OUString::createFromAscii(yytname[nRuleID]); -} - -//----------------------------------------------------------------------------- -sal_uInt32 OSQLParser::StrToRuleID(const ::rtl::OString & rValue) -{ - // In yysvar nach dem angegebenen Namen suchen, den Index zurueckliefern - // (oder 0, wenn nicht gefunden) - static sal_uInt32 nLen = SAL_N_ELEMENTS(yytname); - for (sal_uInt32 i = YYTRANSLATE(SQL_TOKEN_INVALIDSYMBOL); i < (nLen-1); i++) - { - if (yytname && rValue == yytname[i]) - return i; - } - - // Nicht gefunden - return 0; -} - -//----------------------------------------------------------------------------- -OSQLParseNode::Rule OSQLParser::RuleIDToRule( sal_uInt32 _nRule ) -{ - return s_aReverseRuleIDLookup[ _nRule ]; -} - -//----------------------------------------------------------------------------- -sal_uInt32 OSQLParser::RuleID(OSQLParseNode::Rule eRule) -{ - return s_nRuleIDs[(sal_uInt16)eRule]; -} -// ------------------------------------------------------------------------- -sal_Int16 OSQLParser::buildNode(OSQLParseNode*& pAppend,OSQLParseNode* pCompare,OSQLParseNode* pLiteral,OSQLParseNode* pLiteral2) -{ - OSQLParseNode* pColumnRef = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); - pColumnRef->append(new OSQLInternalNode(m_sFieldName,SQL_NODE_NAME)); - OSQLParseNode* pComp = NULL; - if ( SQL_ISTOKEN( pCompare, BETWEEN) && pLiteral2 ) - pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::between_predicate_part_2)); - else - pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::comparison_predicate)); - - pComp->append(pColumnRef); - pComp->append(pCompare); - pComp->append(pLiteral); - if ( pLiteral2 ) - { - pComp->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD,SQL_TOKEN_AND)); - pComp->append(pLiteral2); - } - pAppend->append(pComp); - return 1; -} -//----------------------------------------------------------------------------- -sal_Int16 OSQLParser::buildStringNodes(OSQLParseNode*& pLiteral) -{ - if(!pLiteral) - return 1; - - if(SQL_ISRULE(pLiteral,set_fct_spec) || SQL_ISRULE(pLiteral,general_set_fct) || SQL_ISRULE(pLiteral,column_ref) - || SQL_ISRULE(pLiteral,subquery)) - return 1; // here I have a function that I can't transform into a string - - if(pLiteral->getNodeType() == SQL_NODE_INTNUM || pLiteral->getNodeType() == SQL_NODE_APPROXNUM || pLiteral->getNodeType() == SQL_NODE_ACCESS_DATE) - { - OSQLParseNode* pParent = pLiteral->getParent(); - - OSQLParseNode* pNewNode = new OSQLInternalNode(pLiteral->getTokenValue(), SQL_NODE_STRING); - pParent->replace(pLiteral, pNewNode); - delete pLiteral; - pLiteral = NULL; - return 1; - } - - for(sal_uInt32 i=0;i<pLiteral->count();++i) - { - OSQLParseNode* pChild = pLiteral->getChild(i); - buildStringNodes(pChild); - } - if(SQL_ISRULE(pLiteral,term) || SQL_ISRULE(pLiteral,value_exp_primary)) - { - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); - return 0; - } - return 1; -} -//----------------------------------------------------------------------------- -sal_Int16 OSQLParser::buildComparsionRule(OSQLParseNode*& pAppend,OSQLParseNode* pLiteral) -{ - OSQLParseNode* pComp = new OSQLInternalNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")), SQL_NODE_EQUAL); - return buildPredicateRule(pAppend,pLiteral,pComp); -} - - -//----------------------------------------------------------------------------- -void OSQLParser::reduceLiteral(OSQLParseNode*& pLiteral, sal_Bool bAppendBlank) -{ - OSL_ENSURE(pLiteral->isRule(), "This is no ::com::sun::star::chaos::Rule"); - OSL_ENSURE(pLiteral->count() == 2, "OSQLParser::ReduceLiteral() Invalid count"); - OSQLParseNode* pTemp = pLiteral; - ::rtl::OUStringBuffer aValue(pLiteral->getChild(0)->getTokenValue()); - if (bAppendBlank) - { - aValue.appendAscii(" "); - } - - aValue.append(pLiteral->getChild(1)->getTokenValue()); - - pLiteral = new OSQLInternalNode(aValue.makeStringAndClear(),SQL_NODE_STRING); - delete pTemp; -} - -// ------------------------------------------------------------------------- -void OSQLParser::error(const sal_Char *fmt) -{ - if(!m_sErrorMessage.getLength()) - { - ::rtl::OUString sStr(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8); - ::rtl::OUString sSQL_TOKEN(RTL_CONSTASCII_USTRINGPARAM("SQL_TOKEN_")); - - sal_Int32 nPos1 = sStr.indexOf(sSQL_TOKEN); - if(nPos1 != -1) - { - ::rtl::OUString sFirst = sStr.copy(0,nPos1); - sal_Int32 nPos2 = sStr.indexOf(sSQL_TOKEN,nPos1+1); - if(nPos2 != -1) - { - ::rtl::OUString sSecond = sStr.copy(nPos1+sSQL_TOKEN.getLength(),nPos2-nPos1-sSQL_TOKEN.getLength()); - sFirst += sSecond; - sFirst += sStr.copy(nPos2+sSQL_TOKEN.getLength()); - } - else - sFirst += sStr.copy(nPos1+sSQL_TOKEN.getLength()); - - m_sErrorMessage = sFirst; - } - else - m_sErrorMessage = sStr; - - ::rtl::OUString aError = s_pScanner->getErrorMessage(); - if(aError.getLength()) - { - m_sErrorMessage += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(", ")); - m_sErrorMessage += aError; - } - } -} -// ------------------------------------------------------------------------- -int OSQLParser::SQLlex() -{ - return s_pScanner->SQLlex(); -} - -#if defined __SUNPRO_CC -#pragma enable_warn -#elif defined _MSC_VER -#pragma warning(pop) -#endif diff --git a/connectivity/source/parse/sqlflex.l b/connectivity/source/parse/sqlflex.l deleted file mode 100755 index 85296a8633..0000000000 --- a/connectivity/source/parse/sqlflex.l +++ /dev/null @@ -1,836 +0,0 @@ -%{ - -//-------------------------------------------------------------------------- -// -// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -// -// Copyright 2000, 2010 Oracle and/or its affiliates. -// -// OpenOffice.org - a multi-platform office productivity suite -// -// This file is part of OpenOffice.org. -// -// OpenOffice.org is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License version 3 -// only, as published by the Free Software Foundation. -// -// OpenOffice.org is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License version 3 for more details -// (a copy is included in the LICENSE file that accompanied this code). -// -// You should have received a copy of the GNU Lesser General Public License -// version 3 along with OpenOffice.org. If not, see -// <http://www.openoffice.org/license.html> -// for a copy of the LGPLv3 License. -// -//-------------------------------------------------------------------------- - -#define YY_EXIT 1 // YY_FATAL will not halt the application - -#ifndef _CSTDARG_ -#include <cstdarg> // std::va_list -#endif - -#ifndef _INC_STRING -#include <string.h> -#endif - -#include "internalnode.hxx" - -#ifndef _CONNECTIVITY_SQLYACC_HXX -#define _CONNECTIVITY_SQLYACC_HXX - -#ifndef SQLYYDEBUG -#define SQLYYDEBUG 1 -#endif - -#include "sqlbison.hxx" -#endif -#include "sqlscan.hxx" -#include <osl/diagnose.h> -#include <rtl/strbuf.hxx> -#include <connectivity/sqlparse.hxx> - -#if defined __GNUC__ - #pragma GCC system_header -#elif defined __SUNPRO_CC -#pragma disable_warn -#elif defined _MSC_VER -#pragma warning(push, 1) -/**/ -#ifdef yywrap -#undef yywrap -#define yywrap() 1 -#endif -/**/ -#endif - -using namespace connectivity; - -//============================================================================= -// -// Erzeugung der Blaetter fuer die Token -// Blaetter werden generell vom Lexer erzeugt - -static ::rtl::OUString aEmptyString; - -static sal_Int32 gatherString(sal_Int32 delim, sal_Int32 nTyp); -static sal_Int32 gatherName(const sal_Char*); -static sal_Int32 gatherNamePre(const sal_Char* ); -// has to be set before the parser starts -OSQLScanner* xxx_pGLOBAL_SQLSCAN = NULL; - -#define SQL_NEW_NODE(text, token) \ - SQLyylval.pParseNode = new OSQLInternalNode(text, token); - -#define SQL_NEW_KEYWORD(token) \ - SQLyylval.pParseNode = new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, (token)); return token; - -#define SQL_NEW_INTNUM SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_INTNUM); return SQL_TOKEN_INTNUM; -#define SQL_NEW_APPROXNUM SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_APPROXNUM); return SQL_TOKEN_APPROXNUM; -#define SQL_NEW_DATE SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE); return SQL_TOKEN_ACCESS_DATE; - -#define YY_INPUT(buf,result,max_size) \ -{ \ - buf[0] = xxx_pGLOBAL_SQLSCAN->SQLyygetc(); \ - result = buf[0] != -1; \ -} - -#define YY_FATAL_ERROR(msg) \ -{ \ - xxx_pGLOBAL_SQLSCAN->SQLyyerror(msg); \ -} - -// -//============================================================================= - -%} - -%s SQL -%s PREDICATE_ENG -%s PREDICATE_GER -%s DATE -%s STRING - -%option noyywrap -%option never-interactive -%% - -ABS {SQL_NEW_KEYWORD(SQL_TOKEN_ABS); } -ACOS {SQL_NEW_KEYWORD(SQL_TOKEN_ACOS); } -AFTER {SQL_NEW_KEYWORD(SQL_TOKEN_AFTER); } -ALL {SQL_NEW_KEYWORD(SQL_TOKEN_ALL); } -ALTER {SQL_NEW_KEYWORD(SQL_TOKEN_ALTER); } -AND {SQL_NEW_KEYWORD(SQL_TOKEN_AND); } -ANY {SQL_NEW_KEYWORD(SQL_TOKEN_ANY); } -ARRAY_AGG {SQL_NEW_KEYWORD(SQL_TOKEN_ARRAY_AGG); } -AS {SQL_NEW_KEYWORD(SQL_TOKEN_AS); } -ASC {SQL_NEW_KEYWORD(SQL_TOKEN_ASC); } -ASCII {SQL_NEW_KEYWORD(SQL_TOKEN_ASCII); } -ASIN {SQL_NEW_KEYWORD(SQL_TOKEN_ASIN); } -AT {SQL_NEW_KEYWORD(SQL_TOKEN_AT); } -ATAN {SQL_NEW_KEYWORD(SQL_TOKEN_ATAN); } -ATAN2 {SQL_NEW_KEYWORD(SQL_TOKEN_ATAN2); } -ATOMIC {SQL_NEW_KEYWORD(SQL_TOKEN_ATOMIC); } -AUTHORIZATION {SQL_NEW_KEYWORD(SQL_TOKEN_AUTHORIZATION); } -AVG {SQL_NEW_KEYWORD(SQL_TOKEN_AVG); } - -BEFORE {SQL_NEW_KEYWORD(SQL_TOKEN_BEFORE); } -BEGIN {SQL_NEW_KEYWORD(SQL_TOKEN_BEGIN); } -BETWEEN {SQL_NEW_KEYWORD(SQL_TOKEN_BETWEEN); } -BIGINT {SQL_NEW_KEYWORD(SQL_TOKEN_BIGINT); } -BINARY {SQL_NEW_KEYWORD(SQL_TOKEN_BINARY); } -BIT {SQL_NEW_KEYWORD(SQL_TOKEN_BIT); } -BIT_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_BIT_LENGTH); } -BLOB {SQL_NEW_KEYWORD(SQL_TOKEN_BLOB); } -BOTH {SQL_NEW_KEYWORD(SQL_TOKEN_BOTH); } -BY {SQL_NEW_KEYWORD(SQL_TOKEN_BY); } - -CALL {SQL_NEW_KEYWORD(SQL_TOKEN_CALL); } -CASE {SQL_NEW_KEYWORD(SQL_TOKEN_CASE); } -CAST {SQL_NEW_KEYWORD(SQL_TOKEN_CAST); } -CEILING {SQL_NEW_KEYWORD(SQL_TOKEN_CEILING); } -CHAR {SQL_NEW_KEYWORD(SQL_TOKEN_CHAR); } -CHARACTER {SQL_NEW_KEYWORD(SQL_TOKEN_CHARACTER); } -CHAR(ACTER)?_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_CHAR_LENGTH); } -CHECK {SQL_NEW_KEYWORD(SQL_TOKEN_CHECK); } -CLOB {SQL_NEW_KEYWORD(SQL_TOKEN_CLOB); } -COALESCE {SQL_NEW_KEYWORD(SQL_TOKEN_COALESCE); } -COLLATE {SQL_NEW_KEYWORD(SQL_TOKEN_COLLATE); } -COLLECT {SQL_NEW_KEYWORD(SQL_TOKEN_COLLECT); } -COMMIT {SQL_NEW_KEYWORD(SQL_TOKEN_COMMIT); } -CONCAT {SQL_NEW_KEYWORD(SQL_TOKEN_CONCAT); } -CONTINUE {SQL_NEW_KEYWORD(SQL_TOKEN_CONTINUE); } -CONVERT {SQL_NEW_KEYWORD(SQL_TOKEN_CONVERT); } -COS {SQL_NEW_KEYWORD(SQL_TOKEN_COS); } -COT {SQL_NEW_KEYWORD(SQL_TOKEN_COT); } -COUNT {SQL_NEW_KEYWORD(SQL_TOKEN_COUNT); } -CREATE {SQL_NEW_KEYWORD(SQL_TOKEN_CREATE); } -CROSS {SQL_NEW_KEYWORD(SQL_TOKEN_CROSS); } -CUME_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_CUME_DIST); } -CURRENT {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT); } -CURRENT_DATE {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DATE); } -CURRENT_CATALOG {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_CATALOG); } -CURRENT_DEFAULT_TRANSFORM_GROUP {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP); } -CURRENT_PATH {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_PATH); } -CURRENT_ROLE {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_ROLE); } -CURRENT_SCHEMA {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_SCHEMA); } -CURRENT_USER {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_USER); } -CURDATE {SQL_NEW_KEYWORD(SQL_TOKEN_CURDATE); } -CURRENT_TIME {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIME); } -CURTIME {SQL_NEW_KEYWORD(SQL_TOKEN_CURTIME); } -CURRENT_TIMESTAMP {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIMESTAMP); } -CURSOR {SQL_NEW_KEYWORD(SQL_TOKEN_CURSOR); } - -D {SQL_NEW_KEYWORD(SQL_TOKEN_D); } -DATE {SQL_NEW_KEYWORD(SQL_TOKEN_DATE); } -DATEDIFF {SQL_NEW_KEYWORD(SQL_TOKEN_DATEDIFF); } -DATEVALUE {SQL_NEW_KEYWORD(SQL_TOKEN_DATEVALUE); } -DAY {SQL_NEW_KEYWORD(SQL_TOKEN_DAY); } -DAYNAME {SQL_NEW_KEYWORD(SQL_TOKEN_DAYNAME); } -DAYOFMONTH {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFMONTH); } -DAYOFWEEK {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFWEEK); } -DAYOFYEAR {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFYEAR); } -DEC {SQL_NEW_KEYWORD(SQL_TOKEN_DEC); } -DECIMAL {SQL_NEW_KEYWORD(SQL_TOKEN_DECIMAL); } -DECLARE {SQL_NEW_KEYWORD(SQL_TOKEN_DECLARE); } -DEFAULT {SQL_NEW_KEYWORD(SQL_TOKEN_DEFAULT); } -DEGREES {SQL_NEW_KEYWORD(SQL_TOKEN_DEGREES); } -DELETE {SQL_NEW_KEYWORD(SQL_TOKEN_DELETE); } -DENSE_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_DENSE_RANK); } -DESC {SQL_NEW_KEYWORD(SQL_TOKEN_DESC); } -DIFFERENCE {SQL_NEW_KEYWORD(SQL_TOKEN_DIFFERENCE); } -DISTINCT {SQL_NEW_KEYWORD(SQL_TOKEN_DISTINCT); } -DOUBLE {SQL_NEW_KEYWORD(SQL_TOKEN_DOUBLE); } -DROP {SQL_NEW_KEYWORD(SQL_TOKEN_DROP); } - -EACH {SQL_NEW_KEYWORD(SQL_TOKEN_EACH); } -ELSE {SQL_NEW_KEYWORD(SQL_TOKEN_ELSE); } -END {SQL_NEW_KEYWORD(SQL_TOKEN_END); } -EVERY {SQL_NEW_KEYWORD(SQL_TOKEN_EVERY); } -ESCAPE {SQL_NEW_KEYWORD(SQL_TOKEN_ESCAPE); } -EXCEPT {SQL_NEW_KEYWORD(SQL_TOKEN_EXCEPT); } -EXCLUDE {SQL_NEW_KEYWORD(SQL_TOKEN_EXCLUDE); } -EXISTS {SQL_NEW_KEYWORD(SQL_TOKEN_EXISTS); } -EXP {SQL_NEW_KEYWORD(SQL_TOKEN_EXP); } -EXTRACT {SQL_NEW_KEYWORD(SQL_TOKEN_EXTRACT); } - -FALSE {SQL_NEW_KEYWORD(SQL_TOKEN_FALSE); } -FETCH {SQL_NEW_KEYWORD(SQL_TOKEN_FETCH); } -FIRST {SQL_NEW_KEYWORD(SQL_TOKEN_FIRST); } -FIRST_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_FIRST_VALUE); } -FLOAT {SQL_NEW_KEYWORD(SQL_TOKEN_FLOAT); } -FLOOR {SQL_NEW_KEYWORD(SQL_TOKEN_FLOOR); } -FN {SQL_NEW_KEYWORD(SQL_TOKEN_FN); } -FOLLOWING {SQL_NEW_KEYWORD(SQL_TOKEN_FOLLOWING); } -FOR {SQL_NEW_KEYWORD(SQL_TOKEN_FOR); } -FOREIGN {SQL_NEW_KEYWORD(SQL_TOKEN_FOREIGN); } -FOUND {SQL_NEW_KEYWORD(SQL_TOKEN_FOUND); } -FROM {SQL_NEW_KEYWORD(SQL_TOKEN_FROM); } -FULL {SQL_NEW_KEYWORD(SQL_TOKEN_FULL); } -FUSION {SQL_NEW_KEYWORD(SQL_TOKEN_FUSION); } - -GRANT {SQL_NEW_KEYWORD(SQL_TOKEN_GRANT); } -GROUP {SQL_NEW_KEYWORD(SQL_TOKEN_GROUP); } - -HAVING {SQL_NEW_KEYWORD(SQL_TOKEN_HAVING); } -HOUR {SQL_NEW_KEYWORD(SQL_TOKEN_HOUR); } - -IGNORE {SQL_NEW_KEYWORD(SQL_TOKEN_IGNORE); } -IN {SQL_NEW_KEYWORD(SQL_TOKEN_IN); } -INNER {SQL_NEW_KEYWORD(SQL_TOKEN_INNER); } -INSERT {SQL_NEW_KEYWORD(SQL_TOKEN_INSERT); } -INSTEAD {SQL_NEW_KEYWORD(SQL_TOKEN_INSTEAD); } -INT(EGER)? {SQL_NEW_KEYWORD(SQL_TOKEN_INTEGER); } -INTERSECT {SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECT); } -INTERVAL {SQL_NEW_KEYWORD(SQL_TOKEN_INTERVAL); } -INTERSECTION {SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECTION); } -INTO {SQL_NEW_KEYWORD(SQL_TOKEN_INTO); } -IS {SQL_NEW_KEYWORD(SQL_TOKEN_IS); } - -JOIN {SQL_NEW_KEYWORD(SQL_TOKEN_JOIN); } - -KEY {SQL_NEW_KEYWORD(SQL_TOKEN_KEY); } - -LAG {SQL_NEW_KEYWORD(SQL_TOKEN_LAG); } -LARGE {SQL_NEW_KEYWORD(SQL_TOKEN_LARGE); } -LAST {SQL_NEW_KEYWORD(SQL_TOKEN_LAST); } -LAST_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_LAST_VALUE); } -LCASE {SQL_NEW_KEYWORD(SQL_TOKEN_LCASE); } -LEAD {SQL_NEW_KEYWORD(SQL_TOKEN_LEAD); } -LEADING {SQL_NEW_KEYWORD(SQL_TOKEN_LEADING); } -LEFT {SQL_NEW_KEYWORD(SQL_TOKEN_LEFT); } -LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_LENGTH); } -LIKE {SQL_NEW_KEYWORD(SQL_TOKEN_LIKE); } -LIMIT {SQL_NEW_KEYWORD(SQL_TOKEN_LIMIT); } -LN {SQL_NEW_KEYWORD(SQL_TOKEN_LN); } -LOCAL {SQL_NEW_KEYWORD(SQL_TOKEN_LOCAL); } -LOCATE {SQL_NEW_KEYWORD(SQL_TOKEN_LOCATE); } -LOG {SQL_NEW_KEYWORD(SQL_TOKEN_LOG); } -LOGF {SQL_NEW_KEYWORD(SQL_TOKEN_LOGF); } -LOG10 {SQL_NEW_KEYWORD(SQL_TOKEN_LOG10); } -LOWER {SQL_NEW_KEYWORD(SQL_TOKEN_LOWER); } -LTRIM {SQL_NEW_KEYWORD(SQL_TOKEN_LTRIM); } - -MAX {SQL_NEW_KEYWORD(SQL_TOKEN_MAX); } -MIN {SQL_NEW_KEYWORD(SQL_TOKEN_MIN); } -MINUTE {SQL_NEW_KEYWORD(SQL_TOKEN_MINUTE); } -MOD {SQL_NEW_KEYWORD(SQL_TOKEN_MOD); } -MONTH {SQL_NEW_KEYWORD(SQL_TOKEN_MONTH); } -MONTHNAME {SQL_NEW_KEYWORD(SQL_TOKEN_MONTHNAME); } - -NATIONAL {SQL_NEW_KEYWORD(SQL_TOKEN_NATIONAL); } -NATURAL {SQL_NEW_KEYWORD(SQL_TOKEN_NATURAL); } -NCHAR {SQL_NEW_KEYWORD(SQL_TOKEN_NCHAR); } -NCLOB {SQL_NEW_KEYWORD(SQL_TOKEN_NCLOB); } -NEW {SQL_NEW_KEYWORD(SQL_TOKEN_NEW); } -NEXT {SQL_NEW_KEYWORD(SQL_TOKEN_NEXT); } -NO {SQL_NEW_KEYWORD(SQL_TOKEN_NO); } -NOT {SQL_NEW_KEYWORD(SQL_TOKEN_NOT); } -NOW {SQL_NEW_KEYWORD(SQL_TOKEN_NOW); } -NTH_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_NTH_VALUE); } -NTILE {SQL_NEW_KEYWORD(SQL_TOKEN_NTILE); } -NULL {SQL_NEW_KEYWORD(SQL_TOKEN_NULL); } -NULLIF {SQL_NEW_KEYWORD(SQL_TOKEN_NULLIF); } -NULLS {SQL_NEW_KEYWORD(SQL_TOKEN_NULLS); } -NUMERIC {SQL_NEW_KEYWORD(SQL_TOKEN_NUMERIC); } - -OBJECT {SQL_NEW_KEYWORD(SQL_TOKEN_OBJECT); } -OCTET_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_OCTET_LENGTH); } -OF {SQL_NEW_KEYWORD(SQL_TOKEN_OF); } -OFFSET {SQL_NEW_KEYWORD(SQL_TOKEN_OFFSET); } -OJ {SQL_NEW_KEYWORD(SQL_TOKEN_OJ); } -OLD {SQL_NEW_KEYWORD(SQL_TOKEN_OLD); } -ON {SQL_NEW_KEYWORD(SQL_TOKEN_ON); } -ONLY {SQL_NEW_KEYWORD(SQL_TOKEN_ONLY); } -OPTION {SQL_NEW_KEYWORD(SQL_TOKEN_OPTION); } -OR {SQL_NEW_KEYWORD(SQL_TOKEN_OR); } -ORDER {SQL_NEW_KEYWORD(SQL_TOKEN_ORDER); } -OTHERS {SQL_NEW_KEYWORD(SQL_TOKEN_OTHERS); } -OUTER {SQL_NEW_KEYWORD(SQL_TOKEN_OUTER); } -OVER {SQL_NEW_KEYWORD(SQL_TOKEN_OVER); } - -PARTITION {SQL_NEW_KEYWORD(SQL_TOKEN_PARTITION); } -PERCENT_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENT_RANK); } -PERCENTILE_CONT {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_CONT); } -PERCENTILE_DISC {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_DISC); } -PI {SQL_NEW_KEYWORD(SQL_TOKEN_PI); } -POSITION {SQL_NEW_KEYWORD(SQL_TOKEN_POSITION); } -POWER {SQL_NEW_KEYWORD(SQL_TOKEN_POWER); } -PRECEDING {SQL_NEW_KEYWORD(SQL_TOKEN_PRECEDING); } -PRECISION {SQL_NEW_KEYWORD(SQL_TOKEN_PRECISION); } -PRIMARY {SQL_NEW_KEYWORD(SQL_TOKEN_PRIMARY); } -PRIVILEGES {SQL_NEW_KEYWORD(SQL_TOKEN_PRIVILEGES); } -PROCEDURE {SQL_NEW_KEYWORD(SQL_TOKEN_PROCEDURE); } -PUBLIC {SQL_NEW_KEYWORD(SQL_TOKEN_PUBLIC); } - -QUARTER {SQL_NEW_KEYWORD(SQL_TOKEN_QUARTER); } - -RADIANS {SQL_NEW_KEYWORD(SQL_TOKEN_RADIANS); } -RAND {SQL_NEW_KEYWORD(SQL_TOKEN_RAND); } -RANGE {SQL_NEW_KEYWORD(SQL_TOKEN_RANGE); } -RANK {SQL_NEW_KEYWORD(SQL_TOKEN_RANK); } -REAL {SQL_NEW_KEYWORD(SQL_TOKEN_REAL); } -REFERENCES {SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCES); } -REFERENCING {SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCING); } -REPEAT {SQL_NEW_KEYWORD(SQL_TOKEN_REPEAT); } -REPLACE {SQL_NEW_KEYWORD(SQL_TOKEN_REPLACE); } -RESPECT {SQL_NEW_KEYWORD(SQL_TOKEN_RESPECT); } -ROLLBACK {SQL_NEW_KEYWORD(SQL_TOKEN_ROLLBACK); } -ROUND {SQL_NEW_KEYWORD(SQL_TOKEN_ROUND); } -ROUNDMAGIC {SQL_NEW_KEYWORD(SQL_TOKEN_ROUNDMAGIC); } -ROW {SQL_NEW_KEYWORD(SQL_TOKEN_ROW); } -ROWS {SQL_NEW_KEYWORD(SQL_TOKEN_ROWS); } -ROW_NUMBER {SQL_NEW_KEYWORD(SQL_TOKEN_ROW_NUMBER); } -RIGHT {SQL_NEW_KEYWORD(SQL_TOKEN_RIGHT); } -RTRIM {SQL_NEW_KEYWORD(SQL_TOKEN_RTRIM); } - -SCHEMA {SQL_NEW_KEYWORD(SQL_TOKEN_SCHEMA); } -SECOND {SQL_NEW_KEYWORD(SQL_TOKEN_SECOND); } -SELECT {SQL_NEW_KEYWORD(SQL_TOKEN_SELECT); } -SET {SQL_NEW_KEYWORD(SQL_TOKEN_SET); } -SIZE {SQL_NEW_KEYWORD(SQL_TOKEN_SIZE); } -SIGN {SQL_NEW_KEYWORD(SQL_TOKEN_SIGN); } -SIN {SQL_NEW_KEYWORD(SQL_TOKEN_SIN); } -SMALLINT {SQL_NEW_KEYWORD(SQL_TOKEN_SMALLINT); } -SOME {SQL_NEW_KEYWORD(SQL_TOKEN_SOME); } -SOUNDEX {SQL_NEW_KEYWORD(SQL_TOKEN_SOUNDEX); } -SPACE {SQL_NEW_KEYWORD(SQL_TOKEN_SPACE); } -SQRT {SQL_NEW_KEYWORD(SQL_TOKEN_SQRT); } -STDDEV_POP {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_POP); } -STDDEV_SAMP {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_SAMP); } -STATEMENT {SQL_NEW_KEYWORD(SQL_TOKEN_STATEMENT); } -SUBSTRING {SQL_NEW_KEYWORD(SQL_TOKEN_SUBSTRING); } -SUM {SQL_NEW_KEYWORD(SQL_TOKEN_SUM); } -SESSION_USER {SQL_NEW_KEYWORD(SQL_TOKEN_SESSION_USER); } -SYSTEM_USER {SQL_NEW_KEYWORD(SQL_TOKEN_SYSTEM_USER); } - -TABLE {SQL_NEW_KEYWORD(SQL_TOKEN_TABLE); } -TAN {SQL_NEW_KEYWORD(SQL_TOKEN_TAN); } -THEN {SQL_NEW_KEYWORD(SQL_TOKEN_THEN); } -TIES {SQL_NEW_KEYWORD(SQL_TOKEN_TIES); } -TIME {SQL_NEW_KEYWORD(SQL_TOKEN_TIME); } -TIMESTAMP {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMP); } -TIMESTAMPADD {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPADD); } -TIMESTAMPDIFF {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPDIFF); } -TIMEVALUE {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEVALUE); } -TIMEZONE_HOUR {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_HOUR); } -TIMEZONE_MINUTE {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_MINUTE); } -TO {SQL_NEW_KEYWORD(SQL_TOKEN_TO); } -TRAILING {SQL_NEW_KEYWORD(SQL_TOKEN_TRAILING); } -TRANSLATE {SQL_NEW_KEYWORD(SQL_TOKEN_TRANSLATE); } -TRIGGER {SQL_NEW_KEYWORD(SQL_TOKEN_TRIGGER); } -TRIM {SQL_NEW_KEYWORD(SQL_TOKEN_TRIM); } -TRUE {SQL_NEW_KEYWORD(SQL_TOKEN_TRUE); } -TRUNCATE {SQL_NEW_KEYWORD(SQL_TOKEN_TRUNCATE); } -TS {SQL_NEW_KEYWORD(SQL_TOKEN_TS); } -T {SQL_NEW_KEYWORD(SQL_TOKEN_T); } - -UCASE {SQL_NEW_KEYWORD(SQL_TOKEN_UCASE); } -UNBOUNDED {SQL_NEW_KEYWORD(SQL_TOKEN_UNBOUNDED); } -UNION {SQL_NEW_KEYWORD(SQL_TOKEN_UNION); } -UNIQUE {SQL_NEW_KEYWORD(SQL_TOKEN_UNIQUE); } -UNKNOWN {SQL_NEW_KEYWORD(SQL_TOKEN_UNKNOWN); } -UPDATE {SQL_NEW_KEYWORD(SQL_TOKEN_UPDATE); } -UPPER {SQL_NEW_KEYWORD(SQL_TOKEN_UPPER); } -USAGE {SQL_NEW_KEYWORD(SQL_TOKEN_USAGE); } -USER {SQL_NEW_KEYWORD(SQL_TOKEN_USER); } -USING {SQL_NEW_KEYWORD(SQL_TOKEN_USING); } - -VARBINARY {SQL_NEW_KEYWORD(SQL_TOKEN_VARBINARY); } -VARCHAR {SQL_NEW_KEYWORD(SQL_TOKEN_VARCHAR); } -VARYING {SQL_NEW_KEYWORD(SQL_TOKEN_VARYING); } -VAR_POP {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_POP); } -VAR_SAMP {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_SAMP); } -VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_VALUE); } -VALUES {SQL_NEW_KEYWORD(SQL_TOKEN_VALUES); } -VIEW {SQL_NEW_KEYWORD(SQL_TOKEN_VIEW); } - -WEEK {SQL_NEW_KEYWORD(SQL_TOKEN_WEEK); } -WHEN {SQL_NEW_KEYWORD(SQL_TOKEN_WHEN); } -WHERE {SQL_NEW_KEYWORD(SQL_TOKEN_WHERE); } -WITH {SQL_NEW_KEYWORD(SQL_TOKEN_WITH); } -WITHIN {SQL_NEW_KEYWORD(SQL_TOKEN_WITHIN); } -WITHOUT {SQL_NEW_KEYWORD(SQL_TOKEN_WITHOUT); } -WORK {SQL_NEW_KEYWORD(SQL_TOKEN_WORK); } - -YEAR {SQL_NEW_KEYWORD(SQL_TOKEN_YEAR); } - -ZONE {SQL_NEW_KEYWORD(SQL_TOKEN_ZONE); } - -"<" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESS);return SQL_LESS;} -">" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREAT);return SQL_GREAT;} -"=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_EQUAL);return SQL_EQUAL;} -"<=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESSEQ);return SQL_LESSEQ;} -">=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREATEQ);return SQL_GREATEQ;} -"<>" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;} -"!=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;} -"||" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_CONCAT);return SQL_CONCAT;} - - -[-+*/:(),.;?{}] { return SQLyytext[0]; } - - -<SQL>[A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375][A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375_0-9]* {return gatherName( SQLyytext);} - -<SQL>([0-9]+) | -<SQL>([0-9]+"."[0-9]*) | -<SQL>("."[0-9]*) {SQL_NEW_INTNUM; } - -<SQL>[0-9]+[eE][+-]?[0-9]+ | -<SQL>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ | -<SQL>"."[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } - -<PREDICATE_GER,PREDICATE_ENG,DATE>[A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375][A-Za-z0-9_%.,*?\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375]* {return gatherNamePre(SQLyytext);} - -<PREDICATE_GER,PREDICATE_ENG>([0-9]+) {SQL_NEW_INTNUM; } -<PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+) {SQL_NEW_INTNUM; } -<PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+) {SQL_NEW_INTNUM; } - -<PREDICATE_ENG>([0-9]+"."[0-9]+) | -<PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+"."[0-9]+) | -<PREDICATE_ENG>("."[0-9]+) {SQL_NEW_APPROXNUM; } -<PREDICATE_ENG>[0-9]+[eE][+-]?[0-9]+ | -<PREDICATE_ENG>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ | -<PREDICATE_ENG>"."[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } - -<PREDICATE_GER>([0-9]+","[0-9]+) | -<PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+","[0-9]+) | -<PREDICATE_GER>(","[0-9]+) {SQL_NEW_APPROXNUM; } -<PREDICATE_GER>[0-9]+[eE][+-]?[0-9]+ | -<PREDICATE_GER>[0-9]+","[0-9]*[eE][+-]?[0-9]+ | -<PREDICATE_GER>","[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } - -<PREDICATE_GER,PREDICATE_ENG>[0-9.,][A-Za-z0-9_.,%]* {return gatherNamePre(SQLyytext);} - -<SQL>\" { return gatherString('\"',0); } -<SQL>` { return gatherString('`' ,0); } - -<PREDICATE_GER,PREDICATE_ENG,DATE,SQL>"[" { return gatherString(']' ,0);} - -\' { return gatherString('\'',1); } - -<PREDICATE_GER,PREDICATE_ENG,DATE># { return gatherString('#' ,2); } - -<DATE>[0-9]{1,4}[^ ]*[0-9] | -<DATE>[0-9]{1,4}[^ ]*[0-9][ ][0-9]{1,4}[^ ]*[0-9] { SQL_NEW_DATE; } - -<STRING>["-""+""*""/"":""("")"",""."";""?""{""}"] { return SQLyytext[0]; } /* */ -<STRING>"[" { return gatherString(']' ,0); } -<STRING>[^ ':["?"]* { return gatherNamePre(SQLyytext); } - -\n {} - -[ \t\r]+ {} - -"--".*$ {} - -. {YY_FATAL_ERROR("Invalid symbol"); return SQL_TOKEN_INVALIDSYMBOL;} - -%% - -// Kludge around a bug (well, Posix incompatibility) in flex 2.5.x -// http://bugs.debian.org/cgi-bin/bugreport.cgi?archive=no&bug=189332 -#if YY_FLEX_MAJOR_VERSION >= 2 && YY_FLEX_MINOR_VERSION >= 5 - - #ifndef YY_FLUSH_BUFFER - #define YY_FLUSH_BUFFER SQLyy_flush_buffer(YY_CURRENT_BUFFER ) - #endif - - #ifndef yytext_ptr - #define yytext_ptr SQLyytext - #endif - -#endif - -// Versions of flex apparently differ in whether input() resp. yyinput() returns -// zero or EOF upon end of file: -inline bool checkeof(int c) { return c == 0 || c == EOF; } - -/* - * Read SQL string literal - * Valid strings: - * '' 'a string' 'quote '' within string' - * "" "a string" "quote "" within string" - * nTyp == 0 -> SQL_NODE_NAME - * nTyp == 1 -> SQL_NODE_STRING - * nTyp == 2 -> SQL_NODE_ACCESS_DATE - */ -sal_Int32 gatherString( sal_Int32 delim, sal_Int32 nTyp) -{ - sal_Char ch; - ::rtl::OStringBuffer sBuffer(256); - - while (!checkeof(ch = yyinput())) - { - if (ch == delim) - { - if ((ch = yyinput()) != delim) - { - if (!checkeof(ch)) - unput(ch); - - switch(nTyp) - { - case 0: - SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); - return SQL_TOKEN_NAME; - case 1: - SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_STRING); - return SQL_TOKEN_STRING; - case 2: - SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE); - return SQL_TOKEN_ACCESS_DATE; - } - } - else - { - sBuffer.append(ch); - } - - } - else if (nTyp != 1 && (ch == '\r' || ch == '\n') ) - break; - else - { - sBuffer.append(ch); - } - } - YY_FATAL_ERROR("Unterminated name string"); - return SQL_TOKEN_INVALIDSYMBOL; -} - -sal_Int32 mapEnumToToken(IParseContext::InternationalKeyCode _eKeyCode ) -{ - sal_Int32 nTokenID = 0; - switch( _eKeyCode ) - { - case IParseContext::KEY_LIKE: nTokenID = SQL_TOKEN_LIKE; break; - case IParseContext::KEY_NOT: nTokenID = SQL_TOKEN_NOT; break; - case IParseContext::KEY_NULL: nTokenID = SQL_TOKEN_NULL; break; - case IParseContext::KEY_TRUE: nTokenID = SQL_TOKEN_TRUE; break; - case IParseContext::KEY_FALSE: nTokenID = SQL_TOKEN_FALSE; break; - case IParseContext::KEY_IS: nTokenID = SQL_TOKEN_IS; break; - case IParseContext::KEY_BETWEEN: nTokenID = SQL_TOKEN_BETWEEN; break; - case IParseContext::KEY_OR: nTokenID = SQL_TOKEN_OR; break; - case IParseContext::KEY_AND: nTokenID = SQL_TOKEN_AND; break; - case IParseContext::KEY_AVG: nTokenID = SQL_TOKEN_AVG; break; - case IParseContext::KEY_COUNT: nTokenID = SQL_TOKEN_COUNT; break; - case IParseContext::KEY_MAX: nTokenID = SQL_TOKEN_MAX; break; - case IParseContext::KEY_MIN: nTokenID = SQL_TOKEN_MIN; break; - case IParseContext::KEY_SUM: nTokenID = SQL_TOKEN_SUM; break; - case IParseContext::KEY_EVERY: nTokenID = SQL_TOKEN_EVERY; break; - case IParseContext::KEY_ANY: nTokenID = SQL_TOKEN_ANY; break; - case IParseContext::KEY_SOME: nTokenID = SQL_TOKEN_SOME; break; - case IParseContext::KEY_STDDEV_POP: nTokenID = SQL_TOKEN_STDDEV_POP; break; - case IParseContext::KEY_STDDEV_SAMP: nTokenID = SQL_TOKEN_STDDEV_SAMP; break; - case IParseContext::KEY_VAR_SAMP: nTokenID = SQL_TOKEN_VAR_SAMP; break; - case IParseContext::KEY_VAR_POP: nTokenID = SQL_TOKEN_VAR_POP; break; - case IParseContext::KEY_COLLECT: nTokenID = SQL_TOKEN_COLLECT; break; - case IParseContext::KEY_FUSION: nTokenID = SQL_TOKEN_FUSION; break; - case IParseContext::KEY_INTERSECTION: nTokenID = SQL_TOKEN_INTERSECTION; break; - default: - OSL_FAIL( "mapEnumToToken: unsupported key!" ); - } - return nTokenID; -} -/* - * Read SQL Name literal - * Valid Names or internatioanl keywords: - * As we have international keywords, we test first on them - */ -sal_Int32 gatherName(const sal_Char* text) -{ - sal_Int32 nToken; - OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!"); - IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text); - switch (eKeyCode) - { - case IParseContext::KEY_LIKE: - case IParseContext::KEY_NOT: - case IParseContext::KEY_NULL: - case IParseContext::KEY_TRUE: - case IParseContext::KEY_FALSE: - case IParseContext::KEY_IS: - case IParseContext::KEY_BETWEEN: - case IParseContext::KEY_OR: - case IParseContext::KEY_AND: - case IParseContext::KEY_COUNT: - case IParseContext::KEY_AVG: - case IParseContext::KEY_MAX: - case IParseContext::KEY_MIN: - case IParseContext::KEY_SUM: - case IParseContext::KEY_EVERY: - case IParseContext::KEY_ANY: - case IParseContext::KEY_SOME: - case IParseContext::KEY_STDDEV_POP: - case IParseContext::KEY_STDDEV_SAMP: - case IParseContext::KEY_VAR_SAMP: - case IParseContext::KEY_VAR_POP: - case IParseContext::KEY_COLLECT: - case IParseContext::KEY_FUSION: - case IParseContext::KEY_INTERSECTION: - nToken = mapEnumToToken(eKeyCode); - SQL_NEW_KEYWORD(nToken); - break; - default: - SQL_NEW_NODE(::rtl::OUString(text,strlen(text),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); - return SQL_TOKEN_NAME; - } -} -/** - Read SQL Name literal for predicate check - Valid Names or internatioanl keywords: - As we have international keywords, we test first on them -*/ -sal_Int32 gatherNamePre(const sal_Char* text) -{ - sal_Int32 nToken; - OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!"); - IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text); - switch (eKeyCode) - { - case IParseContext::KEY_LIKE: - case IParseContext::KEY_NOT: - case IParseContext::KEY_NULL: - case IParseContext::KEY_TRUE: - case IParseContext::KEY_FALSE: - case IParseContext::KEY_IS: - case IParseContext::KEY_BETWEEN: - case IParseContext::KEY_OR: - case IParseContext::KEY_AND: - case IParseContext::KEY_COUNT: - case IParseContext::KEY_AVG: - case IParseContext::KEY_MAX: - case IParseContext::KEY_MIN: - case IParseContext::KEY_SUM: - case IParseContext::KEY_EVERY: - case IParseContext::KEY_ANY: - case IParseContext::KEY_SOME: - case IParseContext::KEY_STDDEV_POP: - case IParseContext::KEY_STDDEV_SAMP: - case IParseContext::KEY_VAR_SAMP: - case IParseContext::KEY_VAR_POP: - case IParseContext::KEY_COLLECT: - case IParseContext::KEY_FUSION: - case IParseContext::KEY_INTERSECTION: - nToken = mapEnumToToken(eKeyCode); - SQL_NEW_KEYWORD(nToken); - break; - default: - // we need a special handling for parameter - { - ::rtl::OString sStmt = xxx_pGLOBAL_SQLSCAN->getStatement(); - sal_Int32 nLength = strlen(text); - sal_Int32 nPos = xxx_pGLOBAL_SQLSCAN->GetCurrentPos() - nLength - 2; - if (sStmt.getStr()[nPos] == ':') - { - SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); - nToken = SQL_TOKEN_NAME; - } - else - { - SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_STRING); - nToken = SQL_TOKEN_STRING; - } - } - } - return nToken; -} - -using namespace connectivity; - -static sal_uInt32 Intl_TokenID[] = -{ - SQL_TOKEN_LIKE, SQL_TOKEN_NOT, SQL_TOKEN_NULL, SQL_TOKEN_TRUE, - SQL_TOKEN_FALSE, SQL_TOKEN_IS, SQL_TOKEN_BETWEEN, SQL_TOKEN_OR, - SQL_TOKEN_AND, SQL_TOKEN_AVG, SQL_TOKEN_COUNT, SQL_TOKEN_MAX, - SQL_TOKEN_MIN, SQL_TOKEN_SUM -}; -static bool IN_SQLyyerror; -//------------------------------------------------------------------------------ -OSQLScanner::OSQLScanner() - : m_nCurrentPos(0) - , m_bInternational(sal_False) - , m_pContext(NULL) - , m_nRule(0) // 0 is INITIAL -{ - IN_SQLyyerror = false; -} - -//------------------------------------------------------------------------------ -OSQLScanner::~OSQLScanner() -{ -} -//------------------------------------------------------------------------------ -void OSQLScanner::SQLyyerror(sal_Char *fmt) -{ - - if(IN_SQLyyerror) - return; - IN_SQLyyerror = true; - - OSL_ENSURE(m_pContext, "OSQLScanner::SQLyyerror: No Context set"); - m_sErrorMessage = ::rtl::OUString(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8); - if (m_nCurrentPos < m_sStatement.getLength()) - { - m_sErrorMessage += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(": ")); - - ::rtl::OUString aError; - static sal_Int32 BUFFERSIZE = 256; - static sal_Char* Buffer = 0; - if(!Buffer) - Buffer = new sal_Char[BUFFERSIZE]; - - sal_Char *s = Buffer; - sal_Int32 nPos = 1; - sal_Int32 ch = SQLyytext ? (SQLyytext[0] == 0 ? ' ' : SQLyytext[0]): ' '; - *s++ = ch; - while (!checkeof(ch = yyinput())) - { - if (ch == ' ') - { - if ((ch = yyinput()) != ' ') - { - if (!checkeof(ch)) - unput(ch); - } - *s = '\0'; - aError = ::rtl::OUString(Buffer,nPos,RTL_TEXTENCODING_UTF8); - break; - } - else - { - *s++ = ch; - if (++nPos == BUFFERSIZE) - { - ::rtl::OString aBuf(Buffer); - delete[] Buffer; - BUFFERSIZE *=2; - Buffer = new sal_Char[BUFFERSIZE]; - for(sal_Int32 i=0;i<aBuf.getLength();++i,++Buffer) - *Buffer = aBuf.getStr()[i]; - s = &Buffer[nPos]; - } - } - } - m_sErrorMessage += aError; - delete[] Buffer; - Buffer = NULL; - } - IN_SQLyyerror = false; - YY_FLUSH_BUFFER; -} - -//------------------------------------------------------------------------------ -void OSQLScanner::prepareScan(const ::rtl::OUString & rNewStatement, const IParseContext* pContext, sal_Bool bInternational) -{ - YY_FLUSH_BUFFER; - BEGIN(m_nRule); - - m_sErrorMessage = ::rtl::OUString(); - m_sStatement = ::rtl::OString(rNewStatement,rNewStatement.getLength(), RTL_TEXTENCODING_UTF8); - m_nCurrentPos = 0; - m_bInternational = bInternational; - m_pContext = pContext; -} - -//------------------------------------------------------------------------------ -sal_Int32 OSQLScanner::SQLyygetc(void) -{ - sal_Int32 nPos = (m_nCurrentPos >= m_sStatement.getLength()) ? -1 : m_sStatement.getStr()[m_nCurrentPos]; - m_nCurrentPos++; - return nPos; -} - -//------------------------------------------------------------------------------ -IParseContext::InternationalKeyCode OSQLScanner::getInternationalTokenID(const sal_Char* sToken) const -{ - OSL_ENSURE(m_pContext, "OSQLScanner::getInternationalTokenID: No Context set"); - return (m_bInternational) ? m_pContext->getIntlKeyCode(::rtl::OString(sToken) ) : IParseContext::KEY_NONE; -} -// ------------------------------------------------------------------------- -sal_Int32 OSQLScanner::GetCurrentRule() const { return m_nRule; } -sal_Int32 OSQLScanner::GetGERRule() const { return PREDICATE_GER; } -sal_Int32 OSQLScanner::GetENGRule() const { return PREDICATE_ENG; } -sal_Int32 OSQLScanner::GetSQLRule() const { return SQL; } -sal_Int32 OSQLScanner::GetDATERule() const { return DATE; } -sal_Int32 OSQLScanner::GetSTRINGRule() const { return STRING; } -// ------------------------------------------------------------------------- -void OSQLScanner::setScanner(sal_Bool _bNull) -{ - xxx_pGLOBAL_SQLSCAN = _bNull ? NULL : this; -} -// ------------------------------------------------------------------------- -sal_Int32 OSQLScanner::SQLlex() -{ - return SQLyylex(); -} - -#if defined __SUNPRO_CC -#pragma enable_warn -#elif defined _MSC_VER -#pragma warning(pop) -#endif diff --git a/connectivity/source/parse/sqliterator.cxx b/connectivity/source/parse/sqliterator.cxx deleted file mode 100644 index 62554d6d77..0000000000 --- a/connectivity/source/parse/sqliterator.cxx +++ /dev/null @@ -1,2249 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" -#include "connectivity/sqliterator.hxx" -#include "connectivity/sdbcx/VTable.hxx" -#include <connectivity/sqlparse.hxx> -#include <connectivity/dbtools.hxx> -#include <connectivity/sqlerror.hxx> -#include <com/sun/star/sdbc/ColumnValue.hpp> -#include <com/sun/star/sdbc/DataType.hpp> -#include <com/sun/star/sdbc/XRow.hpp> -#include <com/sun/star/sdb/XQueriesSupplier.hpp> -#include <com/sun/star/sdb/ErrorCondition.hpp> -#ifdef SQL_TEST_PARSETREEITERATOR -#include <iostream> -#endif -#include "connectivity/PColumn.hxx" -#include "connectivity/dbtools.hxx" -#include <tools/diagnose_ex.h> -#include "TConnection.hxx" -#include <comphelper/types.hxx> -#include <connectivity/dbmetadata.hxx> -#include <com/sun/star/sdb/SQLFilterOperator.hpp> -#include "diagnose_ex.h" -#include <rtl/logfile.hxx> - -#define SQL_ISRULEOR2(pParseNode, e1,e2) ((pParseNode)->isRule() && (\ - (pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e1) || \ - (pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e2))) - -using namespace ::comphelper; -using namespace ::connectivity; -using namespace ::connectivity::sdbcx; -using namespace ::dbtools; -using namespace ::connectivity::parse; -using namespace ::com::sun::star; -using namespace ::com::sun::star::uno; -using namespace ::com::sun::star::container; -using namespace ::com::sun::star::sdbcx; -using namespace ::com::sun::star::beans; -using namespace ::com::sun::star::sdbc; -using namespace ::com::sun::star::sdb; - -namespace connectivity -{ - struct OSQLParseTreeIteratorImpl - { - ::std::vector< TNodePair > m_aJoinConditions; - Reference< XConnection > m_xConnection; - Reference< XDatabaseMetaData > m_xDatabaseMetaData; - Reference< XNameAccess > m_xTableContainer; - Reference< XNameAccess > m_xQueryContainer; - - ::boost::shared_ptr< OSQLTables > m_pTables; /// all tables which participate in the SQL statement - ::boost::shared_ptr< OSQLTables > m_pSubTables; /// all tables from sub queries not the tables from the select tables - ::boost::shared_ptr< QueryNameSet > m_pForbiddenQueryNames; - - sal_uInt32 m_nIncludeMask; - - bool m_bIsCaseSensitive; - - OSQLParseTreeIteratorImpl( const Reference< XConnection >& _rxConnection, const Reference< XNameAccess >& _rxTables ) - :m_xConnection( _rxConnection ) - ,m_nIncludeMask( OSQLParseTreeIterator::All ) - ,m_bIsCaseSensitive( true ) - { - OSL_PRECOND( m_xConnection.is(), "OSQLParseTreeIteratorImpl::OSQLParseTreeIteratorImpl: invalid connection!" ); - m_xDatabaseMetaData = m_xConnection->getMetaData(); - - m_bIsCaseSensitive = m_xDatabaseMetaData.is() && m_xDatabaseMetaData->supportsMixedCaseQuotedIdentifiers(); - m_pTables.reset( new OSQLTables( m_bIsCaseSensitive ) ); - m_pSubTables.reset( new OSQLTables( m_bIsCaseSensitive ) ); - - m_xTableContainer = _rxTables; - - DatabaseMetaData aMetaData( m_xConnection ); - if ( aMetaData.supportsSubqueriesInFrom() ) - { - // connections might support the XQueriesSupplier interface, if they implement the css.sdb.Connection - // service - Reference< XQueriesSupplier > xSuppQueries( m_xConnection, UNO_QUERY ); - if ( xSuppQueries.is() ) - m_xQueryContainer = xSuppQueries->getQueries(); - } - } - - public: - inline bool isQueryAllowed( const ::rtl::OUString& _rQueryName ) - { - if ( !m_pForbiddenQueryNames.get() ) - return true; - if ( m_pForbiddenQueryNames->find( _rQueryName ) == m_pForbiddenQueryNames->end() ) - return true; - return false; - } - }; - - //------------------------------------------------------------------------- - /** helper class for temporarily adding a query name to a list of forbidden query names - */ - class ForbidQueryName - { - ::boost::shared_ptr< QueryNameSet >& m_rpAllForbiddenNames; - ::rtl::OUString m_sForbiddenQueryName; - - public: - ForbidQueryName( OSQLParseTreeIteratorImpl& _rIteratorImpl, const ::rtl::OUString _rForbiddenQueryName ) - :m_rpAllForbiddenNames( _rIteratorImpl.m_pForbiddenQueryNames ) - ,m_sForbiddenQueryName( _rForbiddenQueryName ) - { - if ( !m_rpAllForbiddenNames.get() ) - m_rpAllForbiddenNames.reset( new QueryNameSet ); - m_rpAllForbiddenNames->insert( m_sForbiddenQueryName ); - } - - ~ForbidQueryName() - { - m_rpAllForbiddenNames->erase( m_sForbiddenQueryName ); - } - }; -} -//----------------------------------------------------------------------------- -OSQLParseTreeIterator::OSQLParseTreeIterator(const Reference< XConnection >& _rxConnection, - const Reference< XNameAccess >& _rxTables, - const OSQLParser& _rParser, - const OSQLParseNode* pRoot ) - :m_rParser( _rParser ) - ,m_pImpl( new OSQLParseTreeIteratorImpl( _rxConnection, _rxTables ) ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::OSQLParseTreeIterator" ); - setParseTree(pRoot); -} - -//----------------------------------------------------------------------------- -OSQLParseTreeIterator::OSQLParseTreeIterator( const OSQLParseTreeIterator& _rParentIterator, const OSQLParser& _rParser, const OSQLParseNode* pRoot ) - :m_rParser( _rParser ) - ,m_pImpl( new OSQLParseTreeIteratorImpl( _rParentIterator.m_pImpl->m_xConnection, _rParentIterator.m_pImpl->m_xTableContainer ) ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::OSQLParseTreeIterator" ); - m_pImpl->m_pForbiddenQueryNames = _rParentIterator.m_pImpl->m_pForbiddenQueryNames; - setParseTree( pRoot ); -} - -//----------------------------------------------------------------------------- -OSQLParseTreeIterator::~OSQLParseTreeIterator() -{ - dispose(); -} - -// ----------------------------------------------------------------------------- -const OSQLTables& OSQLParseTreeIterator::getTables() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getTables" ); - return *m_pImpl->m_pTables; -} - -// ----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::isCaseSensitive() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::isCaseSensitive" ); - return m_pImpl->m_bIsCaseSensitive; -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::dispose() -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::dispose" ); - m_aSelectColumns = NULL; - m_aGroupColumns = NULL; - m_aOrderColumns = NULL; - m_aParameters = NULL; - m_pImpl->m_xTableContainer = NULL; - m_pImpl->m_xDatabaseMetaData = NULL; - m_aCreateColumns = NULL; - m_pImpl->m_pTables->clear(); - m_pImpl->m_pSubTables->clear(); -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setParseTree(const OSQLParseNode * pNewParseTree) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::setParseTree" ); - m_pImpl->m_pTables->clear(); - m_pImpl->m_pSubTables->clear(); - - m_aSelectColumns = new OSQLColumns(); - m_aGroupColumns = new OSQLColumns(); - m_aOrderColumns = new OSQLColumns(); - m_aParameters = new OSQLColumns(); - m_aCreateColumns = new OSQLColumns(); - - m_pParseTree = pNewParseTree; - if (!m_pParseTree) - { - m_eStatementType = SQL_STATEMENT_UNKNOWN; - return; - } - - // falls m_pParseTree aber keine Connection, dann Fehler - if ( !m_pImpl->m_xTableContainer.is() ) - return; - - m_aErrors = SQLException(); - - - // Statement-Typ ermitteln ... - if (SQL_ISRULE(m_pParseTree,select_statement) || SQL_ISRULE(m_pParseTree,union_statement) ) - { - m_eStatementType = SQL_STATEMENT_SELECT; - } - else if (SQL_ISRULE(m_pParseTree,insert_statement)) - { - m_eStatementType = SQL_STATEMENT_INSERT; - } - else if (SQL_ISRULE(m_pParseTree,update_statement_searched)) - { - m_eStatementType = SQL_STATEMENT_UPDATE; - } - else if (SQL_ISRULE(m_pParseTree,delete_statement_searched)) - { - m_eStatementType = SQL_STATEMENT_DELETE; - } - else if (m_pParseTree->count() == 3 && SQL_ISRULE(m_pParseTree->getChild(1),odbc_call_spec)) - { - m_eStatementType = SQL_STATEMENT_ODBC_CALL; - } - else if (SQL_ISRULE(m_pParseTree->getChild(0),base_table_def)) - { - m_eStatementType = SQL_STATEMENT_CREATE_TABLE; - m_pParseTree = m_pParseTree->getChild(0); - } - else - { - m_eStatementType = SQL_STATEMENT_UNKNOWN; - //aIteratorStatus.setInvalidStatement(); - return; - } -} - -//----------------------------------------------------------------------------- -namespace -{ - //......................................................................... - static void impl_getRowString( const Reference< XRow >& _rxRow, const sal_Int32 _nColumnIndex, ::rtl::OUString& _out_rString ) - { - _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 ) - { - ::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_CONSTASCII_USTRINGPARAM( "%" )); - - // we want all catalogues, all schemas, all tables - Sequence< ::rtl::OUString > sTableTypes(3); - sTableTypes[0] = s_sTableTypeView; - sTableTypes[1] = s_sTableTypeTable; - sTableTypes[2] = s_sWildcard; // just to be sure to include anything else .... - - if ( _rxDBMeta.is() ) - { - sComposedName = ::rtl::OUString(); - - Reference< XResultSet> xRes = _rxDBMeta->getTables( - _rCatalog.getLength() ? makeAny( _rCatalog ) : Any(), _rSchema.getLength() ? _rSchema : s_sWildcard, _rTableName, sTableTypes ); - - Reference< XRow > xCurrentRow( xRes, UNO_QUERY ); - if ( xCurrentRow.is() && xRes->next() ) - { - ::rtl::OUString sCatalog, sSchema, sName; - - impl_getRowString( xCurrentRow, 1, sCatalog ); - impl_getRowString( xCurrentRow, 2, sSchema ); - impl_getRowString( xCurrentRow, 3, sName ); - - sComposedName = ::dbtools::composeTableName( - _rxDBMeta, - sCatalog, - sSchema, - sName, - sal_False, - ::dbtools::eInDataManipulation - ); - } - } - return sComposedName; - } -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::impl_getQueryParameterColumns( const OSQLTable& _rQuery ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_getQueryParameterColumns" ); - if ( ( m_pImpl->m_nIncludeMask & Parameters ) != Parameters ) - // parameters not to be included in the traversal - return; - - ::rtl::Reference< OSQLColumns > pSubQueryParameterColumns( new OSQLColumns() ); - - // get the command and the EscapeProcessing properties from the sub query - ::rtl::OUString sSubQueryCommand; - sal_Bool bEscapeProcessing = sal_False; - try - { - Reference< XPropertySet > xQueryProperties( _rQuery, UNO_QUERY_THROW ); - OSL_VERIFY( xQueryProperties->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_COMMAND ) ) >>= sSubQueryCommand ); - OSL_VERIFY( xQueryProperties->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ) ) >>= bEscapeProcessing ); - } - catch( const Exception& ) - { - DBG_UNHANDLED_EXCEPTION(); - } - - // parse the sub query - do { - - if ( !bEscapeProcessing || ( sSubQueryCommand.getLength() == 0 ) ) - break; - - ::rtl::OUString sError; - ::std::auto_ptr< OSQLParseNode > pSubQueryNode( const_cast< OSQLParser& >( m_rParser ).parseTree( sError, sSubQueryCommand, sal_False ) ); - if ( !pSubQueryNode.get() ) - break; - - OSQLParseTreeIterator aSubQueryIterator( *this, m_rParser, pSubQueryNode.get() ); - aSubQueryIterator.traverseSome( Parameters | SelectColumns ); - // SelectColumns might also contain parameters - // #i77635# - 2007-07-23 / frank.schoenheit@sun.com - pSubQueryParameterColumns = aSubQueryIterator.getParameters(); - aSubQueryIterator.dispose(); - - } while ( false ); - - // copy the parameters of the sub query to our own parameter array - ::std::copy( pSubQueryParameterColumns->get().begin(), pSubQueryParameterColumns->get().end(), - ::std::insert_iterator< OSQLColumns::Vector >( m_aParameters->get(), m_aParameters->get().end() ) ); -} - -//----------------------------------------------------------------------------- -OSQLTable OSQLParseTreeIterator::impl_locateRecordSource( const ::rtl::OUString& _rComposedName ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_locateRecordSource" ); - if ( !_rComposedName.getLength() ) - { - OSL_FAIL( "OSQLParseTreeIterator::impl_locateRecordSource: no object name at all?" ); - return OSQLTable(); - } - - 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 ( bQueryDoesExist ) - impl_appendError( IParseContext::ERROR_INVALID_QUERY_EXIST, &sName ); - else if ( bTableDoesExist ) - impl_appendError( IParseContext::ERROR_INVALID_TABLE_EXIST, &sName ); - else - aReturn = impl_createTableObject( sName, sCatalog, sSchema ); - } - else - { - // 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 ) - { - if ( !m_pImpl->isQueryAllowed( sComposedName ) ) - { - impl_appendError( m_rParser.getErrorHelper().getSQLException( sdb::ErrorCondition::PARSER_CYCLIC_SUB_QUERIES, NULL ) ); - return NULL; - } - - m_pImpl->m_xQueryContainer->getByName( sComposedName ) >>= aReturn; - - // collect the parameters from the sub query - ForbidQueryName aForbidName( *m_pImpl, sComposedName ); - impl_getQueryParameterColumns( aReturn ); - } - else if ( bTableDoesExist ) - m_pImpl->m_xTableContainer->getByName( sComposedName ) >>= aReturn; - else - { - if ( m_pImpl->m_xQueryContainer.is() ) - // the connection on which we're working supports sub queries in from (else - // m_xQueryContainer would not have been set), so emit a better error message - impl_appendError( IParseContext::ERROR_INVALID_TABLE_OR_QUERY, &sName ); - else - impl_appendError( IParseContext::ERROR_INVALID_TABLE, &sName ); - } - } - } - catch(Exception&) - { - impl_appendError( IParseContext::ERROR_INVALID_TABLE, &sComposedName ); - } - - return aReturn; -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseOneTableName( OSQLTables& _rTables,const OSQLParseNode * pTableName, const ::rtl::OUString & rTableRange ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseOneTableName" ); - if ( ( m_pImpl->m_nIncludeMask & TableNames ) != TableNames ) - // tables should not be included in the traversal - return; - - 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,m_pImpl->m_xDatabaseMetaData); - - // create the composed name like DOMAIN.USER.TABLE1 - aComposedName = ::dbtools::composeTableName(m_pImpl->m_xDatabaseMetaData, - aCatalog.hasValue() ? ::comphelper::getString(aCatalog) : ::rtl::OUString(), - aSchema, - aTableName, - 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 ); - if ( aTable.is() ) - _rTables[ aTableRange ] = aTable; -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::impl_fillJoinConditions(const OSQLParseNode* i_pJoinCondition) -{ - if (i_pJoinCondition->count() == 3 && // Ausdruck is geklammert - SQL_ISPUNCTUATION(i_pJoinCondition->getChild(0),"(") && - SQL_ISPUNCTUATION(i_pJoinCondition->getChild(2),")")) - { - impl_fillJoinConditions(i_pJoinCondition->getChild(1)); - } - else if (SQL_ISRULEOR2(i_pJoinCondition,search_condition,boolean_term) && // AND/OR-Verknuepfung: - i_pJoinCondition->count() == 3) - { - // nur AND Verknüpfung zulassen - if ( SQL_ISTOKEN(i_pJoinCondition->getChild(1),AND) ) - { - impl_fillJoinConditions(i_pJoinCondition->getChild(0)); - impl_fillJoinConditions(i_pJoinCondition->getChild(1)); - } - } - else if (SQL_ISRULE(i_pJoinCondition,comparison_predicate)) - { - // only the comparison of columns is allowed - OSL_ENSURE(i_pJoinCondition->count() == 3,"OQueryDesignView::InsertJoinConnection: Fehler im Parse Tree"); - if (SQL_ISRULE(i_pJoinCondition->getChild(0),column_ref) && - SQL_ISRULE(i_pJoinCondition->getChild(2),column_ref) && - i_pJoinCondition->getChild(1)->getNodeType() == SQL_NODE_EQUAL) - { - m_pImpl->m_aJoinConditions.push_back( TNodePair(i_pJoinCondition->getChild(0),i_pJoinCondition->getChild(2)) ); - } - } -} -//----------------------------------------------------------------------------- -::std::vector< TNodePair >& OSQLParseTreeIterator::getJoinConditions() const -{ - return m_pImpl->m_aJoinConditions; -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getQualified_join( OSQLTables& _rTables, const OSQLParseNode *pTableRef, ::rtl::OUString& aTableRange ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getQualified_join" ); - OSL_PRECOND( SQL_ISRULE( pTableRef, cross_union ) || SQL_ISRULE( pTableRef, qualified_join ) , - "OSQLParseTreeIterator::getQualified_join: illegal node!" ); - - aTableRange = ::rtl::OUString(); - - const OSQLParseNode* pNode = getTableNode(_rTables,pTableRef->getChild(0),aTableRange); - if ( isTableNode( pNode ) ) - traverseOneTableName( _rTables, pNode, aTableRange ); - - sal_uInt32 nPos = 4; - if( SQL_ISRULE(pTableRef,cross_union) || pTableRef->getChild(1)->getTokenID() != SQL_TOKEN_NATURAL) - { - nPos = 3; - // join_condition,named_columns_join - if ( SQL_ISRULE( pTableRef, qualified_join ) ) - { - const OSQLParseNode* pJoin_spec = pTableRef->getChild(4); - if ( SQL_ISRULE( pJoin_spec, join_condition ) ) - { - impl_fillJoinConditions(pJoin_spec->getChild(1)); - } - else - { - const OSQLParseNode* pColumnCommalist = pJoin_spec->getChild(2); - // Alle Columns in der column_commalist ... - for (sal_uInt32 i = 0; i < pColumnCommalist->count(); i++) - { - const OSQLParseNode * pCol = pColumnCommalist->getChild(i); - // add twice because the column must exists in both tables - m_pImpl->m_aJoinConditions.push_back( TNodePair(pCol,pCol) ); - } - } - } - } - - pNode = getTableNode(_rTables,pTableRef->getChild(nPos),aTableRange); - if ( isTableNode( pNode ) ) - traverseOneTableName( _rTables, pNode, aTableRange ); -} -//----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getTableNode( OSQLTables& _rTables, const OSQLParseNode *pTableRef,::rtl::OUString& rTableRange ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getTableNode" ); - OSL_PRECOND( SQL_ISRULE( pTableRef, table_ref ) || SQL_ISRULE( pTableRef, joined_table ) - || SQL_ISRULE( pTableRef, qualified_join ) || SQL_ISRULE( pTableRef, cross_union ), - "OSQLParseTreeIterator::getTableNode: only to be called for table_ref nodes!" ); - - const OSQLParseNode* pTableNameNode = NULL; - - if ( SQL_ISRULE( pTableRef, joined_table ) ) - { - getQualified_join( _rTables, pTableRef->getChild(1), rTableRange ); - } - if ( SQL_ISRULE( pTableRef, qualified_join ) || SQL_ISRULE( pTableRef, cross_union ) ) - { - getQualified_join( _rTables, pTableRef, rTableRange ); - } - else - { - rTableRange = OSQLParseNode::getTableRange(pTableRef); - if ( ( pTableRef->count() == 4 ) // '{' SQL_TOKEN_OJ joined_table '}' - || ( pTableRef->count() == 5 ) // '(' joined_table ')' range_variable op_column_commalist - ) - { - getQualified_join( _rTables, pTableRef->getChild(6 - pTableRef->count()), rTableRange ); - } - else if ( pTableRef->count() == 3 ) // subquery range_variable op_column_commalist || '(' joined_table ')' - { - const OSQLParseNode* pSubQuery = pTableRef->getChild(0); - if ( pSubQuery->isToken() ) - { - getQualified_join( _rTables, pTableRef->getChild(1), rTableRange ); - } - else - { - OSL_ENSURE( pSubQuery->count() == 3, "sub queries should have 3 children!" ); - const OSQLParseNode* pQueryExpression = pSubQuery->getChild(1); - if ( SQL_ISRULE( pQueryExpression, select_statement ) ) - { - getSelect_statement( *m_pImpl->m_pSubTables, pQueryExpression ); - } - else - { - OSL_FAIL( "OSQLParseTreeIterator::getTableNode: subquery which is no select_statement: not yet implemented!" ); - } - } - } - else if ( pTableRef->count() == 2 ) // table_node table_primary_as_range_column - { - pTableNameNode = pTableRef->getChild(0); - } - else - OSL_FAIL( "OSQLParseTreeIterator::getTableNode: unhandled case!" ); - } - - return pTableNameNode; -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getSelect_statement(OSQLTables& _rTables,const OSQLParseNode* pSelect) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getSelect_statement" ); - if(SQL_ISRULE(pSelect,union_statement)) - { - getSelect_statement(_rTables,pSelect->getChild(0)); - //getSelect_statement(pSelect->getChild(3)); - return; - } - OSQLParseNode * pTableRefCommalist = pSelect->getChild(3)->getChild(0)->getChild(1); - - OSL_ENSURE(pTableRefCommalist != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableRefCommalist,table_ref_commalist),"OSQLParseTreeIterator: error in parse tree!"); - - const OSQLParseNode* pTableName = NULL; - ::rtl::OUString aTableRange; - for (sal_uInt32 i = 0; i < pTableRefCommalist->count(); i++) - { // from clause durchlaufen - aTableRange = ::rtl::OUString(); - - const OSQLParseNode* pTableListElement = pTableRefCommalist->getChild(i); - if ( isTableNode( pTableListElement ) ) - { - traverseOneTableName( _rTables, pTableListElement, aTableRange ); - } - else if ( SQL_ISRULE( pTableListElement, table_ref ) ) - { - // Tabellenreferenz kann aus Tabellennamen, Tabellennamen (+),'('joined_table')'(+) bestehen - pTableName = pTableListElement->getChild(0); - if( isTableNode( pTableName ) ) - { // Tabellennamen gefunden - aTableRange = OSQLParseNode::getTableRange(pTableListElement); - traverseOneTableName( _rTables, pTableName, aTableRange ); - } - else if(SQL_ISPUNCTUATION(pTableName,"{")) - { // '{' SQL_TOKEN_OJ joined_table '}' - getQualified_join( _rTables, pTableListElement->getChild(2), aTableRange ); - } - else - { // '(' joined_table ')' range_variable op_column_commalist - getTableNode( _rTables, pTableListElement, aTableRange ); - } - } - else if (SQL_ISRULE( pTableListElement, qualified_join ) || SQL_ISRULE( pTableListElement, cross_union ) ) - { - getQualified_join( _rTables, pTableListElement, aTableRange ); - } - else if ( SQL_ISRULE( pTableListElement, joined_table ) ) - { - getQualified_join( _rTables, pTableListElement->getChild(1), aTableRange ); - } - - // if (! aIteratorStatus.IsSuccessful()) break; - } -} -//----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::traverseTableNames(OSQLTables& _rTables) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseTableNames" ); - if ( m_pParseTree == NULL ) - return false; - - OSQLParseNode* pTableName = NULL; - - 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); - break; - - case SQL_STATEMENT_UPDATE: - pTableName = m_pParseTree->getChild(1); - break; - default: - break; - } - - if ( pTableName ) - { - ::rtl::OUString sTableRange; - traverseOneTableName( _rTables, pTableName, sTableRange ); - } - - return !hasErrors(); -} -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParseTreeIterator::getColumnAlias(const OSQLParseNode* _pDerivedColumn) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getColumnAlias" ); - OSL_ENSURE(SQL_ISRULE(_pDerivedColumn,derived_column),"No derived column!"); - ::rtl::OUString sColumnAlias; - if(_pDerivedColumn->getChild(1)->count() == 2) - sColumnAlias = _pDerivedColumn->getChild(1)->getChild(1)->getTokenValue(); - else if(!_pDerivedColumn->getChild(1)->isRule()) - sColumnAlias = _pDerivedColumn->getChild(1)->getTokenValue(); - return sColumnAlias; -} - -// ----------------------------------------------------------------------------- -namespace -{ - void lcl_getColumnRange( const OSQLParseNode* _pColumnRef, const Reference< XConnection >& _rxConnection, - ::rtl::OUString& _out_rColumnName, ::rtl::OUString& _out_rTableRange, - const OSQLColumns* _pSelectColumns, ::rtl::OUString& _out_rColumnAliasIfPresent ) - { - _out_rColumnName = _out_rTableRange = _out_rColumnAliasIfPresent = ::rtl::OUString(); - if ( SQL_ISRULE( _pColumnRef, column_ref ) ) - { - if( _pColumnRef->count() > 1 ) - { - for ( sal_Int32 i=0; i<((sal_Int32)_pColumnRef->count())-2; ++i ) - _pColumnRef->getChild(i)->parseNodeToStr( _out_rTableRange, _rxConnection, NULL, sal_False, sal_False ); - _out_rColumnName = _pColumnRef->getChild( _pColumnRef->count()-1 )->getChild(0)->getTokenValue(); - } - else - _out_rColumnName = _pColumnRef->getChild(0)->getTokenValue(); - - // look up the column in the select column, to find an possible alias - if ( _pSelectColumns ) - { - for ( OSQLColumns::Vector::const_iterator lookupColumn = _pSelectColumns->get().begin(); - lookupColumn != _pSelectColumns->get().end(); - ++lookupColumn - ) - { - Reference< XPropertySet > xColumn( *lookupColumn ); - try - { - ::rtl::OUString sName, sTableName; - xColumn->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_REALNAME ) ) >>= sName; - xColumn->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_TABLENAME ) ) >>= sTableName; - if ( sName == _out_rColumnName && sTableName == _out_rTableRange ) - xColumn->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_NAME ) ) >>= _out_rColumnAliasIfPresent; - } - catch( const Exception& ) - { - DBG_UNHANDLED_EXCEPTION(); - } - } - } - } - else if(SQL_ISRULE(_pColumnRef,general_set_fct) || SQL_ISRULE(_pColumnRef,set_fct_spec)) - { // Funktion - _pColumnRef->parseNodeToStr( _out_rColumnName, _rxConnection ); - } - else if(_pColumnRef->getNodeType() == SQL_NODE_NAME) - _out_rColumnName = _pColumnRef->getTokenValue(); - } -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getColumnRange( const OSQLParseNode* _pColumnRef, - ::rtl::OUString& _rColumnName, - ::rtl::OUString& _rTableRange) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getColumnRange" ); - ::rtl::OUString sDummy; - lcl_getColumnRange( _pColumnRef, m_pImpl->m_xConnection, _rColumnName, _rTableRange, NULL, sDummy ); -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getColumnRange( const OSQLParseNode* _pColumnRef, - ::rtl::OUString& _rColumnName, - ::rtl::OUString& _rTableRange, - ::rtl::OUString& _out_rColumnAliasIfPresent ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getColumnRange" ); - lcl_getColumnRange( _pColumnRef, m_pImpl->m_xConnection, _rColumnName, _rTableRange, &*m_aSelectColumns, _out_rColumnAliasIfPresent ); -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::getColumnRange( const OSQLParseNode* _pColumnRef, - const Reference< XConnection >& _rxConnection, ::rtl::OUString& _out_rColumnName, ::rtl::OUString& _out_rTableRange ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getColumnRange" ); - ::rtl::OUString sDummy; - lcl_getColumnRange( _pColumnRef, _rxConnection, _out_rColumnName, _out_rTableRange, NULL, sDummy ); -} - -//----------------------------------------------------------------------------- -sal_Bool OSQLParseTreeIterator::getColumnTableRange(const OSQLParseNode* pNode, ::rtl::OUString &rTableRange) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getColumnTableRange" ); - // Ermitteln ob alle Spalten zu einer Tabelle gehoeren - if (SQL_ISRULE(pNode,column_ref)) - { - ::rtl::OUString aColName, aTableRange; - getColumnRange(pNode, aColName, aTableRange); - if (!aTableRange.getLength()) // keinen gefunden - { - // dann die Spalte in den Tabellen suchen - for (ConstOSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end(); ++aIter) - { - if (aIter->second.is()) - { - try - { - Reference< XNameAccess > xColumns = aIter->second->getColumns(); - if(xColumns->hasByName(aColName)) - { - Reference< XPropertySet > xColumn; - if (xColumns->getByName(aColName) >>= xColumn) - { - OSL_ENSURE(xColumn.is(),"Column isn't a propertyset!"); - aTableRange = aIter->first; - break; - } - } - } - catch(Exception&) - { - } - } - } - if (!aTableRange.getLength()) - return sal_False; - } - - - if (!rTableRange.getLength()) - rTableRange = aTableRange; - else if (rTableRange != aTableRange) - return sal_False; - } - else - { - for (sal_uInt32 i = 0, ncount = pNode->count(); i < ncount; i++) - { - if (!getColumnTableRange(pNode->getChild(i), rTableRange)) - return sal_False; - } - } - return sal_True; -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseCreateColumns(const OSQLParseNode* pSelectNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseCreateColumns" ); - // aIteratorStatus.Clear(); - - if (!pSelectNode || m_eStatementType != SQL_STATEMENT_CREATE_TABLE || m_pImpl->m_pTables->empty()) - { - impl_appendError( IParseContext::ERROR_GENERAL ); - return; - } - if (!SQL_ISRULE(pSelectNode,base_table_element_commalist)) - return ; - - for (sal_uInt32 i = 0; i < pSelectNode->count(); i++) - { - OSQLParseNode *pColumnRef = pSelectNode->getChild(i); - - if (SQL_ISRULE(pColumnRef,column_def)) - { - ::rtl::OUString aColumnName; - ::rtl::OUString aTypeName; - ::rtl::OUString aTableRange; - sal_Int32 nType = DataType::VARCHAR; - aColumnName = pColumnRef->getChild(0)->getTokenValue(); - - OSQLParseNode *pDatatype = pColumnRef->getChild(1); - if (pDatatype && SQL_ISRULE(pDatatype,character_string_type)) - { - const OSQLParseNode *pType = pDatatype->getChild(0); - aTypeName = pType->getTokenValue(); - if (pDatatype->count() == 2 && (pType->getTokenID() == SQL_TOKEN_CHAR || pType->getTokenID() == SQL_TOKEN_CHARACTER )) - nType = DataType::CHAR; - - const OSQLParseNode *pParams = pDatatype->getChild(pDatatype->count()-1); - if ( pParams->count() ) - { - sal_Int32 nLen = pParams->getChild(1)->getTokenValue().toInt32(); - (void)nLen; - } - } - else if(pDatatype && pDatatype->getNodeType() == SQL_NODE_KEYWORD) - { - aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VARCHAR")); - } - - if (aTypeName.getLength()) - { - //TODO:Create a new class for create statement to handle field length - OParseColumn* pColumn = new OParseColumn(aColumnName,aTypeName,::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,nType,sal_False,sal_False,isCaseSensitive()); - pColumn->setFunction(sal_False); - pColumn->setRealName(aColumnName); - - Reference< XPropertySet> xCol = pColumn; - m_aCreateColumns->get().push_back(xCol); - } - } - - } -} -//----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::traverseSelectColumnNames(const OSQLParseNode* pSelectNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseSelectColumnNames" ); - if ( ( m_pImpl->m_nIncludeMask & SelectColumns ) != SelectColumns ) - return true; - - if (!pSelectNode || m_eStatementType != SQL_STATEMENT_SELECT || m_pImpl->m_pTables->empty()) - { - impl_appendError( IParseContext::ERROR_GENERAL ); - return false; - } - - if(SQL_ISRULE(pSelectNode,union_statement)) - { - return traverseSelectColumnNames( pSelectNode->getChild( 0 ) ) - /*&& traverseSelectColumnNames( pSelectNode->getChild( 3 ) )*/; - } - - static ::rtl::OUString aEmptyString; - // nyi: mehr Pruefung auf korrekte Struktur! - if (pSelectNode->getChild(2)->isRule() && SQL_ISPUNCTUATION(pSelectNode->getChild(2)->getChild(0),"*")) - { - // SELECT * ... - setSelectColumnName(m_aSelectColumns,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("*")), aEmptyString,aEmptyString); - } - else if (SQL_ISRULE(pSelectNode->getChild(2),scalar_exp_commalist)) - { - // SELECT column[,column] oder SELECT COUNT(*) ... - OSQLParseNode * pSelection = pSelectNode->getChild(2); - - for (sal_uInt32 i = 0; i < pSelection->count(); i++) - { - OSQLParseNode *pColumnRef = pSelection->getChild(i); - - //if (SQL_ISRULE(pColumnRef,select_sublist)) - if (SQL_ISRULE(pColumnRef,derived_column) && - SQL_ISRULE(pColumnRef->getChild(0),column_ref) && - pColumnRef->getChild(0)->count() == 3 && - SQL_ISPUNCTUATION(pColumnRef->getChild(0)->getChild(2),"*")) - { - // alle Spalten der Tabelle - ::rtl::OUString aTableRange; - pColumnRef->getChild(0)->parseNodeToStr( aTableRange, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - setSelectColumnName(m_aSelectColumns,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("*")), aEmptyString,aTableRange); - continue; - } - else if (SQL_ISRULE(pColumnRef,derived_column)) - { - ::rtl::OUString aColumnAlias(getColumnAlias(pColumnRef)); // kann leer sein - ::rtl::OUString sColumnName; - ::rtl::OUString aTableRange; - sal_Int32 nType = DataType::VARCHAR; - sal_Bool bFkt(sal_False); - pColumnRef = pColumnRef->getChild(0); - if ( - pColumnRef->count() == 3 && - SQL_ISPUNCTUATION(pColumnRef->getChild(0),"(") && - SQL_ISPUNCTUATION(pColumnRef->getChild(2),")") - ) - pColumnRef = pColumnRef->getChild(1); - - if (SQL_ISRULE(pColumnRef,column_ref)) - { - getColumnRange(pColumnRef,sColumnName,aTableRange); - OSL_ENSURE(sColumnName.getLength(),"Columnname darf nicht leer sein"); - } - else /*if (SQL_ISRULE(pColumnRef,general_set_fct) || SQL_ISRULE(pColumnRef,set_fct_spec) || - SQL_ISRULE(pColumnRef,position_exp) || SQL_ISRULE(pColumnRef,extract_exp) || - SQL_ISRULE(pColumnRef,length_exp) || SQL_ISRULE(pColumnRef,char_value_fct)|| - SQL_ISRULE(pColumnRef,num_value_exp) || SQL_ISRULE(pColumnRef,term))*/ - { - /* Funktionsaufruf vorhanden */ - pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_True ); - ::rtl::OUString sTableRange; - // check if the column is also a parameter - traverseORCriteria(pColumnRef); // num_value_exp - - // gehoeren alle beteiligten Spalten der Funktion zu einer Tabelle - if (m_pImpl->m_pTables->size() == 1) - { - aTableRange = m_pImpl->m_pTables->begin()->first; - } - else - { - getColumnTableRange(pColumnRef,aTableRange); - } - if ( pColumnRef->isRule() ) - { - bFkt = sal_True; - nType = getFunctionReturnType(pColumnRef); - } - } - /* - else - { - aIteratorStatus.setStatementTooComplex(); - return; - } - */ - if(!aColumnAlias.getLength()) - aColumnAlias = sColumnName; - setSelectColumnName(m_aSelectColumns,sColumnName,aColumnAlias,aTableRange,bFkt,nType,SQL_ISRULE(pColumnRef,general_set_fct) || SQL_ISRULE(pColumnRef,set_fct_spec)); - } - } - } - - return !hasErrors(); -} - - -//----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::traverseOrderByColumnNames(const OSQLParseNode* pSelectNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseOrderByColumnNames" ); - traverseByColumnNames( pSelectNode, sal_True ); - return !hasErrors(); -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseByColumnNames(const OSQLParseNode* pSelectNode,sal_Bool _bOrder) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseByColumnNames" ); - // aIteratorStatus.Clear(); - - if (pSelectNode == NULL) - { - //aIteratorStatus.setInvalidStatement(); - return; - } - - if (m_eStatementType != SQL_STATEMENT_SELECT) - { - //aIteratorStatus.setInvalidStatement(); - return; - } - - if(SQL_ISRULE(pSelectNode,union_statement)) - { - traverseByColumnNames(pSelectNode->getChild(0),_bOrder); - return; - } - - OSL_ENSURE(pSelectNode->count() >= 4,"OSQLParseTreeIterator: error in parse tree!"); - - OSQLParseNode * pTableExp = pSelectNode->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator:table_exp error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - sal_uInt32 nPos = ( _bOrder ? ORDER_BY_CHILD_POS : 2 ); - - OSQLParseNode * pOptByClause = pTableExp->getChild(nPos); - OSL_ENSURE(pOptByClause != NULL,"OSQLParseTreeIterator: error in parse tree!"); - if ( pOptByClause->count() == 0 ) - return; - - OSL_ENSURE(pOptByClause->count() == 3,"OSQLParseTreeIterator: error in parse tree!"); - - OSQLParseNode * pOrderingSpecCommalist = pOptByClause->getChild(2); - OSL_ENSURE(pOrderingSpecCommalist != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(!_bOrder || SQL_ISRULE(pOrderingSpecCommalist,ordering_spec_commalist),"OSQLParseTreeIterator:ordering_spec_commalist error in parse tree!"); - OSL_ENSURE(pOrderingSpecCommalist->count() > 0,"OSQLParseTreeIterator: error in parse tree!"); - - ::rtl::OUString sColumnName,aColumnAlias; - ::rtl::OUString aTableRange; - sal_uInt32 nCount = pOrderingSpecCommalist->count(); - for (sal_uInt32 i = 0; i < nCount; ++i) - { - OSQLParseNode* pColumnRef = pOrderingSpecCommalist->getChild(i); - OSL_ENSURE(pColumnRef != NULL,"OSQLParseTreeIterator: error in parse tree!"); - if ( _bOrder ) - { - OSL_ENSURE(SQL_ISRULE(pColumnRef,ordering_spec),"OSQLParseTreeIterator:ordering_spec error in parse tree!"); - OSL_ENSURE(pColumnRef->count() == 2,"OSQLParseTreeIterator: error in parse tree!"); - - pColumnRef = pColumnRef->getChild(0); - } - aTableRange = ::rtl::OUString(); - sColumnName = ::rtl::OUString(); - if ( SQL_ISRULE(pColumnRef,column_ref) ) - { - // Column-Name (und TableRange): - if(SQL_ISRULE(pColumnRef,column_ref)) - getColumnRange(pColumnRef,sColumnName,aTableRange); - else // eine Expression - pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - - OSL_ENSURE(sColumnName.getLength(),"sColumnName darf nicht leer sein"); - } - else - { // here I found a predicate - pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - } - OSL_ENSURE(pColumnRef != NULL,"OSQLParseTreeIterator: error in parse tree!"); - if ( _bOrder ) - { - // Ascending/Descending - OSQLParseNode * pOptAscDesc = pColumnRef->getParent()->getChild(1); - OSL_ENSURE(pOptAscDesc != NULL,"OSQLParseTreeIterator: error in parse tree!"); - - sal_Bool bAscending = pOptAscDesc && SQL_ISTOKEN(pOptAscDesc,ASC); - setOrderByColumnName(sColumnName, aTableRange,bAscending); - } - else - setGroupByColumnName(sColumnName, aTableRange); - } -} -//----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::traverseGroupByColumnNames(const OSQLParseNode* pSelectNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseGroupByColumnNames" ); - traverseByColumnNames( pSelectNode, sal_False ); - return !hasErrors(); -} - -// ----------------------------------------------------------------------------- -namespace -{ - ::rtl::OUString lcl_generateParameterName( const OSQLParseNode& _rParentNode, const OSQLParseNode& _rParamNode ) - { - ::rtl::OUString sColumnName( RTL_CONSTASCII_USTRINGPARAM( "param" ) ); - const sal_Int32 nCount = (sal_Int32)_rParentNode.count(); - for ( sal_Int32 i = 0; i < nCount; ++i ) - { - if ( _rParentNode.getChild(i) == &_rParamNode ) - { - sColumnName += ::rtl::OUString::valueOf( i+1 ); - break; - } - } - return sColumnName; - } -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseParameters(const OSQLParseNode* _pNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseParameters" ); - if ( _pNode == NULL ) - return; - - ::rtl::OUString sColumnName, sTableRange, aColumnAlias; - const OSQLParseNode* pParent = _pNode->getParent(); - if ( pParent != NULL ) - { - if ( SQL_ISRULE(pParent,comparison_predicate) ) // x = X - { - sal_uInt32 nPos = 0; - if ( pParent->getChild(nPos) == _pNode ) - nPos = 2; - const OSQLParseNode* pOther = pParent->getChild(nPos); - if ( SQL_ISRULE( pOther, column_ref ) ) - getColumnRange( pOther, sColumnName, sTableRange, aColumnAlias); - else - pOther->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - } // if ( SQL_ISRULE(pParent,comparison_predicate) ) // x = X - else if ( SQL_ISRULE(pParent,other_like_predicate_part_2) ) - { - const OSQLParseNode* pOther = pParent->getParent()->getChild(0); - if ( SQL_ISRULE( pOther, column_ref ) ) - getColumnRange( pOther, sColumnName, sTableRange, aColumnAlias); - else - pOther->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - } - else if ( SQL_ISRULE(pParent,between_predicate_part_2) ) - { - const OSQLParseNode* pOther = pParent->getParent()->getChild(0); - if ( SQL_ISRULE( pOther, column_ref ) ) - getColumnRange( pOther, sColumnName, sTableRange, aColumnAlias); - else - { - pOther->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - lcl_generateParameterName( *pParent, *_pNode ); - } - } - else if ( pParent->getNodeType() == SQL_NODE_COMMALISTRULE ) - { - lcl_generateParameterName( *pParent, *_pNode ); - } - } - traverseParameter( _pNode, pParent, sColumnName, sTableRange, aColumnAlias ); - const sal_uInt32 nCount = _pNode->count(); - for (sal_uInt32 i = 0; i < nCount; ++i) - { - const OSQLParseNode* pChild = _pNode->getChild(i); - traverseParameters( pChild ); - } -} -//----------------------------------------------------------------------------- -bool OSQLParseTreeIterator::traverseSelectionCriteria(const OSQLParseNode* pSelectNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseSelectionCriteria" ); - if ( pSelectNode == NULL ) - return false; - - - // Parse Tree analysieren (je nach Statement-Typ) - // und Zeiger auf WHERE-Klausel setzen: - OSQLParseNode * pWhereClause = NULL; - - if (m_eStatementType == SQL_STATEMENT_SELECT) - { - if(SQL_ISRULE(pSelectNode,union_statement)) - { - return traverseSelectionCriteria( pSelectNode->getChild( 0 ) ) - && traverseSelectionCriteria( pSelectNode->getChild( 3 ) ); - } - OSL_ENSURE(pSelectNode->count() >= 4,"OSQLParseTreeIterator: error in parse tree!"); - - OSQLParseNode * pTableExp = pSelectNode->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - pWhereClause = pTableExp->getChild(1); - } else if (SQL_ISRULE(pSelectNode,update_statement_searched)) { - OSL_ENSURE(pSelectNode->count() == 5,"OSQLParseTreeIterator: error in parse tree!"); - pWhereClause = pSelectNode->getChild(4); - } else if (SQL_ISRULE(pSelectNode,delete_statement_searched)) { - OSL_ENSURE(pSelectNode->count() == 4,"OSQLParseTreeIterator: error in parse tree!"); - pWhereClause = pSelectNode->getChild(3); - } else if (SQL_ISRULE(pSelectNode,delete_statement_positioned)) { - // nyi - OSL_FAIL("OSQLParseTreeIterator::getSelectionCriteria: positioned nyi"); - } else { - // Anderes Statement. Keine Selektionskriterien. - return false; - } - - if (! SQL_ISRULE(pWhereClause,where_clause)) { - // Die Where Clause ist meistens optional, d. h. es koennte sich auch - // um "optional_where_clause" handeln. - OSL_ENSURE(SQL_ISRULE(pWhereClause,opt_where_clause),"OSQLParseTreeIterator: error in parse tree!"); - return false; - } - - // Wenn es aber eine where_clause ist, dann darf sie nicht leer sein: - OSL_ENSURE(pWhereClause->count() == 2,"OSQLParseTreeIterator: error in parse tree!"); - - OSQLParseNode * pComparisonPredicate = pWhereClause->getChild(1); - OSL_ENSURE(pComparisonPredicate != NULL,"OSQLParseTreeIterator: error in parse tree!"); - - // - // Und nun die Vergleichskriterien abarbeiten (rekursiv, alles ist erstmal ein OR-Kriterium): - // - - traverseORCriteria(pComparisonPredicate); - - return !hasErrors(); -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseORCriteria(OSQLParseNode * pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseORCriteria" ); - - - if ( - pSearchCondition->count() == 3 && - SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && - SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")") - ) - { - // Runde Klammern um den Ausdruck - traverseORCriteria(pSearchCondition->getChild(1)); - } else if (SQL_ISRULE(pSearchCondition,search_condition) && - pSearchCondition->count() == 3 && - SQL_ISTOKEN(pSearchCondition->getChild(1),OR)) - { - // OR-Verknuepfung: - - for (int i = 0; i < 3; i++) { - if (i == 1) continue; // Schluesselwort OR ueberspringen - - // Ist das erste Element wieder eine OR-Verknuepfung? - if (i == 0 && - SQL_ISRULE(pSearchCondition->getChild(0),search_condition) && - pSearchCondition->getChild(0)->count() == 3 && - SQL_ISTOKEN(pSearchCondition->getChild(0)->getChild(1),OR)) - { - // Dann rekursiv absteigen ... - traverseORCriteria(pSearchCondition->getChild(0)); - - } else { - // AND-Kriterien ... - traverseANDCriteria(pSearchCondition->getChild(i)); - // if (! aIteratorStatus.IsSuccessful()) break; - } - - // if (! aIteratorStatus.IsSuccessful()) break; - } - } else { - // Nur *ein* Kriterium oder eine AND-Verknuepfung von Kriterien. - // Direkt die AND-Kriterien behandeln. - traverseANDCriteria(pSearchCondition); - // if (! aIteratorStatus.IsSuccessful()) return; - } - - // Fehler einfach weiterreichen. -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseANDCriteria(OSQLParseNode * pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseANDCriteria" ); - - - if ( - SQL_ISRULE(pSearchCondition,boolean_primary) && - pSearchCondition->count() == 3 && - SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && - SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")") - ) - { - // Runde Klammern - traverseANDCriteria(pSearchCondition->getChild(1)); - } - // Das erste Element ist eine OR-Verknuepfung - else if ( SQL_ISRULE(pSearchCondition,search_condition) && pSearchCondition->count() == 3 ) - { - // Dann rekursiv absteigen (dieselbe Row benutzen) ... - traverseORCriteria(pSearchCondition->getChild(0)); -// if (! aIteratorStatus.IsSuccessful()) -// return; - - // Und mit dem rechten Child weitermachen: - traverseANDCriteria(pSearchCondition->getChild(2)); - } - // Das erste Element ist (wieder) eine AND-Verknuepfung - else if ( SQL_ISRULE(pSearchCondition,boolean_term) && pSearchCondition->count() == 3 ) - { - // Dann rekursiv absteigen (dieselbe Row benutzen) ... - traverseANDCriteria(pSearchCondition->getChild(0)); -// if (! aIteratorStatus.IsSuccessful()) -// return; - - // Und mit dem rechten Child weitermachen: - traverseANDCriteria(pSearchCondition->getChild(2)); - } - // Sonst einzelne Suchkriterien wie =, !=, ..., LIKE, IS NULL usw. behandeln: - else if (SQL_ISRULE(pSearchCondition,comparison_predicate) ) - { - ::rtl::OUString aValue; - pSearchCondition->getChild(2)->parseNodeToStr( aValue, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - traverseOnePredicate(pSearchCondition->getChild(0),aValue,pSearchCondition->getChild(2)); - impl_fillJoinConditions(pSearchCondition); -// if (! aIteratorStatus.IsSuccessful()) -// return; - } - else if (SQL_ISRULE(pSearchCondition,like_predicate) /*&& SQL_ISRULE(pSearchCondition->getChild(0),column_ref)*/) - { - OSL_ENSURE(pSearchCondition->count() == 2,"OSQLParseTreeIterator: error in parse tree!"); - const OSQLParseNode* pPart2 = pSearchCondition->getChild(1); - - sal_Int32 nCurentPos = pPart2->count()-2; - - OSQLParseNode * pNum_value_exp = pPart2->getChild(nCurentPos); - OSQLParseNode * pOptEscape = pPart2->getChild(nCurentPos+1); - - OSL_ENSURE(pNum_value_exp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pOptEscape != NULL,"OSQLParseTreeIterator: error in parse tree!"); - - if (pOptEscape->count() != 0) - { - // aIteratorStatus.setStatementTooComplex(); - return; - } - - ::rtl::OUString aValue; - OSQLParseNode * pParam = NULL; - if (SQL_ISRULE(pNum_value_exp,parameter)) - pParam = pNum_value_exp; - else if(pNum_value_exp->isToken()) - // Normaler Wert - aValue = pNum_value_exp->getTokenValue(); - else - { - pNum_value_exp->parseNodeToStr( aValue, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - pParam = pNum_value_exp; - } - - traverseOnePredicate(pSearchCondition->getChild(0),aValue,pParam); -// if (! aIteratorStatus.IsSuccessful()) -// return; - } - else if (SQL_ISRULE(pSearchCondition,in_predicate)) - { - OSL_ENSURE(pSearchCondition->count() == 2,"OSQLParseTreeIterator: error in parse tree!"); - const OSQLParseNode* pPart2 = pSearchCondition->getChild(1); - - traverseORCriteria(pSearchCondition->getChild(0)); - // if (! aIteratorStatus.IsSuccessful()) return; - - OSQLParseNode* pChild = pPart2->getChild(2); - if ( SQL_ISRULE(pChild->getChild(0),subquery) ) - { - traverseTableNames( *m_pImpl->m_pSubTables ); - traverseSelectionCriteria(pChild->getChild(0)->getChild(1)); - } - else - { // '(' value_exp_commalist ')' - pChild = pChild->getChild(1); - sal_Int32 nCount = pChild->count(); - for (sal_Int32 i=0; i < nCount; ++i) - { - traverseANDCriteria(pChild->getChild(i)); - } - } - } - else if (SQL_ISRULE(pSearchCondition,test_for_null) /*&& SQL_ISRULE(pSearchCondition->getChild(0),column_ref)*/) - { - OSL_ENSURE(pSearchCondition->count() == 2,"OSQLParseTreeIterator: error in parse tree!"); - const OSQLParseNode* pPart2 = pSearchCondition->getChild(1); - (void)pPart2; - OSL_ENSURE(SQL_ISTOKEN(pPart2->getChild(0),IS),"OSQLParseTreeIterator: error in parse tree!"); - - ::rtl::OUString aString; - traverseOnePredicate(pSearchCondition->getChild(0),aString,NULL); - // if (! aIteratorStatus.IsSuccessful()) return; - } - else if (SQL_ISRULE(pSearchCondition,num_value_exp) || SQL_ISRULE(pSearchCondition,term)) - { - ::rtl::OUString aString; - traverseOnePredicate(pSearchCondition->getChild(0),aString,pSearchCondition->getChild(0)); - traverseOnePredicate(pSearchCondition->getChild(2),aString,pSearchCondition->getChild(2)); - } - // Fehler einfach weiterreichen. -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseParameter(const OSQLParseNode* _pParseNode - ,const OSQLParseNode* _pParentNode - ,const ::rtl::OUString& _aColumnName - ,const ::rtl::OUString& _aTableRange - ,const ::rtl::OUString& _rColumnAlias) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseParameter" ); - if ( !SQL_ISRULE( _pParseNode, parameter ) ) - return; - - if ( ( m_pImpl->m_nIncludeMask & Parameters ) != Parameters ) - // parameters not to be included in the traversal - return; - - OSL_ENSURE(_pParseNode->count() > 0,"OSQLParseTreeIterator: error in parse tree!"); - OSQLParseNode * pMark = _pParseNode->getChild(0); - ::rtl::OUString sParameterName; - - if (SQL_ISPUNCTUATION(pMark,"?")) - { - sParameterName = _rColumnAlias.getLength() - ? _rColumnAlias - : _aColumnName.getLength() - ? _aColumnName - : ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("?")); - } - else if (SQL_ISPUNCTUATION(pMark,":")) - { - sParameterName = _pParseNode->getChild(1)->getTokenValue(); - } - else if (SQL_ISPUNCTUATION(pMark,"[")) - { - sParameterName = _pParseNode->getChild(1)->getTokenValue(); - } - else - { - OSL_FAIL("OSQLParseTreeIterator: error in parse tree!"); - } - - // found a parameter - if ( _pParentNode && (SQL_ISRULE(_pParentNode,general_set_fct) || SQL_ISRULE(_pParentNode,set_fct_spec)) ) - {// found a function as column_ref - ::rtl::OUString sFunctionName; - _pParentNode->getChild(0)->parseNodeToStr( sFunctionName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - const sal_uInt32 nCount = _pParentNode->count(); - sal_uInt32 i = 0; - for(; i < nCount;++i) - { - if ( _pParentNode->getChild(i) == _pParseNode ) - break; - } - sal_Int32 nType = ::connectivity::OSQLParser::getFunctionParameterType( _pParentNode->getChild(0)->getTokenID(), i-1); - - OParseColumn* pColumn = new OParseColumn( sParameterName, - ::rtl::OUString(), - ::rtl::OUString(), - ::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN, - 0, - 0, - nType, - sal_False, - sal_False, - isCaseSensitive()); - pColumn->setFunction(sal_True); - pColumn->setAggregateFunction(sal_True); - pColumn->setRealName(sFunctionName); - m_aParameters->get().push_back(pColumn); - } - else - { - sal_Bool bNotFound = sal_True; - OSQLColumns::Vector::const_iterator aIter = ::connectivity::find( - m_aSelectColumns->get().begin(), - m_aSelectColumns->get().end(), - _aColumnName,::comphelper::UStringMixEqual( isCaseSensitive() ) - ); - if(aIter != m_aSelectColumns->get().end()) - { - OParseColumn* pNewColumn = new OParseColumn(*aIter,isCaseSensitive()); - pNewColumn->setName(sParameterName); - pNewColumn->setRealName(_aColumnName); - m_aParameters->get().push_back(pNewColumn); - bNotFound = sal_False; - } - else if(_aColumnName.getLength())// search in the tables for the right one - { - - Reference<XPropertySet> xColumn = findColumn( _aColumnName, _aTableRange, true ); - - if ( xColumn.is() ) - { - OParseColumn* pNewColumn = new OParseColumn(xColumn,isCaseSensitive()); - pNewColumn->setName(sParameterName); - pNewColumn->setRealName(_aColumnName); - m_aParameters->get().push_back(pNewColumn); - bNotFound = sal_False; - } - } - if ( bNotFound ) - { - sal_Int32 nType = DataType::VARCHAR; - OSQLParseNode* pParent = _pParentNode ? _pParentNode->getParent() : NULL; - if ( pParent && (SQL_ISRULE(pParent,general_set_fct) || SQL_ISRULE(pParent,set_fct_spec)) ) - { - const sal_uInt32 nCount = _pParentNode->count(); - sal_uInt32 i = 0; - for(; i < nCount;++i) - { - if ( _pParentNode->getChild(i) == _pParseNode ) - break; - } - nType = ::connectivity::OSQLParser::getFunctionParameterType( pParent->getChild(0)->getTokenID(), i+1); - } - - ::rtl::OUString aNewColName( getUniqueColumnName( sParameterName ) ); - - OParseColumn* pColumn = new OParseColumn(aNewColName, - ::rtl::OUString(), - ::rtl::OUString(), - ::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN, - 0, - 0, - nType, - sal_False, - sal_False, - isCaseSensitive() ); - pColumn->setName(aNewColName); - pColumn->setRealName(sParameterName); - m_aParameters->get().push_back(pColumn); - } - } -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseOnePredicate( - OSQLParseNode * pColumnRef, - ::rtl::OUString& rValue, - OSQLParseNode * pParseNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseOnePredicate" ); - if ( !pParseNode ) - return; - - // Column-Name (und TableRange): - ::rtl::OUString aColumnName, aTableRange, sColumnAlias; - getColumnRange( pColumnRef, aColumnName, aTableRange, sColumnAlias); - - ::rtl::OUString aName; - - /*if (SQL_ISRULE(pParseNode,parameter)) - traverseParameter( pParseNode, pColumnRef, aColumnName, aTableRange, sColumnAlias ); - else */if (SQL_ISRULE(pParseNode,column_ref))// Column-Name (und TableRange): - getColumnRange(pParseNode,aName,rValue); - else - { - traverseORCriteria(pParseNode); - // if (! aIteratorStatus.IsSuccessful()) return; - } -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseSome( sal_uInt32 _nIncludeMask ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseSome" ); - impl_traverse( _nIncludeMask ); -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::traverseAll() -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::traverseAll" ); - impl_traverse( All ); -} - -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::impl_traverse( sal_uInt32 _nIncludeMask ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_traverse" ); - impl_resetErrors(); - m_pImpl->m_nIncludeMask = _nIncludeMask; - - if ( !traverseTableNames( *m_pImpl->m_pTables ) ) - return; - - switch ( m_eStatementType ) - { - case SQL_STATEMENT_SELECT: - { - const OSQLParseNode* pSelectNode = m_pParseTree; - traverseParameters( pSelectNode ); - if ( !traverseSelectColumnNames( pSelectNode ) - || !traverseOrderByColumnNames( pSelectNode ) - || !traverseGroupByColumnNames( pSelectNode ) - || !traverseSelectionCriteria( pSelectNode ) - ) - return; - } - break; - case 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: - break; - default: - break; - } -} - -// Dummy-Implementationen: - -//----------------------------------------------------------------------------- -OSQLTable OSQLParseTreeIterator::impl_createTableObject( const ::rtl::OUString& rTableName, - const ::rtl::OUString& rCatalogName, const ::rtl::OUString& rSchemaName ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_createTableObject" ); - 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) - - OSQLTable aReturnTable = new OTable( - NULL, - sal_False, - rTableName, - ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Table")), - ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("New Created Table")), - rSchemaName, - rCatalogName - ); - return aReturnTable; -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::appendColumns(::rtl::Reference<OSQLColumns>& _rColumns,const ::rtl::OUString& _rTableAlias,const OSQLTable& _rTable) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::appendColumns" ); - - if (!_rTable.is()) - return; - - Reference<XNameAccess> xColumns = _rTable->getColumns(); - if ( !xColumns.is() ) - return; - - Sequence< ::rtl::OUString > aColNames = xColumns->getElementNames(); - const ::rtl::OUString* pBegin = aColNames.getConstArray(); - const ::rtl::OUString* pEnd = pBegin + aColNames.getLength(); - - for(;pBegin != pEnd;++pBegin) - { - - ::rtl::OUString aName(getUniqueColumnName(*pBegin)); - Reference< XPropertySet > xColumn; - if(xColumns->hasByName(*pBegin) && (xColumns->getByName(*pBegin) >>= xColumn) && xColumn.is()) - { - OParseColumn* pColumn = new OParseColumn(aName - , getString(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))) - , getString(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE))) - , getString(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION))) - , getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))) - , getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))) - , getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))) - , 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))) - , isCaseSensitive() ); - - pColumn->setTableName(_rTableAlias); - pColumn->setRealName(*pBegin); - Reference< XPropertySet> xCol = pColumn; - _rColumns->get().push_back(xCol); - } - else - impl_appendError( IParseContext::ERROR_INVALID_COLUMN, pBegin, &_rTableAlias ); - } -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setSelectColumnName(::rtl::Reference<OSQLColumns>& _rColumns,const ::rtl::OUString & rColumnName,const ::rtl::OUString & rColumnAlias, const ::rtl::OUString & rTableRange,sal_Bool bFkt,sal_Int32 _nType,sal_Bool bAggFkt) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::setSelectColumnName" ); - if(rColumnName.toChar() == '*' && !rTableRange.getLength()) - { // SELECT * ... - OSL_ENSURE(_rColumns == m_aSelectColumns,"Invalid columns used here!"); - 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() ) - { // SELECT <table>.* - OSL_ENSURE(_rColumns == m_aSelectColumns,"Invalid columns used here!"); - ConstOSQLTablesIterator aFind = m_pImpl->m_pTables->find(rTableRange); - - if(aFind != m_pImpl->m_pTables->end()) - appendColumns(_rColumns,rTableRange,aFind->second); - } - else if ( !rTableRange.getLength() ) - { // SELECT <something> ... - // without table specified - if ( !bFkt ) - { - Reference< XPropertySet> xNewColumn; - - for ( OSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end(); ++aIter ) - { - if ( !aIter->second.is() ) - continue; - - Reference<XNameAccess> xColumns = aIter->second->getColumns(); - Reference< XPropertySet > xColumn; - if ( !xColumns->hasByName( rColumnName ) - || !( xColumns->getByName( rColumnName ) >>= xColumn ) - ) - continue; - - ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); - - OParseColumn* pColumn = new OParseColumn(xColumn,isCaseSensitive()); - xNewColumn = pColumn; - pColumn->setTableName(aIter->first); - pColumn->setName(aNewColName); - pColumn->setRealName(rColumnName); - - break; - } - - if ( !xNewColumn.is() ) - { - // no function (due to the above !bFkt), no existing column - // => assume an expression - ::rtl::OUString aNewColName( getUniqueColumnName( rColumnAlias ) ); - // did not find a column with this name in any of the tables - OParseColumn* pColumn = new OParseColumn( - aNewColName, - ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VARCHAR")), - // TODO: does this match with _nType? - // Or should be fill this from the getTypeInfo of the connection? - ::rtl::OUString(), - ::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN, - 0, - 0, - _nType, - sal_False, - sal_False, - isCaseSensitive() - ); - - xNewColumn = pColumn; - pColumn->setRealName( rColumnName ); - } - - _rColumns->get().push_back( xNewColumn ); - } - else - { - ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); - - OParseColumn* pColumn = new OParseColumn(aNewColName,::rtl::OUString(),::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,isCaseSensitive()); - pColumn->setFunction(sal_True); - pColumn->setAggregateFunction(bAggFkt); - pColumn->setRealName(rColumnName); - - Reference< XPropertySet> xCol = pColumn; - _rColumns->get().push_back(xCol); - } - } - else // ColumnName und Tablename vorhanden - { - ConstOSQLTablesIterator aFind = m_pImpl->m_pTables->find(rTableRange); - - sal_Bool bError = sal_False; - 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(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,_nType,sal_False,sal_False,isCaseSensitive()); - pColumn->setFunction(sal_True); - pColumn->setAggregateFunction(bAggFkt); - pColumn->setRealName(rColumnName); - pColumn->setTableName(aFind->first); - - Reference< XPropertySet> xCol = pColumn; - _rColumns->get().push_back(xCol); - } - else - { - Reference< XPropertySet > xColumn; - if (aFind->second->getColumns()->hasByName(rColumnName) && (aFind->second->getColumns()->getByName(rColumnName) >>= xColumn)) - { - ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); - - OParseColumn* pColumn = new OParseColumn(xColumn,isCaseSensitive()); - pColumn->setName(aNewColName); - pColumn->setRealName(rColumnName); - pColumn->setTableName(aFind->first); - - Reference< XPropertySet> xCol = pColumn; - _rColumns->get().push_back(xCol); - } - else - bError = sal_True; - } - } - else - bError = sal_True; - - // Tabelle existiert nicht oder Feld nicht vorhanden - if (bError) - { - ::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias)); - - OParseColumn* pColumn = new OParseColumn(aNewColName,::rtl::OUString(),::rtl::OUString(),::rtl::OUString(), - ColumnValue::NULLABLE_UNKNOWN,0,0,DataType::VARCHAR,sal_False,sal_False,isCaseSensitive()); - pColumn->setFunction(sal_True); - pColumn->setAggregateFunction(bAggFkt); - - Reference< XPropertySet> xCol = pColumn; - _rColumns->get().push_back(xCol); - } - } -} -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParseTreeIterator::getUniqueColumnName(const ::rtl::OUString & rColumnName) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getUniqueColumnName" ); - ::rtl::OUString aAlias(rColumnName); - - OSQLColumns::Vector::const_iterator aIter = find( - m_aSelectColumns->get().begin(), - m_aSelectColumns->get().end(), - aAlias, - ::comphelper::UStringMixEqual( isCaseSensitive() ) - ); - sal_Int32 i=1; - while(aIter != m_aSelectColumns->get().end()) - { - (aAlias = rColumnName) += ::rtl::OUString::valueOf(i++); - aIter = find( - m_aSelectColumns->get().begin(), - m_aSelectColumns->get().end(), - aAlias, - ::comphelper::UStringMixEqual( isCaseSensitive() ) - ); - } - return aAlias; -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setOrderByColumnName(const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange,sal_Bool bAscending) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::setOrderByColumnName" ); - Reference<XPropertySet> xColumn = findColumn( rColumnName, rTableRange, false ); - if ( xColumn.is() ) - m_aOrderColumns->get().push_back(new OOrderColumn( xColumn, rTableRange, isCaseSensitive(), bAscending ) ); - else - { - sal_Int32 nId = rColumnName.toInt32(); - if ( nId > 0 && nId < static_cast<sal_Int32>(m_aSelectColumns->get().size()) ) - m_aOrderColumns->get().push_back( new OOrderColumn( ( m_aSelectColumns->get() )[nId-1], isCaseSensitive(), bAscending ) ); - } - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setOrderByColumnName: " - << (const char *) rColumnName << ", " - << (const char *) rTableRange << ", " - << (bAscending ? "true" : "false") - << "\n"; -#endif -} -//----------------------------------------------------------------------------- -void OSQLParseTreeIterator::setGroupByColumnName(const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::setGroupByColumnName" ); - Reference<XPropertySet> xColumn = findColumn( rColumnName, rTableRange, false ); - if ( xColumn.is() ) - m_aGroupColumns->get().push_back(new OParseColumn(xColumn,isCaseSensitive())); - else - { - sal_Int32 nId = rColumnName.toInt32(); - if ( nId > 0 && nId < static_cast<sal_Int32>(m_aSelectColumns->get().size()) ) - m_aGroupColumns->get().push_back(new OParseColumn((m_aSelectColumns->get())[nId-1],isCaseSensitive())); - } - -#ifdef SQL_TEST_PARSETREEITERATOR - cout << "OSQLParseTreeIterator::setOrderByColumnName: " - << (const char *) rColumnName << ", " - << (const char *) rTableRange << ", " - << (bAscending ? "true" : "false") - << "\n"; -#endif -} - -//----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getWhereTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getWhereTree" ); - - - if (!m_pParseTree) - return NULL; - - // Parse Tree analysieren (je nach Statement-Typ) - // und Zeiger auf WHERE-Klausel setzen: - OSQLParseNode * pWhereClause = NULL; - if(getStatementType() == SQL_STATEMENT_SELECT) - { - OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!"); - OSQLParseNode * pTableExp = m_pParseTree->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - pWhereClause = pTableExp->getChild(1); - } - else if (SQL_ISRULE(m_pParseTree,update_statement_searched) || - SQL_ISRULE(m_pParseTree,delete_statement_searched)) - { - pWhereClause = m_pParseTree->getChild(m_pParseTree->count()-1); - } - if(pWhereClause->count() != 2) - pWhereClause = NULL; - return pWhereClause; -} - -//----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getOrderTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getOrderTree" ); - - - if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT) - return NULL; - - // Parse Tree analysieren (je nach Statement-Typ) - // und Zeiger auf ORDER-Klausel setzen: - OSQLParseNode * pOrderClause = NULL; - OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!"); - OSQLParseNode * pTableExp = m_pParseTree->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - pOrderClause = pTableExp->getChild(ORDER_BY_CHILD_POS); - // Wenn es aber eine order_by ist, dann darf sie nicht leer sein: - if(pOrderClause->count() != 3) - pOrderClause = NULL; - return pOrderClause; -} -//----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getGroupByTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getGroupByTree" ); - if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT) - return NULL; - - // Parse Tree analysieren (je nach Statement-Typ) - // und Zeiger auf ORDER-Klausel setzen: - OSQLParseNode * pGroupClause = NULL; - OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!"); - OSQLParseNode * pTableExp = m_pParseTree->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - pGroupClause = pTableExp->getChild(2); - // Wenn es aber eine order_by ist, dann darf sie nicht leer sein: - if(pGroupClause->count() != 3) - pGroupClause = NULL; - return pGroupClause; -} -//----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getHavingTree() const -{ - if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT) - return NULL; - - // Parse Tree analysieren (je nach Statement-Typ) - // und Zeiger auf ORDER-Klausel setzen: - OSQLParseNode * pHavingClause = NULL; - OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!"); - OSQLParseNode * pTableExp = m_pParseTree->getChild(3); - OSL_ENSURE(pTableExp != NULL,"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(SQL_ISRULE(pTableExp,table_exp),"OSQLParseTreeIterator: error in parse tree!"); - OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!"); - - pHavingClause = pTableExp->getChild(3); - // Wenn es aber eine order_by ist, dann darf sie nicht leer sein: - if(pHavingClause->count() < 1) - pHavingClause = NULL; - return pHavingClause; -} -// ----------------------------------------------------------------------------- -sal_Bool OSQLParseTreeIterator::isTableNode(const OSQLParseNode* _pTableNode) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::isTableNode" ); - return _pTableNode && (SQL_ISRULE(_pTableNode,catalog_name) || - SQL_ISRULE(_pTableNode,schema_name) || - SQL_ISRULE(_pTableNode,table_name)); -} -// ----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getSimpleWhereTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getSimpleWhereTree" ); - const OSQLParseNode* pNode = getWhereTree(); - return pNode ? pNode->getChild(1) : NULL; -} -// ----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getSimpleOrderTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getSimpleOrderTree" ); - const OSQLParseNode* pNode = getOrderTree(); - return pNode ? pNode->getChild(2) : NULL; -} -// ----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getSimpleGroupByTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getSimpleGroupByTree" ); - const OSQLParseNode* pNode = getGroupByTree(); - return pNode ? pNode->getChild(2) : NULL; -} -// ----------------------------------------------------------------------------- -const OSQLParseNode* OSQLParseTreeIterator::getSimpleHavingTree() const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::getSimpleHavingTree" ); - const OSQLParseNode* pNode = getHavingTree(); - return pNode ? pNode->getChild(1) : NULL; -} - -// ----------------------------------------------------------------------------- -Reference< XPropertySet > OSQLParseTreeIterator::findColumn( const ::rtl::OUString & rColumnName, const ::rtl::OUString & rTableRange, bool _bLookInSubTables ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::findColumn" ); - 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) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::findColumn" ); - Reference< XPropertySet > xColumn; - if ( rTableRange.getLength() ) - { - ConstOSQLTablesIterator aFind = _rTables.find(rTableRange); - - if ( aFind != _rTables.end() - && aFind->second.is() - && aFind->second->getColumns().is() - && aFind->second->getColumns()->hasByName(rColumnName) ) - aFind->second->getColumns()->getByName(rColumnName) >>= xColumn; - } - if ( !xColumn.is() ) - { - OSQLTables::const_iterator aEnd = _rTables.end(); - for(OSQLTables::const_iterator aIter = _rTables.begin(); aIter != aEnd; ++aIter) - { - if ( aIter->second.is() ) - { - Reference<XNameAccess> xColumns = aIter->second->getColumns(); - if( xColumns.is() && xColumns->hasByName(rColumnName) && (xColumns->getByName(rColumnName) >>= xColumn) ) - { - OSL_ENSURE(xColumn.is(),"Column isn't a propertyset!"); - break; // diese Column darf nur einmal vorkommen - } - } - } - } - return xColumn; -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::impl_appendError( IParseContext::ErrorCode _eError, const ::rtl::OUString* _pReplaceToken1, const ::rtl::OUString* _pReplaceToken2 ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_appendError" ); - ::rtl::OUString sErrorMessage = m_rParser.getContext().getErrorMessage( _eError ); - if ( _pReplaceToken1 ) - { - bool bTwoTokens = ( _pReplaceToken2 != NULL ); - const sal_Char* pPlaceHolder1 = bTwoTokens ? "#1" : "#"; - const ::rtl::OUString sPlaceHolder1 = ::rtl::OUString::createFromAscii( pPlaceHolder1 ); - - sErrorMessage = sErrorMessage.replaceAt( sErrorMessage.indexOf( sPlaceHolder1 ), sPlaceHolder1.getLength(), *_pReplaceToken1 ); - if ( _pReplaceToken2 ) - sErrorMessage = sErrorMessage.replaceAt( sErrorMessage.indexOf( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("#2")) ), 2, *_pReplaceToken2 ); - } - - impl_appendError( SQLException( - sErrorMessage, NULL, getStandardSQLState( SQL_GENERAL_ERROR ), 1000, Any() ) ); -} - -// ----------------------------------------------------------------------------- -void OSQLParseTreeIterator::impl_appendError( const SQLException& _rError ) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseTreeIterator::impl_appendError" ); - if ( m_aErrors.Message.getLength() ) - { - SQLException* pErrorChain = &m_aErrors; - while ( pErrorChain->NextException.hasValue() ) - pErrorChain = static_cast< SQLException* >( pErrorChain->NextException.pData ); - pErrorChain->NextException <<= _rError; - } - else - m_aErrors = _rError; -} -// ----------------------------------------------------------------------------- -sal_Int32 OSQLParseTreeIterator::getFunctionReturnType(const OSQLParseNode* _pNode ) -{ - sal_Int32 nType = DataType::OTHER; - ::rtl::OUString sFunctionName; - if ( SQL_ISRULE(_pNode,length_exp) ) - { - _pNode->getChild(0)->getChild(0)->parseNodeToStr(sFunctionName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - nType = ::connectivity::OSQLParser::getFunctionReturnType( sFunctionName, &m_rParser.getContext() ); - } - else if ( SQL_ISRULE(_pNode,num_value_exp) || SQL_ISRULE(_pNode,term) || SQL_ISRULE(_pNode,factor) ) - { - nType = DataType::DOUBLE; - } - else - { - _pNode->getChild(0)->parseNodeToStr(sFunctionName, m_pImpl->m_xConnection, NULL, sal_False, sal_False ); - - // MIN and MAX have another return type, we have to check the expression itself. - // @see http://qa.openoffice.org/issues/show_bug.cgi?id=99566 - if ( SQL_ISRULE(_pNode,general_set_fct) && (SQL_ISTOKEN(_pNode->getChild(0),MIN) || SQL_ISTOKEN(_pNode->getChild(0),MAX) )) - { - const OSQLParseNode* pValueExp = _pNode->getChild(3); - if (SQL_ISRULE(pValueExp,column_ref)) - { - ::rtl::OUString sColumnName; - ::rtl::OUString aTableRange; - getColumnRange(pValueExp,sColumnName,aTableRange); - OSL_ENSURE(sColumnName.getLength(),"Columnname darf nicht leer sein"); - Reference<XPropertySet> xColumn = findColumn( sColumnName, aTableRange, true ); - - if ( xColumn.is() ) - { - xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_TYPE)) >>= nType; - } - } - else - { - if ( SQL_ISRULE(pValueExp,num_value_exp) || SQL_ISRULE(pValueExp,term) || SQL_ISRULE(pValueExp,factor) ) - { - nType = DataType::DOUBLE; - } - else if ( SQL_ISRULE(pValueExp,datetime_primary) ) - { - switch(pValueExp->getChild(0)->getTokenID() ) - { - case SQL_TOKEN_CURRENT_DATE: - nType = DataType::DATE; - break; - case SQL_TOKEN_CURRENT_TIME: - nType = DataType::TIME; - break; - case SQL_TOKEN_CURRENT_TIMESTAMP: - nType = DataType::TIMESTAMP; - break; - } - } - else if ( SQL_ISRULE(pValueExp,value_exp_primary) ) - { - nType = getFunctionReturnType(pValueExp->getChild(1)); - } - else if ( SQL_ISRULE(pValueExp,concatenation) - || SQL_ISRULE(pValueExp,char_factor) - || SQL_ISRULE(pValueExp,bit_value_fct) - || SQL_ISRULE(pValueExp,char_value_fct) - || SQL_ISRULE(pValueExp,char_substring_fct) - || SQL_ISRULE(pValueExp,fold) - || SQL_ISTOKEN(pValueExp,STRING) ) - { - nType = DataType::VARCHAR; - } - } - if ( nType == DataType::OTHER ) - nType = DataType::DOUBLE; - } - else - nType = ::connectivity::OSQLParser::getFunctionReturnType( sFunctionName, &m_rParser.getContext() ); - } - - return nType; -} - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/parse/sqlnode.cxx b/connectivity/source/parse/sqlnode.cxx deleted file mode 100644 index 0f9170b0ed..0000000000 --- a/connectivity/source/parse/sqlnode.cxx +++ /dev/null @@ -1,2838 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" - - -#include <sal/macros.h> -#include <connectivity/sqlnode.hxx> -#include <connectivity/sqlerror.hxx> -#include <internalnode.hxx> -#define YYBISON 1 -#ifndef BISON_INCLUDED -#define BISON_INCLUDED -#include <sqlbison.hxx> -#endif -#include <connectivity/sqlparse.hxx> -#include <com/sun/star/lang/Locale.hpp> -#include <com/sun/star/util/XNumberFormatter.hpp> -#include <com/sun/star/util/XNumberFormatTypes.hpp> -#include <com/sun/star/i18n/NumberFormatIndex.hpp> -#include <com/sun/star/beans/XPropertySet.hpp> -#include <com/sun/star/sdbc/XDatabaseMetaData.hpp> -#include <com/sun/star/sdbc/DataType.hpp> -#include <com/sun/star/sdb/XQueriesSupplier.hpp> -#include <com/sun/star/sdb/ErrorCondition.hpp> -#include <com/sun/star/util/XNumberFormatter.hpp> -#include <com/sun/star/util/XNumberFormatsSupplier.hpp> -#include <com/sun/star/util/XNumberFormats.hpp> -#include <com/sun/star/util/NumberFormat.hpp> -#include <com/sun/star/util/XNumberFormatTypes.hpp> -#include <com/sun/star/lang/Locale.hpp> -#include <com/sun/star/i18n/KParseType.hpp> -#include <com/sun/star/i18n/KParseTokens.hpp> -#include "connectivity/dbconversion.hxx" -#include <com/sun/star/util/DateTime.hpp> -#include <com/sun/star/util/Time.hpp> -#include <com/sun/star/util/Date.hpp> -#include "TConnection.hxx" -#include "sqlscan.hxx" -#include <comphelper/numbers.hxx> -#include <comphelper/processfactory.hxx> -#include <comphelper/stl_types.hxx> -#include "connectivity/dbtools.hxx" -#include "connectivity/dbmetadata.hxx" -#include "connectivity/sqlerror.hxx" -#include <tools/diagnose_ex.h> -#include <string.h> -#include <boost/bind.hpp> -#include <algorithm> -#include <functional> -#include <rtl/logfile.hxx> -#include <rtl/ustrbuf.hxx> - -using namespace ::com::sun::star::sdbc; -using namespace ::com::sun::star::util; -using namespace ::com::sun::star::beans; -using namespace ::com::sun::star::sdb; -using namespace ::com::sun::star::uno; -using namespace ::com::sun::star::lang; -using namespace ::com::sun::star::i18n; -using namespace ::com::sun::star; -using namespace ::osl; -using namespace ::dbtools; -using namespace ::comphelper; - - -extern int SQLyyparse (void); -extern ::rtl::OUString ConvertLikeToken(const ::connectivity::OSQLParseNode* pTokenNode, const ::connectivity::OSQLParseNode* pEscapeNode, sal_Bool bInternational); -extern void setParser( ::connectivity::OSQLParser* ); - -namespace -{ - // ----------------------------------------------------------------------------- - sal_Bool lcl_saveConvertToNumber(const Reference< XNumberFormatter > & _xFormatter,sal_Int32 _nKey,const ::rtl::OUString& _sValue,double& _nrValue) - { - sal_Bool bRet = sal_False; - try - { - _nrValue = _xFormatter->convertStringToNumber(_nKey, _sValue); - bRet = sal_True; - } - catch(Exception&) - { - } - return bRet; - } - // ----------------------------------------------------------------------------- - void replaceAndReset(connectivity::OSQLParseNode*& _pResetNode,connectivity::OSQLParseNode* _pNewNode) - { - _pResetNode->getParent()->replace(_pResetNode, _pNewNode); - delete _pResetNode; - _pResetNode = _pNewNode; - } - // ----------------------------------------------------------------------------- - /** quotes a string and search for quotes inside the string and replace them with the new quote - @param rValue - The value to be quoted. - @param rQuot - The quote - @param rQuotToReplace - The quote to replace with - @return - The quoted string. - */ - ::rtl::OUString SetQuotation(const ::rtl::OUString& rValue, const ::rtl::OUString& rQuot, const ::rtl::OUString& rQuotToReplace) - { - ::rtl::OUString rNewValue = rQuot; - rNewValue += rValue; - sal_Int32 nIndex = (sal_Int32)-1; // Quotes durch zweifache Quotes ersetzen, sonst kriegt der Parser Probleme - - if (rQuot.getLength()) - { - do - { - nIndex += 2; - nIndex = rNewValue.indexOf(rQuot,nIndex); - if(nIndex != -1) - rNewValue = rNewValue.replaceAt(nIndex,rQuot.getLength(),rQuotToReplace); - } while (nIndex != -1); - } - - rNewValue += rQuot; - return rNewValue; - } -} - -namespace connectivity -{ - -//============================================================================= -struct OSQLParser_Data -{ - ::com::sun::star::lang::Locale aLocale; - ::connectivity::SQLError aErrors; - - OSQLParser_Data( const Reference< XMultiServiceFactory >& _xServiceFactory ) - :aErrors( _xServiceFactory ) - { - } -}; - -//============================================================================= -//= SQLParseNodeParameter -//============================================================================= -//----------------------------------------------------------------------------- -SQLParseNodeParameter::SQLParseNodeParameter( const Reference< XConnection >& _rxConnection, - const Reference< XNumberFormatter >& _xFormatter, const Reference< XPropertySet >& _xField, - const Locale& _rLocale, const IParseContext* _pContext, - bool _bIntl, bool _bQuote, sal_Char _cDecSep, bool _bPredicate, bool _bParseToSDBC ) - :rLocale(_rLocale) - ,aMetaData( _rxConnection ) - ,pParser( NULL ) - ,pSubQueryHistory( new QueryNameSet ) - ,xFormatter(_xFormatter) - ,xField(_xField) - ,m_rContext( _pContext ? (const IParseContext&)(*_pContext) : (const IParseContext&)OSQLParser::s_aDefaultContext ) - ,cDecSep(_cDecSep) - ,bQuote(_bQuote) - ,bInternational(_bIntl) - ,bPredicate(_bPredicate) - ,bParseToSDBCLevel( _bParseToSDBC ) -{ -} - -//----------------------------------------------------------------------------- -SQLParseNodeParameter::~SQLParseNodeParameter() -{ -} - -//============================================================================= -//= OSQLParseNode -//============================================================================= -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParseNode::convertDateString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertDateString" ); - Date aDate = DBTypeConversion::toDate(rString); - Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); - Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); - - double fDate = DBTypeConversion::toDouble(aDate,DBTypeConversion::getNULLDate(xSupplier)); - sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 36; // XXX hack - return rParam.xFormatter->convertNumberToString(nKey, fDate); -} - -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParseNode::convertDateTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertDateTimeString" ); - DateTime aDate = DBTypeConversion::toDateTime(rString); - Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); - Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); - - double fDateTime = DBTypeConversion::toDouble(aDate,DBTypeConversion::getNULLDate(xSupplier)); - sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 51; // XXX hack - return rParam.xFormatter->convertNumberToString(nKey, fDateTime); -} - -//----------------------------------------------------------------------------- -::rtl::OUString OSQLParseNode::convertTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::convertTimeString" ); - Time aTime = DBTypeConversion::toTime(rString); - Reference< XNumberFormatsSupplier > xSupplier(rParam.xFormatter->getNumberFormatsSupplier()); - - Reference< XNumberFormatTypes > xTypes(xSupplier->getNumberFormats(), UNO_QUERY); - - double fTime = DBTypeConversion::toDouble(aTime); - sal_Int32 nKey = xTypes->getStandardIndex(rParam.rLocale) + 41; // XXX hack - return rParam.xFormatter->convertNumberToString(nKey, fTime); -} - -//----------------------------------------------------------------------------- -void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, - const Reference< XConnection >& _rxConnection, - const IParseContext* pContext, - sal_Bool _bIntl, - sal_Bool _bQuote) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToStr" ); - - parseNodeToStr( - rString, _rxConnection, NULL, NULL, - pContext ? pContext->getPreferredLocale() : OParseContext::getDefaultLocale(), - pContext, _bIntl, _bQuote, '.', false, false ); -} - -//----------------------------------------------------------------------------- -void OSQLParseNode::parseNodeToPredicateStr(::rtl::OUString& rString, - const Reference< XConnection >& _rxConnection, - const Reference< XNumberFormatter > & xFormatter, - const ::com::sun::star::lang::Locale& rIntl, - sal_Char _cDec, - const IParseContext* pContext ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToPredicateStr" ); - - OSL_ENSURE(xFormatter.is(), "OSQLParseNode::parseNodeToPredicateStr:: no formatter!"); - - if (xFormatter.is()) - parseNodeToStr(rString, _rxConnection, xFormatter, NULL, rIntl, pContext, sal_True, sal_True, _cDec, true, false); -} - -//----------------------------------------------------------------------------- -void OSQLParseNode::parseNodeToPredicateStr(::rtl::OUString& rString, - const Reference< XConnection > & _rxConnection, - const Reference< XNumberFormatter > & xFormatter, - const Reference< XPropertySet > & _xField, - const ::com::sun::star::lang::Locale& rIntl, - sal_Char _cDec, - const IParseContext* pContext ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToPredicateStr" ); - - OSL_ENSURE(xFormatter.is(), "OSQLParseNode::parseNodeToPredicateStr:: no formatter!"); - - if (xFormatter.is()) - parseNodeToStr( rString, _rxConnection, xFormatter, _xField, rIntl, pContext, true, true, _cDec, true, false ); -} - -//----------------------------------------------------------------------------- -void OSQLParseNode::parseNodeToStr(::rtl::OUString& rString, - const Reference< XConnection > & _rxConnection, - const Reference< XNumberFormatter > & xFormatter, - const Reference< XPropertySet > & _xField, - const ::com::sun::star::lang::Locale& rIntl, - const IParseContext* pContext, - bool _bIntl, - bool _bQuote, - sal_Char _cDecSep, - bool _bPredicate, - bool _bSubstitute) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToStr" ); - - OSL_ENSURE( _rxConnection.is(), "OSQLParseNode::parseNodeToStr: invalid connection!" ); - - if ( _rxConnection.is() ) - { - ::rtl::OUStringBuffer sBuffer = rString; - try - { - OSQLParseNode::impl_parseNodeToString_throw( sBuffer, - SQLParseNodeParameter( - _rxConnection, xFormatter, _xField, rIntl, pContext, - _bIntl, _bQuote, _cDecSep, _bPredicate, _bSubstitute - ) ); - } - catch( const SQLException& ) - { - OSL_FAIL( "OSQLParseNode::parseNodeToStr: this should not throw!" ); - // our callers don't expect this method to throw anything. The only known situation - // where impl_parseNodeToString_throw can throw is when there is a cyclic reference - // in the sub queries, but this cannot be the case here, as we do not parse to - // SDBC level. - } - rString = sBuffer.makeStringAndClear(); - } -} -//----------------------------------------------------------------------------- -bool OSQLParseNode::parseNodeToExecutableStatement( ::rtl::OUString& _out_rString, const Reference< XConnection >& _rxConnection, - OSQLParser& _rParser, ::com::sun::star::sdbc::SQLException* _pErrorHolder ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::parseNodeToExecutableStatement" ); - OSL_PRECOND( _rxConnection.is(), "OSQLParseNode::parseNodeToExecutableStatement: invalid connection!" ); - SQLParseNodeParameter aParseParam( _rxConnection, - NULL, NULL, OParseContext::getDefaultLocale(), NULL, false, true, '.', false, true ); - - if ( aParseParam.aMetaData.supportsSubqueriesInFrom() ) - { - Reference< XQueriesSupplier > xSuppQueries( _rxConnection, UNO_QUERY ); - OSL_ENSURE( xSuppQueries.is(), "OSQLParseNode::parseNodeToExecutableStatement: cannot substitute everything without a QueriesSupplier!" ); - if ( xSuppQueries.is() ) - aParseParam.xQueries = xSuppQueries->getQueries(); - } - - aParseParam.pParser = &_rParser; - - _out_rString = ::rtl::OUString(); - ::rtl::OUStringBuffer sBuffer; - bool bSuccess = false; - try - { - impl_parseNodeToString_throw( sBuffer, aParseParam ); - bSuccess = true; - } - catch( const SQLException& e ) - { - if ( _pErrorHolder ) - *_pErrorHolder = e; - } - _out_rString = sBuffer.makeStringAndClear(); - return bSuccess; -} - -//----------------------------------------------------------------------------- -namespace -{ - bool lcl_isAliasNamePresent( const OSQLParseNode& _rTableNameNode ) - { - return OSQLParseNode::getTableRange(_rTableNameNode.getParent()).getLength() != 0; - } -} - -//----------------------------------------------------------------------------- -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() ) - { - parseLeaf(rString,rParam); - return; - } - - // einmal auswerten wieviel Subtrees dieser Knoten besitzt - sal_uInt32 nCount = count(); - - bool bHandled = false; - switch ( getKnownRuleID() ) - { - // special handling for parameters - case parameter: - { - if(rString.getLength()) - rString.appendAscii(" "); - if (nCount == 1) // ? - m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); - else if (nCount == 2) // :Name - { - m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); - rString.append(m_aChildren[1]->m_aNodeValue); - } // [Name] - else - { - m_aChildren[0]->impl_parseNodeToString_throw( rString, rParam ); - rString.append(m_aChildren[1]->m_aNodeValue); - rString.append(m_aChildren[2]->m_aNodeValue); - } - bHandled = true; - } - break; - - // table refs - case table_ref: - if ( ( nCount == 2 ) || ( nCount == 3 ) || ( nCount == 5 ) ) - { - impl_parseTableRangeNodeToString_throw( rString, rParam ); - bHandled = true; - } - break; - - // table name - might be a query name - case table_name: - bHandled = impl_parseTableNameNodeToString_throw( rString, rParam ); - break; - - case as: - if ( rParam.aMetaData.generateASBeforeCorrelationName() ) - rString.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" AS"))); - bHandled = true; - break; - - case like_predicate: - // je nachdem ob international angegeben wird oder nicht wird like anders behandelt - // interanational: *, ? sind Platzhalter - // sonst SQL92 konform: %, _ - impl_parseLikeNodeToString_throw( rString, rParam ); - bHandled = true; - break; - - case general_set_fct: - case set_fct_spec: - case position_exp: - case extract_exp: - case length_exp: - case char_value_fct: - { - if (!addDateValue(rString, rParam)) - { - // Funktionsname nicht quoten - SQLParseNodeParameter aNewParam(rParam); - aNewParam.bQuote = ( SQL_ISRULE(this,length_exp) || SQL_ISRULE(this,char_value_fct) ); - - m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); - aNewParam.bQuote = rParam.bQuote; - //aNewParam.bPredicate = sal_False; // disable [ ] around names // look at i73215 - ::rtl::OUStringBuffer aStringPara; - for (sal_uInt32 i=1; i<nCount; 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.appendAscii(","); - } - else - i++; - } - rString.append(aStringPara.makeStringAndClear()); - } - bHandled = true; - } - break; - default: - break; - } // switch ( getKnownRuleID() ) - - if ( !bHandled ) - { - for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); - i != m_aChildren.end();) - { - const OSQLParseNode* pSubTree = *i; - if ( !pSubTree ) - { - ++i; - continue; - } - - SQLParseNodeParameter aNewParam(rParam); - - // don't replace the field for subqueries - if (rParam.xField.is() && SQL_ISRULE(pSubTree,subquery)) - aNewParam.xField = NULL; - - // if there is a field given we don't display the fieldname, if there is any - if (rParam.xField.is() && SQL_ISRULE(pSubTree,column_ref)) - { - sal_Bool bFilter = sal_False; - // retrieve the fields name - ::rtl::OUString aFieldName; - try - { - sal_Int32 nNamePropertyId = PROPERTY_ID_NAME; - if ( rParam.xField->getPropertySetInfo()->hasPropertyByName( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_REALNAME ) ) ) - nNamePropertyId = PROPERTY_ID_REALNAME; - rParam.xField->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( nNamePropertyId ) ) >>= aFieldName; - } - catch ( Exception& ) - { - } - - if(pSubTree->count()) - { - const OSQLParseNode* pCol = pSubTree->m_aChildren[pSubTree->count()-1]; - if ( ( SQL_ISRULE(pCol,column_val) - && pCol->getChild(0)->getTokenValue().equalsIgnoreAsciiCase(aFieldName) - ) - || pCol->getTokenValue().equalsIgnoreAsciiCase(aFieldName) - ) - bFilter = sal_True; - } - - // ok we found the field, if the following node is the - // comparision operator '=' we filter it as well - if (bFilter) - { - if (SQL_ISRULE(this, comparison_predicate)) - { - ++i; - if(i != m_aChildren.end()) - { - pSubTree = *i; - if (pSubTree && pSubTree->getNodeType() == SQL_NODE_EQUAL) - ++i; - } - } - else - ++i; - } - else - { - pSubTree->impl_parseNodeToString_throw( rString, aNewParam ); - ++i; - - // bei den CommaListen zwischen alle Subtrees Commas setzen - if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) - rString.appendAscii(","); - } - } - else - { - pSubTree->impl_parseNodeToString_throw( rString, aNewParam ); - ++i; - - // bei den CommaListen zwischen alle Subtrees Commas setzen - if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end())) - { - if (SQL_ISRULE(this,value_exp_commalist) && rParam.bPredicate) - rString.appendAscii(";"); - else - rString.appendAscii(","); - } - } - } - } -} - -//----------------------------------------------------------------------------- -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? - OSL_ENSURE( getParent(), "OSQLParseNode::impl_parseTableNameNodeToString_throw: table_name without parent?" ); - if ( !getParent() || ( getParent()->getKnownRuleID() != table_ref ) ) - return false; - - // if it's a query, maybe we need to substitute the SQL statement ... - if ( !rParam.bParseToSDBCLevel ) - return false; - - if ( !rParam.xQueries.is() ) - // connection does not support queries in queries, or was no query supplier - return false; - - try - { - ::rtl::OUString sTableOrQueryName( getChild(0)->getTokenValue() ); - bool bIsQuery = rParam.xQueries->hasByName( sTableOrQueryName ); - if ( !bIsQuery ) - return false; - - // avoid recursion (e.g. "foo" defined as "SELECT * FROM bar" and "bar" defined as "SELECT * FROM foo". - if ( rParam.pSubQueryHistory->find( sTableOrQueryName ) != rParam.pSubQueryHistory->end() ) - { - ::rtl::OUString sMessage( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cyclic sub queries" ) ) ); - OSL_ENSURE( rParam.pParser, "OSQLParseNode::impl_parseTableNameNodeToString_throw: no parser?" ); - if ( rParam.pParser ) - { - const SQLError& rErrors( rParam.pParser->getErrorHelper() ); - rErrors.raiseException( sdb::ErrorCondition::PARSER_CYCLIC_SUB_QUERIES ); - } - else - { - SQLError aErrors( ::comphelper::getProcessServiceFactory() ); - aErrors.raiseException( sdb::ErrorCondition::PARSER_CYCLIC_SUB_QUERIES ); - } - } - rParam.pSubQueryHistory->insert( sTableOrQueryName ); - - Reference< XPropertySet > xQuery( rParam.xQueries->getByName( sTableOrQueryName ), UNO_QUERY_THROW ); - - // substitute the query name with the constituting command - ::rtl::OUString sCommand; - OSL_VERIFY( xQuery->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_COMMAND ) ) >>= sCommand ); - - sal_Bool bEscapeProcessing = sal_False; - OSL_VERIFY( xQuery->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ) ) >>= bEscapeProcessing ); - - // the query we found here might itself be based on another query, so parse it recursively - OSL_ENSURE( rParam.pParser, "OSQLParseNode::impl_parseTableNameNodeToString_throw: cannot analyze sub queries without a parser!" ); - if ( bEscapeProcessing && rParam.pParser ) - { - ::rtl::OUString sError; - ::std::auto_ptr< OSQLParseNode > pSubQueryNode( rParam.pParser->parseTree( sError, sCommand, sal_False ) ); - if ( pSubQueryNode.get() ) - { - // parse the sub-select to SDBC level, too - ::rtl::OUStringBuffer sSubSelect; - pSubQueryNode->impl_parseNodeToString_throw( sSubSelect, rParam ); - if ( sSubSelect.getLength() ) - sCommand = sSubSelect.makeStringAndClear(); - } - } - - 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.appendAscii( " AS " ); - if ( rParam.bQuote ) - rString.append(SetQuotation( sTableOrQueryName, - rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); - } - - // don't forget to remove the query name from the history, else multiple inclusions - // won't work - // #i69227# / 2006-10-10 / frank.schoenheit@sun.com - rParam.pSubQueryHistory->erase( sTableOrQueryName ); - - return true; - } - catch( const SQLException& ) - { - throw; - } - catch( const Exception& ) - { - DBG_UNHANDLED_EXCEPTION(); - } - return false; -} - -//----------------------------------------------------------------------------- -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(RTL_CONSTASCII_USTRINGPARAM(" ")); - ::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::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::impl_parseLikeNodeToString_throw" ); - OSL_ENSURE(count() == 2,"count != 2: Prepare for GPF"); - - const OSQLParseNode* pEscNode = NULL; - const OSQLParseNode* pParaNode = NULL; - - SQLParseNodeParameter aNewParam(rParam); - //aNewParam.bQuote = sal_True; // why setting this to true? @see http://www.openoffice.org/issues/show_bug.cgi?id=75557 - - // if there is a field given we don't display the fieldname, if there are any - sal_Bool bAddName = sal_True; - if (rParam.xField.is()) - { - // retrieve the fields name - ::rtl::OUString aFieldName; - try - { - // retrieve the fields name - rtl::OUString aString; - rParam.xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aString; - aFieldName = aString.getStr(); - } - catch ( Exception& ) - { - OSL_FAIL( "OSQLParseNode::impl_parseLikeNodeToString_throw Exception occurred!" ); - } - if ( !m_aChildren[0]->isLeaf() ) - { - 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; - } - } - - if (bAddName) - m_aChildren[0]->impl_parseNodeToString_throw( rString, aNewParam ); - - const OSQLParseNode* pPart2 = m_aChildren[1]; - pPart2->getChild(0)->impl_parseNodeToString_throw( rString, aNewParam ); - pPart2->getChild(1)->impl_parseNodeToString_throw( rString, aNewParam ); - pParaNode = pPart2->getChild(2); - pEscNode = pPart2->getChild(3); - - if (pParaNode->isToken()) - { - ::rtl::OUString aStr = ConvertLikeToken(pParaNode, pEscNode, rParam.bInternational); - rString.appendAscii(" "); - rString.append(SetQuotation(aStr,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\'")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\'\'")))); - } - else - pParaNode->impl_parseNodeToString_throw( rString, aNewParam ); - - pEscNode->impl_parseNodeToString_throw( rString, aNewParam ); -} - - -// ----------------------------------------------------------------------------- -sal_Bool OSQLParseNode::getTableComponents(const OSQLParseNode* _pTableNode, - ::com::sun::star::uno::Any &_rCatalog, - ::rtl::OUString &_rSchema, - ::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(); - _rSchema = _rTable = ::rtl::OUString(); - // see rule catalog_name: in sqlbison.y - if (SQL_ISRULE(pTableNode,catalog_name)) - { - OSL_ENSURE(pTableNode->getChild(0) && pTableNode->getChild(0)->isToken(),"Invalid parsenode!"); - _rCatalog <<= pTableNode->getChild(0)->getTokenValue(); - pTableNode = pTableNode->getChild(2); - } - // check if we have schema_name rule - if(SQL_ISRULE(pTableNode,schema_name)) - { - 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 - if(SQL_ISRULE(pTableNode,table_name)) - { - _rTable = pTableNode->getChild(0)->getTokenValue(); - } - else - { - OSL_FAIL("Error in parse tree!"); - } - } - return _rTable.getLength() != 0; -} -// ----------------------------------------------------------------------------- -void OSQLParser::killThousandSeparator(OSQLParseNode* pLiteral) -{ - if ( pLiteral ) - { - if ( s_xLocaleData->getLocaleItem( m_pData->aLocale ).decimalSeparator.toChar() == ',' ) - { - pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace('.', sal_Unicode()); - // and replace decimal - pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace(',', '.'); - } - else - pLiteral->m_aNodeValue = pLiteral->m_aNodeValue.replace(',', sal_Unicode()); - } -} -// ----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral) -{ - if ( !pLiteral ) - return NULL; - - OSQLParseNode* pReturn = pLiteral; - - if ( ( pLiteral->isRule() && !SQL_ISRULE(pLiteral,value_exp) ) || SQL_ISTOKEN(pLiteral,FALSE) || SQL_ISTOKEN(pLiteral,TRUE) ) - { - switch(nType) - { - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - if ( !SQL_ISRULE(pReturn,char_value_exp) && !buildStringNodes(pReturn) ) - pReturn = NULL; - default: - break; - } - } - else - { - switch(pLiteral->getNodeType()) - { - case SQL_NODE_STRING: - switch(nType) - { - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - break; - case DataType::DATE: - case DataType::TIME: - case DataType::TIMESTAMP: - if (m_xFormatter.is()) - pReturn = buildDate( nType, pReturn); - break; - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); - break; - } - break; - case SQL_NODE_ACCESS_DATE: - switch(nType) - { - case DataType::DATE: - case DataType::TIME: - case DataType::TIMESTAMP: - if ( m_xFormatter.is() ) - pReturn = buildDate( nType, pReturn); - else - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_DATE_COMPARE); - break; - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); - break; - } - break; - case SQL_NODE_INTNUM: - switch(nType) - { - case DataType::BIT: - case DataType::BOOLEAN: - case DataType::DECIMAL: - case DataType::NUMERIC: - case DataType::TINYINT: - case DataType::SMALLINT: - case DataType::INTEGER: - case DataType::BIGINT: - case DataType::FLOAT: - case DataType::REAL: - case DataType::DOUBLE: - // kill thousand seperators if any - killThousandSeparator(pReturn); - break; - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - pReturn = buildNode_STR_NUM(pReturn); - break; - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_INT_COMPARE); - break; - } - break; - case SQL_NODE_APPROXNUM: - switch(nType) - { - case DataType::DECIMAL: - case DataType::NUMERIC: - case DataType::FLOAT: - case DataType::REAL: - case DataType::DOUBLE: - // kill thousand seperators if any - killThousandSeparator(pReturn); - break; - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - pReturn = buildNode_STR_NUM(pReturn); - break; - case DataType::INTEGER: - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_REAL_COMPARE); - break; - } - break; - default: - ; - } - } - return pReturn; -} -// ----------------------------------------------------------------------------- -sal_Int16 OSQLParser::buildPredicateRule(OSQLParseNode*& pAppend,OSQLParseNode* pLiteral,OSQLParseNode*& pCompare,OSQLParseNode* pLiteral2) -{ - OSL_ENSURE(inPredicateCheck(),"Only in predicate check allowed!"); - sal_Int16 nErg = 0; - if ( m_xField.is() ) - { - sal_Int32 nType = 0; - try - { - m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType; - } - catch( Exception& ) - { - return nErg; - } - - OSQLParseNode* pNode1 = convertNode(nType,pLiteral); - if ( pNode1 ) - { - OSQLParseNode* pNode2 = convertNode(nType,pLiteral2); - if ( !m_sErrorMessage.getLength() ) - nErg = buildNode(pAppend,pCompare,pNode1,pNode2); - } - } - if (!pCompare->getParent()) // I have no parent so I was not used and I must die :-) - delete pCompare; - return nErg; -} -// ----------------------------------------------------------------------------- -sal_Int16 OSQLParser::buildLikeRule(OSQLParseNode*& pAppend, OSQLParseNode*& pLiteral, const OSQLParseNode* pEscape) -{ - sal_Int16 nErg = 0; - sal_Int32 nType = 0; - - if (!m_xField.is()) - return nErg; - try - { - Any aValue; - { - aValue = m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)); - aValue >>= nType; - } - } - catch( Exception& ) - { - return nErg; - } - - switch (nType) - { - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - if(pLiteral->isRule()) - { - pAppend->append(pLiteral); - nErg = 1; - } - else - { - switch(pLiteral->getNodeType()) - { - case SQL_NODE_STRING: - pLiteral->m_aNodeValue = ConvertLikeToken(pLiteral, pEscape, sal_False); - pAppend->append(pLiteral); - nErg = 1; - break; - case SQL_NODE_APPROXNUM: - if (m_xFormatter.is() && m_nFormatKey) - { - sal_Int16 nScale = 0; - try - { - Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Decimals")) ); - aValue >>= nScale; - } - catch( Exception& ) - { - } - - pAppend->append(new OSQLInternalNode(stringToDouble(pLiteral->getTokenValue(),nScale),SQL_NODE_STRING)); - } - else - pAppend->append(new OSQLInternalNode(pLiteral->getTokenValue(),SQL_NODE_STRING)); - - delete pLiteral; - nErg = 1; - break; - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_VALUE_NO_LIKE); - m_sErrorMessage = m_sErrorMessage.replaceAt(m_sErrorMessage.indexOf(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("#1"))),2,pLiteral->getTokenValue()); - break; - } - } - break; - default: - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_FIELD_NO_LIKE); - break; - } - return nErg; -} -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::buildNode_Date(const double& fValue, sal_Int32 nType) -{ - ::rtl::OUString aEmptyString; - OSQLParseNode* pNewNode = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::set_fct_spec)); - pNewNode->append(new OSQLInternalNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("{")), SQL_NODE_PUNCTUATION)); - OSQLParseNode* pDateNode = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::odbc_fct_spec)); - pNewNode->append(pDateNode); - pNewNode->append(new OSQLInternalNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("}")), SQL_NODE_PUNCTUATION)); - - switch (nType) - { - case DataType::DATE: - { - Date aDate = DBTypeConversion::toDate(fValue,DBTypeConversion::getNULLDate(m_xFormatter->getNumberFormatsSupplier())); - ::rtl::OUString aString = DBTypeConversion::toDateString(aDate); - pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_D)); - pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); - break; - } - case DataType::TIME: - { - Time aTime = DBTypeConversion::toTime(fValue); - ::rtl::OUString aString = DBTypeConversion::toTimeString(aTime); - pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_T)); - pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); - break; - } - case DataType::TIMESTAMP: - { - DateTime aDateTime = DBTypeConversion::toDateTime(fValue,DBTypeConversion::getNULLDate(m_xFormatter->getNumberFormatsSupplier())); - if (aDateTime.Seconds || aDateTime.Minutes || aDateTime.Hours) - { - ::rtl::OUString aString = DBTypeConversion::toDateTimeString(aDateTime); - pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_TS)); - pDateNode->append(new OSQLInternalNode(aString, SQL_NODE_STRING)); - } - else - { - Date aDate(aDateTime.Day,aDateTime.Month,aDateTime.Year); - pDateNode->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, SQL_TOKEN_D)); - pDateNode->append(new OSQLInternalNode(DBTypeConversion::toDateString(aDate), SQL_NODE_STRING)); - } - break; - } - } - - return pNewNode; -} -// ----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::buildNode_STR_NUM(OSQLParseNode*& _pLiteral) -{ - OSQLParseNode* pReturn = NULL; - if ( _pLiteral ) - { - if (m_nFormatKey) - { - sal_Int16 nScale = 0; - ::rtl::OUString aDec; - try - { - Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Decimals")) ); - aValue >>= nScale; - } - catch( Exception& ) - { - } - - pReturn = new OSQLInternalNode(stringToDouble(_pLiteral->getTokenValue(),nScale),SQL_NODE_STRING); - } - else - pReturn = new OSQLInternalNode(_pLiteral->getTokenValue(),SQL_NODE_STRING); - - delete _pLiteral; - _pLiteral = NULL; - } - return pReturn; -} -// ----------------------------------------------------------------------------- -::rtl::OUString OSQLParser::stringToDouble(const ::rtl::OUString& _rValue,sal_Int16 _nScale) -{ - ::rtl::OUString aValue; - if(!m_xCharClass.is()) - m_xCharClass = Reference<XCharacterClassification>(m_xServiceFactory->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.i18n.CharacterClassification"))),UNO_QUERY); - if(m_xCharClass.is() && s_xLocaleData.is()) - { - try - { - ParseResult aResult = m_xCharClass->parsePredefinedToken(KParseType::ANY_NUMBER,_rValue,0,m_pData->aLocale,0,::rtl::OUString(),KParseType::ANY_NUMBER,::rtl::OUString()); - if((aResult.TokenType & KParseType::IDENTNAME) && aResult.EndPos == _rValue.getLength()) - { - aValue = ::rtl::OUString::valueOf(aResult.Value); - sal_Int32 nPos = aValue.lastIndexOf(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("."))); - if((nPos+_nScale) < aValue.getLength()) - aValue = aValue.replaceAt(nPos+_nScale,aValue.getLength()-nPos-_nScale,::rtl::OUString()); - aValue = aValue.replaceAt(aValue.lastIndexOf(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("."))),1,s_xLocaleData->getLocaleItem(m_pData->aLocale).decimalSeparator); - return aValue; - } - } - catch(Exception&) - { - } - } - return aValue; -} -// ----------------------------------------------------------------------------- - -::osl::Mutex& OSQLParser::getMutex() -{ - static ::osl::Mutex aMutex; - return aMutex; -} - -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const ::rtl::OUString& rStatement, - const Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter, - const Reference< XPropertySet > & xField) -{ - - - // mutex for parsing - static ::osl::Mutex aMutex; - - // Guard the parsing - ::osl::MutexGuard aGuard(getMutex()); - // must be reset - setParser(this); - - - // reset the parser - m_xField = xField; - m_xFormatter = xFormatter; - - if (m_xField.is()) - { - sal_Int32 nType=0; - try - { - // get the field name - rtl::OUString aString; - - // retrieve the fields name - // #75243# use the RealName of the column if there is any otherwise the name which could be the alias - // of the field - Reference< XPropertySetInfo> xInfo = m_xField->getPropertySetInfo(); - if ( xInfo->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME))) - m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME)) >>= aString; - else - m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aString; - - m_sFieldName = aString; - - // get the field format key - if ( xInfo->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY))) - m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY)) >>= m_nFormatKey; - else - m_nFormatKey = 0; - - // get the field type - m_xField->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType; - } - catch ( Exception& ) - { - OSL_ASSERT(0); - } - - if (m_nFormatKey && m_xFormatter.is()) - { - Any aValue = getNumberFormatProperty( m_xFormatter, m_nFormatKey, OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_LOCALE) ); - OSL_ENSURE(aValue.getValueType() == ::getCppuType((const ::com::sun::star::lang::Locale*)0), "OSQLParser::PredicateTree : invalid language property !"); - - if (aValue.getValueType() == ::getCppuType((const ::com::sun::star::lang::Locale*)0)) - aValue >>= m_pData->aLocale; - } - else - m_pData->aLocale = m_pContext->getPreferredLocale(); - - if ( m_xFormatter.is() ) - { - try - { - Reference< ::com::sun::star::util::XNumberFormatsSupplier > xFormatSup = m_xFormatter->getNumberFormatsSupplier(); - if ( xFormatSup.is() ) - { - Reference< ::com::sun::star::util::XNumberFormats > xFormats = xFormatSup->getNumberFormats(); - if ( xFormats.is() ) - { - ::com::sun::star::lang::Locale aLocale; - aLocale.Language = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("en")); - aLocale.Country = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("US")); - ::rtl::OUString sFormat(RTL_CONSTASCII_USTRINGPARAM("YYYY-MM-DD")); - m_nDateFormatKey = xFormats->queryKey(sFormat,aLocale,sal_False); - if ( m_nDateFormatKey == sal_Int32(-1) ) - m_nDateFormatKey = xFormats->addNew(sFormat, aLocale); - } - } - } - catch ( Exception& ) - { - OSL_FAIL("DateFormatKey"); - } - } - - switch (nType) - { - case DataType::DATE: - case DataType::TIME: - case DataType::TIMESTAMP: - s_pScanner->SetRule(s_pScanner->GetDATERule()); - break; - case DataType::CHAR: - case DataType::VARCHAR: - case DataType::LONGVARCHAR: - case DataType::CLOB: - s_pScanner->SetRule(s_pScanner->GetSTRINGRule()); - break; - default: - if ( s_xLocaleData->getLocaleItem( m_pData->aLocale ).decimalSeparator.toChar() == ',' ) - s_pScanner->SetRule(s_pScanner->GetGERRule()); - else - s_pScanner->SetRule(s_pScanner->GetENGRule()); - } - - } - else - s_pScanner->SetRule(s_pScanner->GetSQLRule()); - - s_pScanner->prepareScan(rStatement, m_pContext, sal_True); - - SQLyylval.pParseNode = NULL; - // SQLyypvt = NULL; - m_pParseTree = NULL; - m_sErrorMessage= ::rtl::OUString(); - - // ... und den Parser anwerfen ... - if (SQLyyparse() != 0) - { - m_sFieldName= ::rtl::OUString(); - m_xField.clear(); - m_xFormatter.clear(); - m_nFormatKey = 0; - m_nDateFormatKey = 0; - - if (!m_sErrorMessage.getLength()) - m_sErrorMessage = s_pScanner->getErrorMessage(); - if (!m_sErrorMessage.getLength()) - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_GENERAL); - - rErrorMessage = m_sErrorMessage; - - // clear the garbage collector - (*s_pGarbageCollector)->clearAndDelete(); - return NULL; - } - else - { - (*s_pGarbageCollector)->clear(); - - m_sFieldName= ::rtl::OUString(); - m_xField.clear(); - m_xFormatter.clear(); - m_nFormatKey = 0; - m_nDateFormatKey = 0; - - // Das Ergebnis liefern (den Root Parse Node): - - // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree - // - einfach diesen zurueckliefern: - OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert"); - return m_pParseTree; - } -} - -//============================================================================= -//----------------------------------------------------------------------------- -OSQLParser::OSQLParser(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _xServiceFactory,const IParseContext* _pContext) - :m_pContext(_pContext) - ,m_pParseTree(NULL) - ,m_pData( new OSQLParser_Data( _xServiceFactory ) ) - ,m_nFormatKey(0) - ,m_nDateFormatKey(0) - ,m_xServiceFactory(_xServiceFactory) -{ - - - setParser(this); - -#ifdef SQLYYDEBUG -#ifdef SQLYYDEBUG_ON - SQLyydebug = 1; -#endif -#endif - - ::osl::MutexGuard aGuard(getMutex()); - // do we have to initialize the data - if (s_nRefCount == 0) - { - s_pScanner = new OSQLScanner(); - s_pScanner->setScanner(); - s_pGarbageCollector = new OSQLParseNodesGarbageCollector(); - - if(!s_xLocaleData.is()) - s_xLocaleData = Reference<XLocaleData>(m_xServiceFactory->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.i18n.LocaleData"))),UNO_QUERY); - - // auf 0 zuruecksetzen - memset(OSQLParser::s_nRuleIDs,0,sizeof(OSQLParser::s_nRuleIDs[0]) * (OSQLParseNode::rule_count+1)); - - struct - { - OSQLParseNode::Rule eRule; // the parse node's ID for the rule - ::rtl::OString sRuleName; // the name of the rule ("select_statement") - } aRuleDescriptions[] = - { - { OSQLParseNode::select_statement, "select_statement" }, - { OSQLParseNode::table_exp, "table_exp" }, - { OSQLParseNode::table_ref_commalist, "table_ref_commalist" }, - { OSQLParseNode::table_ref, "table_ref" }, - { OSQLParseNode::catalog_name, "catalog_name" }, - { OSQLParseNode::schema_name, "schema_name" }, - { OSQLParseNode::table_name, "table_name" }, - { OSQLParseNode::opt_column_commalist, "opt_column_commalist" }, - { OSQLParseNode::column_commalist, "column_commalist" }, - { OSQLParseNode::column_ref_commalist, "column_ref_commalist" }, - { OSQLParseNode::column_ref, "column_ref" }, - { OSQLParseNode::opt_order_by_clause, "opt_order_by_clause" }, - { OSQLParseNode::ordering_spec_commalist, "ordering_spec_commalist" }, - { OSQLParseNode::ordering_spec, "ordering_spec" }, - { OSQLParseNode::opt_asc_desc, "opt_asc_desc" }, - { OSQLParseNode::where_clause, "where_clause" }, - { OSQLParseNode::opt_where_clause, "opt_where_clause" }, - { OSQLParseNode::search_condition, "search_condition" }, - { OSQLParseNode::comparison_predicate, "comparison_predicate" }, - { OSQLParseNode::between_predicate, "between_predicate" }, - { OSQLParseNode::like_predicate, "like_predicate" }, - { OSQLParseNode::opt_escape, "opt_escape" }, - { OSQLParseNode::test_for_null, "test_for_null" }, - { OSQLParseNode::scalar_exp_commalist, "scalar_exp_commalist" }, - { OSQLParseNode::scalar_exp, "scalar_exp" }, - { OSQLParseNode::parameter_ref, "parameter_ref" }, - { OSQLParseNode::parameter, "parameter" }, - { OSQLParseNode::general_set_fct, "general_set_fct" }, - { OSQLParseNode::range_variable, "range_variable" }, - { OSQLParseNode::column, "column" }, - { OSQLParseNode::delete_statement_positioned, "delete_statement_positioned" }, - { OSQLParseNode::delete_statement_searched, "delete_statement_searched" }, - { OSQLParseNode::update_statement_positioned, "update_statement_positioned" }, - { OSQLParseNode::update_statement_searched, "update_statement_searched" }, - { OSQLParseNode::assignment_commalist, "assignment_commalist" }, - { OSQLParseNode::assignment, "assignment" }, - { OSQLParseNode::values_or_query_spec, "values_or_query_spec" }, - { OSQLParseNode::insert_statement, "insert_statement" }, - { OSQLParseNode::insert_atom_commalist, "insert_atom_commalist" }, - { OSQLParseNode::insert_atom, "insert_atom" }, - { OSQLParseNode::predicate_check, "predicate_check" }, - { OSQLParseNode::from_clause, "from_clause" }, - { OSQLParseNode::qualified_join, "qualified_join" }, - { OSQLParseNode::cross_union, "cross_union" }, - { OSQLParseNode::select_sublist, "select_sublist" }, - { OSQLParseNode::derived_column, "derived_column" }, - { OSQLParseNode::column_val, "column_val" }, - { OSQLParseNode::set_fct_spec, "set_fct_spec" }, - { OSQLParseNode::boolean_term, "boolean_term" }, - { OSQLParseNode::boolean_primary, "boolean_primary" }, - { OSQLParseNode::num_value_exp, "num_value_exp" }, - { OSQLParseNode::join_type, "join_type" }, - { OSQLParseNode::position_exp, "position_exp" }, - { OSQLParseNode::extract_exp, "extract_exp" }, - { OSQLParseNode::length_exp, "length_exp" }, - { OSQLParseNode::char_value_fct, "char_value_fct" }, - { OSQLParseNode::odbc_call_spec, "odbc_call_spec" }, - { OSQLParseNode::in_predicate, "in_predicate" }, - { OSQLParseNode::existence_test, "existence_test" }, - { OSQLParseNode::unique_test, "unique_test" }, - { OSQLParseNode::all_or_any_predicate, "all_or_any_predicate" }, - { OSQLParseNode::named_columns_join, "named_columns_join" }, - { OSQLParseNode::join_condition, "join_condition" }, - { OSQLParseNode::joined_table, "joined_table" }, - { OSQLParseNode::boolean_factor, "boolean_factor" }, - { OSQLParseNode::sql_not, "sql_not" }, - { OSQLParseNode::boolean_test, "boolean_test" }, - { OSQLParseNode::manipulative_statement, "manipulative_statement" }, - { OSQLParseNode::subquery, "subquery" }, - { OSQLParseNode::value_exp_commalist, "value_exp_commalist" }, - { OSQLParseNode::odbc_fct_spec, "odbc_fct_spec" }, - { OSQLParseNode::union_statement, "union_statement" }, - { OSQLParseNode::outer_join_type, "outer_join_type" }, - { OSQLParseNode::char_value_exp, "char_value_exp" }, - { OSQLParseNode::term, "term" }, - { OSQLParseNode::value_exp_primary, "value_exp_primary" }, - { OSQLParseNode::value_exp, "value_exp" }, - { OSQLParseNode::selection, "selection" }, - { OSQLParseNode::fold, "fold" }, - { OSQLParseNode::char_substring_fct, "char_substring_fct" }, - { OSQLParseNode::factor, "factor" }, - { OSQLParseNode::base_table_def, "base_table_def" }, - { OSQLParseNode::base_table_element_commalist, "base_table_element_commalist" }, - { OSQLParseNode::data_type, "data_type" }, - { OSQLParseNode::column_def, "column_def" }, - { OSQLParseNode::table_node, "table_node" }, - { OSQLParseNode::as, "as" }, - { OSQLParseNode::op_column_commalist, "op_column_commalist" }, - { OSQLParseNode::table_primary_as_range_column, "table_primary_as_range_column" }, - { OSQLParseNode::datetime_primary, "datetime_primary" }, - { OSQLParseNode::concatenation, "concatenation" }, - { OSQLParseNode::char_factor, "char_factor" }, - { OSQLParseNode::bit_value_fct, "bit_value_fct" }, - { OSQLParseNode::comparison_predicate_part_2, "comparison_predicate_part_2" }, - { OSQLParseNode::parenthesized_boolean_value_expression, "parenthesized_boolean_value_expression" }, - { OSQLParseNode::character_string_type, "character_string_type" }, - { OSQLParseNode::other_like_predicate_part_2, "other_like_predicate_part_2" }, - { OSQLParseNode::between_predicate_part_2, "between_predicate_part_2" }, - { OSQLParseNode::cast_spec, "cast_spec" } - }; - size_t nRuleMapCount = SAL_N_ELEMENTS( aRuleDescriptions ); - OSL_ENSURE( nRuleMapCount == size_t( OSQLParseNode::rule_count ), "OSQLParser::OSQLParser: added a new rule? Adjust this map!" ); - - for ( size_t mapEntry = 0; mapEntry < nRuleMapCount; ++mapEntry ) - { - // look up the rule description in the our identifier map - sal_uInt32 nParserRuleID = StrToRuleID( aRuleDescriptions[ mapEntry ].sRuleName ); - // map the parser's rule ID to the OSQLParseNode::Rule - s_aReverseRuleIDLookup[ nParserRuleID ] = aRuleDescriptions[ mapEntry ].eRule; - // and map the OSQLParseNode::Rule to the parser's rule ID - s_nRuleIDs[ aRuleDescriptions[ mapEntry ].eRule ] = nParserRuleID; - } - } - ++s_nRefCount; - - if (m_pContext == NULL) - // take the default context - m_pContext = &s_aDefaultContext; - - m_pData->aLocale = m_pContext->getPreferredLocale(); -} - -//----------------------------------------------------------------------------- -OSQLParser::~OSQLParser() -{ - { - ::osl::MutexGuard aGuard(getMutex()); - OSL_ENSURE(s_nRefCount > 0, "OSQLParser::~OSQLParser() : suspicious call : have a refcount of 0 !"); - if (!--s_nRefCount) - { - s_pScanner->setScanner(sal_True); - delete s_pScanner; - s_pScanner = NULL; - - delete s_pGarbageCollector; - s_pGarbageCollector = NULL; - // is only set the first time so we should delete it only when there no more instances - s_xLocaleData = NULL; - - RuleIDMap aEmpty; - s_aReverseRuleIDLookup.swap( aEmpty ); - } - m_pParseTree = NULL; - } -} -// ----------------------------------------------------------------------------- -void OSQLParseNode::substituteParameterNames(OSQLParseNode* _pNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::substituteParameterNames" ); - sal_Int32 nCount = _pNode->count(); - for(sal_Int32 i=0;i < nCount;++i) - { - OSQLParseNode* pChildNode = _pNode->getChild(i); - if(SQL_ISRULE(pChildNode,parameter) && pChildNode->count() > 1) - { - OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("?")) ,SQL_NODE_PUNCTUATION,0); - delete pChildNode->replace(pChildNode->getChild(0),pNewNode); - sal_Int32 nChildCount = pChildNode->count(); - for(sal_Int32 j=1;j < nChildCount;++j) - delete pChildNode->removeAt(1); - } - else - substituteParameterNames(pChildNode); - - } -} -// ----------------------------------------------------------------------------- -bool OSQLParser::extractDate(OSQLParseNode* pLiteral,double& _rfValue) -{ - Reference< XNumberFormatsSupplier > xFormatSup = m_xFormatter->getNumberFormatsSupplier(); - Reference< XNumberFormatTypes > xFormatTypes; - if ( xFormatSup.is() ) - xFormatTypes = xFormatTypes.query( xFormatSup->getNumberFormats() ); - - // if there is no format key, yet, make sure we have a feasible one for our locale - try - { - if ( !m_nFormatKey && xFormatTypes.is() ) - m_nFormatKey = ::dbtools::getDefaultNumberFormat( m_xField, xFormatTypes, m_pData->aLocale ); - } - catch( Exception& ) { } - ::rtl::OUString sValue = pLiteral->getTokenValue(); - sal_Int32 nTryFormat = m_nFormatKey; - bool bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); - - // If our format key didn't do, try the default date format for our locale. - if ( !bSuccess && xFormatTypes.is() ) - { - try - { - nTryFormat = xFormatTypes->getStandardFormat( NumberFormat::DATE, m_pData->aLocale ); - } - catch( Exception& ) { } - bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); - } - - // if this also didn't do, try ISO format - if ( !bSuccess && xFormatTypes.is() ) - { - try - { - nTryFormat = xFormatTypes->getFormatIndex( NumberFormatIndex::DATE_DIN_YYYYMMDD, m_pData->aLocale ); - } - catch( Exception& ) { } - bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); - } - - // if this also didn't do, try fallback date format (en-US) - if ( !bSuccess ) - { - nTryFormat = m_nDateFormatKey; - bSuccess = lcl_saveConvertToNumber( m_xFormatter, nTryFormat, sValue, _rfValue ); - } - return bSuccess; -} -// ----------------------------------------------------------------------------- -OSQLParseNode* OSQLParser::buildDate(sal_Int32 _nType,OSQLParseNode*& pLiteral) -{ - // try converting the string into a date, according to our format key - double fValue = 0.0; - OSQLParseNode* pFCTNode = NULL; - - if ( extractDate(pLiteral,fValue) ) - pFCTNode = buildNode_Date( fValue, _nType); - - delete pLiteral; - pLiteral = NULL; - - if ( !pFCTNode ) - m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_DATE_COMPARE); - - return pFCTNode; -} -// ----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -OSQLParseNode::OSQLParseNode(const sal_Char * pNewValue, - SQLNodeType eNewNodeType, - sal_uInt32 nNewNodeID) - :m_pParent(NULL) - ,m_aNodeValue(pNewValue,strlen(pNewValue),RTL_TEXTENCODING_UTF8) - ,m_eNodeType(eNewNodeType) - ,m_nNodeID(nNewNodeID) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); - - OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); -} -//----------------------------------------------------------------------------- -OSQLParseNode::OSQLParseNode(const ::rtl::OString &_rNewValue, - SQLNodeType eNewNodeType, - sal_uInt32 nNewNodeID) - :m_pParent(NULL) - ,m_aNodeValue(rtl::OStringToOUString(_rNewValue,RTL_TEXTENCODING_UTF8)) - ,m_eNodeType(eNewNodeType) - ,m_nNodeID(nNewNodeID) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); - - OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); -} -//----------------------------------------------------------------------------- -OSQLParseNode::OSQLParseNode(const sal_Unicode * pNewValue, - SQLNodeType eNewNodeType, - sal_uInt32 nNewNodeID) - :m_pParent(NULL) - ,m_aNodeValue(pNewValue) - ,m_eNodeType(eNewNodeType) - ,m_nNodeID(nNewNodeID) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); - - OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); -} -//----------------------------------------------------------------------------- -OSQLParseNode::OSQLParseNode(const ::rtl::OUString &_rNewValue, - SQLNodeType eNewNodeType, - sal_uInt32 nNewNodeID) - :m_pParent(NULL) - ,m_aNodeValue(_rNewValue) - ,m_eNodeType(eNewNodeType) - ,m_nNodeID(nNewNodeID) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); - - OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert"); -} -//----------------------------------------------------------------------------- -OSQLParseNode::OSQLParseNode(const OSQLParseNode& rParseNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::OSQLParseNode" ); - - // klemm den getParent auf NULL - m_pParent = NULL; - - // kopiere die member - m_aNodeValue = rParseNode.m_aNodeValue; - m_eNodeType = rParseNode.m_eNodeType; - m_nNodeID = rParseNode.m_nNodeID; - - - // denk dran, dass von Container abgeleitet wurde, laut SV-Help erzeugt - // copy-Constructor des Containers einen neuen Container mit den gleichen - // Zeigern als Inhalt -> d.h. nach dem Kopieren des Container wird fuer - // alle Zeiger ungleich NULL eine Kopie hergestellt und anstelle des alten - // Zeigers wieder eingehangen. - - // wenn kein Blatt, dann SubTrees bearbeiten - for (OSQLParseNodes::const_iterator i = rParseNode.m_aChildren.begin(); - i != rParseNode.m_aChildren.end(); ++i) - append(new OSQLParseNode(**i)); -} -// ----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -OSQLParseNode& OSQLParseNode::operator=(const OSQLParseNode& rParseNode) -{ - if (this != &rParseNode) - { - // kopiere die member - pParent bleibt der alte - m_aNodeValue = rParseNode.m_aNodeValue; - m_eNodeType = rParseNode.m_eNodeType; - m_nNodeID = rParseNode.m_nNodeID; - - for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); - i != m_aChildren.end(); ++i) - delete *i; - - m_aChildren.clear(); - - for (OSQLParseNodes::const_iterator j = rParseNode.m_aChildren.begin(); - j != rParseNode.m_aChildren.end(); ++j) - append(new OSQLParseNode(**j)); - } - return *this; -} - -//----------------------------------------------------------------------------- -sal_Bool OSQLParseNode::operator==(OSQLParseNode& rParseNode) const -{ - // die member muessen gleich sein - sal_Bool bResult = (m_nNodeID == rParseNode.m_nNodeID) && - (m_eNodeType == rParseNode.m_eNodeType) && - (m_aNodeValue == rParseNode.m_aNodeValue) && - count() == rParseNode.count(); - - // Parameters are not equal! - bResult = bResult && !SQL_ISRULE(this, parameter); - - // compare childs - for (sal_uInt32 i=0; bResult && i < count(); i++) - bResult = *getChild(i) == *rParseNode.getChild(i); - - return bResult; -} - -//----------------------------------------------------------------------------- -OSQLParseNode::~OSQLParseNode() -{ - for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); - i != m_aChildren.end(); ++i) - delete *i; - m_aChildren.clear(); -} - -//----------------------------------------------------------------------------- -void OSQLParseNode::append(OSQLParseNode* pNewNode) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::append" ); - - OSL_ENSURE(pNewNode != NULL, "OSQLParseNode: ungueltiger NewSubTree"); - OSL_ENSURE(pNewNode->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise"); - 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_aChildren.push_back(pNewNode); -} -// ----------------------------------------------------------------------------- -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_aChildren[0],"{")) - { - const OSQLParseNode* pODBCNode = m_aChildren[1]; - const OSQLParseNode* pODBCNodeChild = pODBCNode->m_aChildren[0]; - - if (pODBCNodeChild->getNodeType() == SQL_NODE_KEYWORD && ( - SQL_ISTOKEN(pODBCNodeChild, D) || - SQL_ISTOKEN(pODBCNodeChild, T) || - SQL_ISTOKEN(pODBCNodeChild, TS) )) - { - ::rtl::OUString suQuote(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("'"))); - if (rParam.bPredicate) - { - if (rParam.aMetaData.shouldEscapeDateTime()) - { - suQuote = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("#")); - } - } - else - { - if (rParam.aMetaData.shouldEscapeDateTime()) - { - // suQuote = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("'")); - return sal_False; - } - } - - if (rString.getLength()) - rString.appendAscii(" "); - rString.append(suQuote); - const ::rtl::OUString sTokenValue = pODBCNode->m_aChildren[1]->getTokenValue(); - if (SQL_ISTOKEN(pODBCNodeChild, D)) - { - rString.append(rParam.bPredicate ? convertDateString(rParam, sTokenValue) : sTokenValue); - } - else if (SQL_ISTOKEN(pODBCNodeChild, T)) - { - rString.append(rParam.bPredicate ? convertTimeString(rParam, sTokenValue) : sTokenValue); - } - else - { - rString.append(rParam.bPredicate ? convertDateTimeString(rParam, sTokenValue) : sTokenValue); - } - rString.append(suQuote); - return sal_True; - } - } - return sal_False; -} -// ----------------------------------------------------------------------------- -void OSQLParseNode::replaceNodeValue(const ::rtl::OUString& rTableAlias,const ::rtl::OUString& rColumnName) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::replaceNodeValue" ); - for (sal_uInt32 i=0;i<count();++i) - { - if (SQL_ISRULE(this,column_ref) && count() == 1 && getChild(0)->getTokenValue() == rColumnName) - { - OSQLParseNode * pCol = removeAt((sal_uInt32)0); - append(new OSQLParseNode(rTableAlias,SQL_NODE_NAME)); - append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".")),SQL_NODE_PUNCTUATION)); - append(pCol); - } - else - getChild(i)->replaceNodeValue(rTableAlias,rColumnName); - } -} -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParseNode::getByRule(OSQLParseNode::Rule eRule) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getByRule" ); - OSQLParseNode* pRetNode = 0; - if (isRule() && OSQLParser::RuleID(eRule) == getRuleID()) - pRetNode = (OSQLParseNode*)this; - else - { - for (OSQLParseNodes::const_iterator i = m_aChildren.begin(); - !pRetNode && i != m_aChildren.end(); ++i) - pRetNode = (*i)->getByRule(eRule); - } - return pRetNode; -} -//----------------------------------------------------------------------------- -OSQLParseNode* MakeANDNode(OSQLParseNode *pLeftLeaf,OSQLParseNode *pRightLeaf) -{ - OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_term)); - pNewNode->append(pLeftLeaf); - pNewNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AND")),SQL_NODE_KEYWORD,SQL_TOKEN_AND)); - pNewNode->append(pRightLeaf); - return pNewNode; -} -//----------------------------------------------------------------------------- -OSQLParseNode* MakeORNode(OSQLParseNode *pLeftLeaf,OSQLParseNode *pRightLeaf) -{ - OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::search_condition)); - pNewNode->append(pLeftLeaf); - pNewNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OR")),SQL_NODE_KEYWORD,SQL_TOKEN_OR)); - pNewNode->append(pRightLeaf); - return pNewNode; -} -//----------------------------------------------------------------------------- -void OSQLParseNode::disjunctiveNormalForm(OSQLParseNode*& pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::disjunctiveNormalForm" ); - if(!pSearchCondition) // no where condition at entry point - return; - - OSQLParseNode::absorptions(pSearchCondition); - // '(' search_condition ')' - if (SQL_ISRULE(pSearchCondition,boolean_primary)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(1); - disjunctiveNormalForm(pLeft); - } - // search_condition SQL_TOKEN_OR boolean_term - else if (SQL_ISRULE(pSearchCondition,search_condition)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - disjunctiveNormalForm(pLeft); - - OSQLParseNode* pRight = pSearchCondition->getChild(2); - disjunctiveNormalForm(pRight); - } - // boolean_term SQL_TOKEN_AND boolean_factor - else if (SQL_ISRULE(pSearchCondition,boolean_term)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - disjunctiveNormalForm(pLeft); - - OSQLParseNode* pRight = pSearchCondition->getChild(2); - disjunctiveNormalForm(pRight); - - OSQLParseNode* pNewNode = NULL; - // '(' search_condition ')' on left side - if(pLeft->count() == 3 && SQL_ISRULE(pLeft,boolean_primary) && SQL_ISRULE(pLeft->getChild(1),search_condition)) - { - // and-or tree on left side - OSQLParseNode* pOr = pLeft->getChild(1); - OSQLParseNode* pNewLeft = NULL; - OSQLParseNode* pNewRight = NULL; - - // cut right from parent - pSearchCondition->removeAt(2); - - pNewRight = MakeANDNode(pOr->removeAt(2) ,pRight); - pNewLeft = MakeANDNode(pOr->removeAt((sal_uInt32)0) ,new OSQLParseNode(*pRight)); - pNewNode = MakeORNode(pNewLeft,pNewRight); - // and append new Node - replaceAndReset(pSearchCondition,pNewNode); - - disjunctiveNormalForm(pSearchCondition); - } - else if(pRight->count() == 3 && SQL_ISRULE(pRight,boolean_primary) && SQL_ISRULE(pRight->getChild(1),search_condition)) - { // '(' search_condition ')' on right side - // and-or tree on right side - // a and (b or c) - OSQLParseNode* pOr = pRight->getChild(1); - OSQLParseNode* pNewLeft = NULL; - OSQLParseNode* pNewRight = NULL; - - // cut left from parent - pSearchCondition->removeAt((sal_uInt32)0); - - pNewRight = MakeANDNode(pLeft,pOr->removeAt(2)); - pNewLeft = MakeANDNode(new OSQLParseNode(*pLeft),pOr->removeAt((sal_uInt32)0)); - pNewNode = MakeORNode(pNewLeft,pNewRight); - - // and append new Node - replaceAndReset(pSearchCondition,pNewNode); - disjunctiveNormalForm(pSearchCondition); - } - else if(SQL_ISRULE(pLeft,boolean_primary) && (!SQL_ISRULE(pLeft->getChild(1),search_condition) || !SQL_ISRULE(pLeft->getChild(1),boolean_term))) - pSearchCondition->replace(pLeft, pLeft->removeAt(1)); - else if(SQL_ISRULE(pRight,boolean_primary) && (!SQL_ISRULE(pRight->getChild(1),search_condition) || !SQL_ISRULE(pRight->getChild(1),boolean_term))) - pSearchCondition->replace(pRight, pRight->removeAt(1)); - } -} -//----------------------------------------------------------------------------- -void OSQLParseNode::negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_Bool bNegate) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::negateSearchCondition" ); - if(!pSearchCondition) // no where condition at entry point - return; - // '(' search_condition ')' - if (pSearchCondition->count() == 3 && SQL_ISRULE(pSearchCondition,boolean_primary)) - { - OSQLParseNode* pRight = pSearchCondition->getChild(1); - negateSearchCondition(pRight,bNegate); - } - // search_condition SQL_TOKEN_OR boolean_term - else if (SQL_ISRULE(pSearchCondition,search_condition)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - OSQLParseNode* pRight = pSearchCondition->getChild(2); - if(bNegate) - { - OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_term)); - pNewNode->append(pSearchCondition->removeAt((sal_uInt32)0)); - pNewNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AND")),SQL_NODE_KEYWORD,SQL_TOKEN_AND)); - pNewNode->append(pSearchCondition->removeAt((sal_uInt32)1)); - replaceAndReset(pSearchCondition,pNewNode); - - pLeft = pNewNode->getChild(0); - pRight = pNewNode->getChild(2); - } - - negateSearchCondition(pLeft,bNegate); - negateSearchCondition(pRight,bNegate); - } - // boolean_term SQL_TOKEN_AND boolean_factor - else if (SQL_ISRULE(pSearchCondition,boolean_term)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - OSQLParseNode* pRight = pSearchCondition->getChild(2); - if(bNegate) - { - OSQLParseNode* pNewNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::search_condition)); - pNewNode->append(pSearchCondition->removeAt((sal_uInt32)0)); - pNewNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OR")),SQL_NODE_KEYWORD,SQL_TOKEN_OR)); - pNewNode->append(pSearchCondition->removeAt((sal_uInt32)1)); - replaceAndReset(pSearchCondition,pNewNode); - - pLeft = pNewNode->getChild(0); - pRight = pNewNode->getChild(2); - } - - negateSearchCondition(pLeft,bNegate); - negateSearchCondition(pRight,bNegate); - } - // SQL_TOKEN_NOT ( boolean_test ) - else if (SQL_ISRULE(pSearchCondition,boolean_factor)) - { - OSQLParseNode *pNot = pSearchCondition->removeAt((sal_uInt32)0); - delete pNot; - OSQLParseNode *pBooleanTest = pSearchCondition->removeAt((sal_uInt32)0); - // TODO is this needed // pBooleanTest->setParent(NULL); - replaceAndReset(pSearchCondition,pBooleanTest); - - if (!bNegate) - negateSearchCondition(pSearchCondition,sal_True); // negate all deeper values - } - // row_value_constructor comparison row_value_constructor - // row_value_constructor comparison any_all_some subquery - else if(bNegate && (SQL_ISRULE(pSearchCondition,comparison_predicate) || SQL_ISRULE(pSearchCondition,all_or_any_predicate))) - { - OSQLParseNode* pComparison = pSearchCondition->getChild(1); - OSQLParseNode* pNewComparison = NULL; - switch(pComparison->getNodeType()) - { - case SQL_NODE_EQUAL: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<>")),SQL_NODE_NOTEQUAL,SQL_NOTEQUAL); - break; - case SQL_NODE_LESS: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">=")),SQL_NODE_GREATEQ,SQL_GREATEQ); - break; - case SQL_NODE_GREAT: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<=")),SQL_NODE_LESSEQ,SQL_LESSEQ); - break; - case SQL_NODE_LESSEQ: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">")),SQL_NODE_GREAT,SQL_GREAT); - break; - case SQL_NODE_GREATEQ: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<")),SQL_NODE_LESS,SQL_LESS); - break; - case SQL_NODE_NOTEQUAL: - pNewComparison = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")),SQL_NODE_EQUAL,SQL_EQUAL); - break; - default: - OSL_FAIL( "OSQLParseNode::negateSearchCondition: unexpected node type!" ); - break; - } - pSearchCondition->replace(pComparison, pNewComparison); - delete pComparison; - } - - else if(bNegate && (SQL_ISRULE(pSearchCondition,test_for_null) || SQL_ISRULE(pSearchCondition,in_predicate) || - SQL_ISRULE(pSearchCondition,between_predicate) || SQL_ISRULE(pSearchCondition,boolean_test) )) - { - OSQLParseNode* pPart2 = pSearchCondition; - if ( !SQL_ISRULE(pSearchCondition,boolean_test) ) - pPart2 = pSearchCondition->getChild(1); - sal_uInt32 nNotPos = 0; - if ( SQL_ISRULE( pSearchCondition, test_for_null ) ) - nNotPos = 1; - else if ( SQL_ISRULE( pSearchCondition, boolean_test ) ) - nNotPos = 2; - - OSQLParseNode* pNot = pPart2->getChild(nNotPos); - OSQLParseNode* pNotNot = NULL; - if(pNot->isRule()) - pNotNot = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NOT")),SQL_NODE_KEYWORD,SQL_TOKEN_NOT); - else - pNotNot = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::sql_not)); - pPart2->replace(pNot, pNotNot); - delete pNot; - } - else if(bNegate && (SQL_ISRULE(pSearchCondition,like_predicate))) - { - OSQLParseNode* pNot = pSearchCondition->getChild( 1 )->getChild( 0 ); - OSQLParseNode* pNotNot = NULL; - if(pNot->isRule()) - pNotNot = new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NOT")),SQL_NODE_KEYWORD,SQL_TOKEN_NOT); - else - pNotNot = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::sql_not)); - pSearchCondition->getChild( 1 )->replace(pNot, pNotNot); - delete pNot; - } -} -//----------------------------------------------------------------------------- -void OSQLParseNode::eraseBraces(OSQLParseNode*& pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::eraseBraces" ); - if (pSearchCondition && (SQL_ISRULE(pSearchCondition,boolean_primary) || (pSearchCondition->count() == 3 && SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && - SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")")))) - { - OSQLParseNode* pRight = pSearchCondition->getChild(1); - absorptions(pRight); - // if child is not a or or and tree then delete () around child - if(!(SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || SQL_ISRULE(pSearchCondition->getChild(1),search_condition)) || - SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || // and can always stand without () - (SQL_ISRULE(pSearchCondition->getChild(1),search_condition) && SQL_ISRULE(pSearchCondition->getParent(),search_condition))) - { - OSQLParseNode* pNode = pSearchCondition->removeAt(1); - replaceAndReset(pSearchCondition,pNode); - } - } -} -//----------------------------------------------------------------------------- -void OSQLParseNode::absorptions(OSQLParseNode*& pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::absorptions" ); - if(!pSearchCondition) // no where condition at entry point - return; - - eraseBraces(pSearchCondition); - - if(SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - absorptions(pLeft); - OSQLParseNode* pRight = pSearchCondition->getChild(2); - absorptions(pRight); - } - - sal_uInt32 nPos = 0; - // a and a || a or a - OSQLParseNode* pNewNode = NULL; - if(( SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) - && *pSearchCondition->getChild(0) == *pSearchCondition->getChild(2)) - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)0); - replaceAndReset(pSearchCondition,pNewNode); - } - // (a or b) and a || ( b or c ) and a - // a and ( a or b) || a and ( b or c ) - else if ( SQL_ISRULE(pSearchCondition,boolean_term) - && ( - ( SQL_ISRULE(pSearchCondition->getChild(nPos = 0),boolean_primary) - || SQL_ISRULE(pSearchCondition->getChild(nPos),search_condition) - ) - || ( SQL_ISRULE(pSearchCondition->getChild(nPos = 2),boolean_primary) - || SQL_ISRULE(pSearchCondition->getChild(nPos),search_condition) - ) - ) - ) - { - OSQLParseNode* p2ndSearch = pSearchCondition->getChild(nPos); - if ( SQL_ISRULE(p2ndSearch,boolean_primary) ) - p2ndSearch = p2ndSearch->getChild(1); - - if ( *p2ndSearch->getChild(0) == *pSearchCondition->getChild(2-nPos) ) // a and ( a or b) -> a or b - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)0); - replaceAndReset(pSearchCondition,pNewNode); - - } - else if ( *p2ndSearch->getChild(2) == *pSearchCondition->getChild(2-nPos) ) // a and ( b or a) -> a or b - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)2); - replaceAndReset(pSearchCondition,pNewNode); - } - else if ( p2ndSearch->getByRule(OSQLParseNode::search_condition) ) - { - // a and ( b or c ) -> ( a and b ) or ( a and c ) - // ( b or c ) and a -> ( a and b ) or ( a and c ) - OSQLParseNode* pC = p2ndSearch->removeAt((sal_uInt32)2); - OSQLParseNode* pB = p2ndSearch->removeAt((sal_uInt32)0); - OSQLParseNode* pA = pSearchCondition->removeAt((sal_uInt32)2-nPos); - - OSQLParseNode* p1stAnd = MakeANDNode(pA,pB); - OSQLParseNode* p2ndAnd = MakeANDNode(new OSQLParseNode(*pA),pC); - pNewNode = MakeORNode(p1stAnd,p2ndAnd); - OSQLParseNode* pNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); - pNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(")),SQL_NODE_PUNCTUATION)); - pNode->append(pNewNode); - pNode->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")),SQL_NODE_PUNCTUATION)); - OSQLParseNode::eraseBraces(p1stAnd); - OSQLParseNode::eraseBraces(p2ndAnd); - replaceAndReset(pSearchCondition,pNode); - } - } - // a or a and b || a or b and a - else if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(2),boolean_term)) - { - if(*pSearchCondition->getChild(2)->getChild(0) == *pSearchCondition->getChild(0)) - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)0); - replaceAndReset(pSearchCondition,pNewNode); - } - else if(*pSearchCondition->getChild(2)->getChild(2) == *pSearchCondition->getChild(0)) - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)0); - replaceAndReset(pSearchCondition,pNewNode); - } - } - // a and b or a || b and a or a - else if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(0),boolean_term)) - { - if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)) - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)2); - replaceAndReset(pSearchCondition,pNewNode); - } - else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)) - { - pNewNode = pSearchCondition->removeAt((sal_uInt32)2); - replaceAndReset(pSearchCondition,pNewNode); - } - } - eraseBraces(pSearchCondition); -} -//----------------------------------------------------------------------------- -void OSQLParseNode::compress(OSQLParseNode *&pSearchCondition) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::compress" ); - if(!pSearchCondition) // no where condition at entry point - return; - - OSQLParseNode::eraseBraces(pSearchCondition); - - if(SQL_ISRULE(pSearchCondition,boolean_term) || SQL_ISRULE(pSearchCondition,search_condition)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0); - compress(pLeft); - - OSQLParseNode* pRight = pSearchCondition->getChild(2); - compress(pRight); - } - else if( SQL_ISRULE(pSearchCondition,boolean_primary) || (pSearchCondition->count() == 3 && SQL_ISPUNCTUATION(pSearchCondition->getChild(0),"(") && - SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")"))) - { - OSQLParseNode* pRight = pSearchCondition->getChild(1); - compress(pRight); - // if child is not a or or and tree then delete () around child - if(!(SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) || SQL_ISRULE(pSearchCondition->getChild(1),search_condition)) || - (SQL_ISRULE(pSearchCondition->getChild(1),boolean_term) && SQL_ISRULE(pSearchCondition->getParent(),boolean_term)) || - (SQL_ISRULE(pSearchCondition->getChild(1),search_condition) && SQL_ISRULE(pSearchCondition->getParent(),search_condition))) - { - OSQLParseNode* pNode = pSearchCondition->removeAt(1); - replaceAndReset(pSearchCondition,pNode); - } - } - - // or with two and trees where one element of the and trees are equal - if(SQL_ISRULE(pSearchCondition,search_condition) && SQL_ISRULE(pSearchCondition->getChild(0),boolean_term) && SQL_ISRULE(pSearchCondition->getChild(2),boolean_term)) - { - if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)->getChild(0)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt(2); - OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt(2); - OSQLParseNode* pNode = MakeORNode(pLeft,pRight); - - OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(")),SQL_NODE_PUNCTUATION)); - pNewRule->append(pNode); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")),SQL_NODE_PUNCTUATION)); - - OSQLParseNode::eraseBraces(pLeft); - OSQLParseNode::eraseBraces(pRight); - - pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt((sal_uInt32)0),pNewRule); - replaceAndReset(pSearchCondition,pNode); - } - else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)->getChild(0)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt((sal_uInt32)0); - OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt(2); - OSQLParseNode* pNode = MakeORNode(pLeft,pRight); - - OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(")),SQL_NODE_PUNCTUATION)); - pNewRule->append(pNode); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")),SQL_NODE_PUNCTUATION)); - - OSQLParseNode::eraseBraces(pLeft); - OSQLParseNode::eraseBraces(pRight); - - pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt(1),pNewRule); - replaceAndReset(pSearchCondition,pNode); - } - else if(*pSearchCondition->getChild(0)->getChild(0) == *pSearchCondition->getChild(2)->getChild(2)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt(2); - OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt((sal_uInt32)0); - OSQLParseNode* pNode = MakeORNode(pLeft,pRight); - - OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(")),SQL_NODE_PUNCTUATION)); - pNewRule->append(pNode); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")),SQL_NODE_PUNCTUATION)); - - OSQLParseNode::eraseBraces(pLeft); - OSQLParseNode::eraseBraces(pRight); - - pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt((sal_uInt32)0),pNewRule); - replaceAndReset(pSearchCondition,pNode); - } - else if(*pSearchCondition->getChild(0)->getChild(2) == *pSearchCondition->getChild(2)->getChild(2)) - { - OSQLParseNode* pLeft = pSearchCondition->getChild(0)->removeAt((sal_uInt32)0); - OSQLParseNode* pRight = pSearchCondition->getChild(2)->removeAt((sal_uInt32)0); - OSQLParseNode* pNode = MakeORNode(pLeft,pRight); - - OSQLParseNode* pNewRule = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary)); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(")),SQL_NODE_PUNCTUATION)); - pNewRule->append(pNode); - pNewRule->append(new OSQLParseNode(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")),SQL_NODE_PUNCTUATION)); - - OSQLParseNode::eraseBraces(pLeft); - OSQLParseNode::eraseBraces(pRight); - - pNode = MakeANDNode(pSearchCondition->getChild(0)->removeAt(1),pNewRule); - replaceAndReset(pSearchCondition,pNode); - } - } -} -#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::OUStringBuffer& _inout_rBuffer, sal_uInt32 nLevel ) const -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::showParseTree" ); - - for ( sal_uInt32 j=0; j<nLevel; ++j) - _inout_rBuffer.appendAscii( " " ); - - if ( !isToken() ) - { - // Regelnamen als rule: ... - _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_aChildren.begin(); - i != m_aChildren.end(); - ++i - ) - (*i)->showParseTree( _inout_rBuffer, nLevel+1 ); - } - else - { - // ein Token gefunden - switch (m_eNodeType) - { - - case SQL_NODE_KEYWORD: - _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: - _inout_rBuffer.appendAscii( "SQL_COMPARISON: " ); - _inout_rBuffer.append( m_aNodeValue ); - _inout_rBuffer.append( sal_Unicode( '\n' ) ); - break; - - case SQL_NODE_NAME: - _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: - _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: - _inout_rBuffer.appendAscii( "SQL_INTNUM: " ); - _inout_rBuffer.append( m_aNodeValue ); - _inout_rBuffer.append( sal_Unicode( '\n' ) ); - break; - - case SQL_NODE_APPROXNUM: - _inout_rBuffer.appendAscii( "SQL_APPROXNUM: " ); - _inout_rBuffer.append( m_aNodeValue ); - _inout_rBuffer.append( sal_Unicode( '\n' ) ); - break; - - case SQL_NODE_PUNCTUATION: - _inout_rBuffer.appendAscii( "SQL_PUNCTUATION: " ); - _inout_rBuffer.append( m_aNodeValue ); - _inout_rBuffer.append( sal_Unicode( '\n' ) ); - break; - - case SQL_NODE_AMMSC: - _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_TRACE( "-- %i", int( m_eNodeType ) ); - OSL_FAIL( "OSQLParser::ShowParseTree: unzulaessiger NodeType" ); - } - } -} -#endif // OSL_DEBUG_LEVEL > 0 -// ----------------------------------------------------------------------------- -// Insert-Methoden -//----------------------------------------------------------------------------- -void OSQLParseNode::insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::insert" ); - OSL_ENSURE(pNewSubTree != NULL, "OSQLParseNode: ungueltiger NewSubTree"); - OSL_ENSURE(pNewSubTree->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise"); - - // stelle Verbindung zum getParent her: - pNewSubTree->setParent( this ); - m_aChildren.insert(m_aChildren.begin() + nPos, pNewSubTree); -} - -// removeAt-Methoden -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::removeAt" ); - 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_aChildren.erase(aPos); - return pNode; -} -//----------------------------------------------------------------------------- -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_aChildren.begin(), m_aChildren.end(), pSubTree); - if (aPos != m_aChildren.end()) - { - // setze den getParent des removeten auf NULL - pSubTree->setParent( NULL ); - m_aChildren.erase(aPos); - return pSubTree; - } - else - return NULL; -} - -// Replace-Methoden -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParseNode::replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubNode) -{ - 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_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_aChildren[nPos]; - - // stelle Verbindung zum getParent her: - pNewSubNode->setParent( this ); - pOldSubNode->setParent( NULL ); - - m_aChildren[nPos] = pNewSubNode; - return pOldSubNode; -} - -//----------------------------------------------------------------------------- -OSQLParseNode* OSQLParseNode::replace (OSQLParseNode* pOldSubNode, OSQLParseNode* pNewSubNode ) -{ - 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_aChildren.begin(), m_aChildren.end(), pOldSubNode) != m_aChildren.end(), - "OSQLParseNode::Replace() Node not element of parent"); - 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_aChildren.begin(), m_aChildren.end(), pOldSubNode, pNewSubNode); - return pOldSubNode; -} -// ----------------------------------------------------------------------------- -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 - // Inhalt dem Ausgabestring anfuegen - switch (m_eNodeType) - { - case SQL_NODE_KEYWORD: - { - if (rString.getLength()) - rString.appendAscii(" "); - - const ::rtl::OString sT = OSQLParser::TokenIDToStr(m_nNodeID, rParam.bInternational ? &rParam.m_rContext : NULL); - rString.append(::rtl::OStringToOUString(sT,RTL_TEXTENCODING_UTF8)); - } break; - case SQL_NODE_STRING: - if (rString.getLength()) - rString.appendAscii(" "); - rString.append(SetQuotation(m_aNodeValue,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\'")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\'\'")))); - break; - case SQL_NODE_NAME: - if (rString.getLength()) - { - switch(rString.charAt(rString.getLength()-1) ) - { - case ' ' : - case '.' : break; - default : - if ( !rParam.aMetaData.getCatalogSeparator().getLength() - || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() - ) - rString.appendAscii(" "); break; - } - } - if (rParam.bQuote) - { - if (rParam.bPredicate) - { - rString.appendAscii("["); - rString.append(m_aNodeValue); - rString.appendAscii("]"); - } - else - rString.append(SetQuotation(m_aNodeValue, - rParam.aMetaData.getIdentifierQuoteString(), rParam.aMetaData.getIdentifierQuoteString() )); - } - else - rString.append(m_aNodeValue); - break; - case SQL_NODE_ACCESS_DATE: - if (rString.getLength()) - rString.appendAscii(" "); - rString.appendAscii("#"); - rString.append(m_aNodeValue); - rString.appendAscii("#"); - break; - - case SQL_NODE_INTNUM: - case SQL_NODE_APPROXNUM: - { - ::rtl::OUString aTmp = m_aNodeValue; - if (rParam.bInternational && rParam.bPredicate && rParam.cDecSep != '.') - aTmp = aTmp.replace('.', rParam.cDecSep); - - if (rString.getLength()) - rString.appendAscii(" "); - rString.append(aTmp); - - } break; - case SQL_NODE_PUNCTUATION: - if ( getParent() && SQL_ISRULE(getParent(),cast_spec) && m_aNodeValue.toChar() == '(' ) // no spaces in front of '(' - { - rString.append(m_aNodeValue); - break; - } - // fall through - default: - if (rString.getLength() && m_aNodeValue.toChar() != '.' && m_aNodeValue.toChar() != ':' ) - { - switch( rString.charAt(rString.getLength()-1) ) - { - case ' ' : - case '.' : break; - default : - if ( !rParam.aMetaData.getCatalogSeparator().getLength() - || rString.charAt( rString.getLength()-1 ) != rParam.aMetaData.getCatalogSeparator().toChar() - ) - rString.appendAscii(" "); break; - } - } - rString.append(m_aNodeValue); - } -} - -// ----------------------------------------------------------------------------- -sal_Int32 OSQLParser::getFunctionReturnType(const ::rtl::OUString& _sFunctionName, const IParseContext* pContext) -{ - sal_Int32 nType = DataType::VARCHAR; - ::rtl::OString sFunctionName(::rtl::OUStringToOString(_sFunctionName,RTL_TEXTENCODING_UTF8)); - - if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ASCII,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_BIT_LENGTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CHAR,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CHAR_LENGTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CONCAT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DIFFERENCE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_INSERT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LCASE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LEFT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LENGTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOCATE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOCATE_2,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LTRIM,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_OCTET_LENGTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_POSITION,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_REPEAT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_REPLACE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RIGHT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RTRIM,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SOUNDEX,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SPACE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SUBSTRING,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_UCASE,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_DATE,pContext))) nType = DataType::DATE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_TIME,pContext))) nType = DataType::TIME; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURRENT_TIMESTAMP,pContext))) nType = DataType::TIMESTAMP; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURDATE,pContext))) nType = DataType::DATE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DATEDIFF,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DATEVALUE,pContext))) nType = DataType::DATE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CURTIME,pContext))) nType = DataType::TIME; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYNAME,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFMONTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFWEEK,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DAYOFYEAR,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_EXTRACT,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_HOUR,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MINUTE,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MONTH,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MONTHNAME,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_NOW,pContext))) nType = DataType::TIMESTAMP; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_QUARTER,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SECOND,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMESTAMPADD,pContext))) nType = DataType::TIMESTAMP; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMESTAMPDIFF,pContext))) nType = DataType::TIMESTAMP; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TIMEVALUE,pContext))) nType = DataType::TIMESTAMP; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_WEEK,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_YEAR,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ABS,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ACOS,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ASIN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ATAN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ATAN2,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_CEILING,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COS,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COT,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_DEGREES,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_EXP,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_FLOOR,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOGF,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOG,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOG10,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MOD,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_PI,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_POWER,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RADIANS,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_RAND,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ROUND,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_ROUNDMAGIC,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SIGN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SIN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SQRT,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TAN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_TRUNCATE,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_COUNT,pContext))) nType = DataType::INTEGER; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MAX,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_MIN,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_AVG,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_SUM,pContext))) nType = DataType::DOUBLE; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_LOWER,pContext))) nType = DataType::VARCHAR; - else if(sFunctionName.equalsIgnoreAsciiCase(TokenIDToStr(SQL_TOKEN_UPPER,pContext))) nType = DataType::VARCHAR; - - 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 -{ - return m_pData->aErrors; -} - -// ----------------------------------------------------------------------------- -OSQLParseNode::Rule OSQLParseNode::getKnownRuleID() const -{ - if ( !isRule() ) - return UNKNOWN_RULE; - return OSQLParser::RuleIDToRule( getRuleID() ); -} -// ----------------------------------------------------------------------------- -::rtl::OUString OSQLParseNode::getTableRange(const OSQLParseNode* _pTableRef) -{ - RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen@sun.com", "OSQLParseNode::getTableRange" ); - OSL_ENSURE(_pTableRef && _pTableRef->count() > 1 && _pTableRef->getKnownRuleID() == OSQLParseNode::table_ref,"Invalid node give, only table ref is allowed!"); - const sal_uInt32 nCount = _pTableRef->count(); - ::rtl::OUString sTableRange; - if ( nCount == 2 || (nCount == 3 && !_pTableRef->getChild(0)->isToken()) || nCount == 5 ) - { - const OSQLParseNode* pNode = _pTableRef->getChild(nCount - (nCount == 2 ? 1 : 2)); - OSL_ENSURE(pNode && (pNode->getKnownRuleID() == OSQLParseNode::table_primary_as_range_column - || pNode->getKnownRuleID() == OSQLParseNode::range_variable) - ,"SQL grammar changed!"); - if ( !pNode->isLeaf() ) - sTableRange = pNode->getChild(1)->getTokenValue(); - } // if ( nCount == 2 || nCount == 3 || nCount == 5) - - 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 - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/parse/wrap_sqlbison.cxx b/connectivity/source/parse/wrap_sqlbison.cxx deleted file mode 100644 index 932f74fa86..0000000000 --- a/connectivity/source/parse/wrap_sqlbison.cxx +++ /dev/null @@ -1,34 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" - -#include "sqlbison.cxx" - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/parse/wrap_sqlflex.cxx b/connectivity/source/parse/wrap_sqlflex.cxx deleted file mode 100644 index 31007e1fce..0000000000 --- a/connectivity/source/parse/wrap_sqlflex.cxx +++ /dev/null @@ -1,38 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_connectivity.hxx" - -#if defined _MSC_VER - #pragma warning(disable:4505) -#endif - -#include "sqlflex.cxx" - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |