xref: /aoo4110/main/connectivity/inc/connectivity/sqlnode.hxx (revision b1cdbd2c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#ifndef _CONNECTIVITY_SQLNODE_HXX
#define _CONNECTIVITY_SQLNODE_HXX

#include "connectivity/dbtoolsdllapi.hxx"
#include "connectivity/dbmetadata.hxx"
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <vector>
#include <functional>
#include <set>
#include <boost/shared_ptr.hpp>
#include <rtl/ustrbuf.hxx>

// forward declarations
namespace com
{
	namespace sun
	{
		namespace star
		{
			namespace beans
			{
				class XPropertySet;
			}
			namespace util
			{
				class XNumberFormatter;
			}
            namespace container
            {
                class XNameAccess;
            }
		}
	}
}

namespace rtl
{
    class OUStringBuffer;
}
#define ORDER_BY_CHILD_POS  5
#define TABLE_EXPRESSION_CHILD_COUNT    9

namespace connectivity
{
    class OSQLParser;
	class OSQLParseNode;
	class IParseContext;

    typedef ::std::vector< OSQLParseNode* >                  OSQLParseNodes;

	enum SQLNodeType	{SQL_NODE_RULE, SQL_NODE_LISTRULE, SQL_NODE_COMMALISTRULE,
						 SQL_NODE_KEYWORD, SQL_NODE_COMPARISON, SQL_NODE_NAME,
						 SQL_NODE_STRING,	SQL_NODE_INTNUM, SQL_NODE_APPROXNUM,
						 SQL_NODE_EQUAL,SQL_NODE_LESS,SQL_NODE_GREAT,SQL_NODE_LESSEQ,SQL_NODE_GREATEQ,SQL_NODE_NOTEQUAL,
						 SQL_NODE_PUNCTUATION, SQL_NODE_AMMSC, SQL_NODE_ACCESS_DATE,SQL_NODE_DATE,SQL_NODE_CONCAT};

    typedef ::std::set< ::rtl::OUString >   QueryNameSet;
    //==================================================================
    //= SQLParseNodeParameter
    //==================================================================
    struct OOO_DLLPUBLIC_DBTOOLS SQLParseNodeParameter
    {
	    const ::com::sun::star::lang::Locale&	rLocale;
        ::dbtools::DatabaseMetaData             aMetaData;
        OSQLParser*                             pParser;
        ::boost::shared_ptr< QueryNameSet >     pSubQueryHistory;
	    ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatter >    xFormatter;
	    ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >       xField;
	    ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >    xQueries;  // see bParseToSDBCLevel
	    const IParseContext& m_rContext;
	    sal_Char			cDecSep;
	    bool                bQuote                      : 1;    /// should we quote identifiers?
	    bool                bInternational              : 1;    /// should we internationalize keywords and placeholders?
	    bool                bPredicate                  : 1;    /// are we going to parse a mere predicate?
        bool                bParseToSDBCLevel           : 1;    /// should we create an SDBC-level statement (e.g. with substituted sub queries)?

	    SQLParseNodeParameter(
            const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
		    const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatter >& _xFormatter,
            const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& _xField,
		    const ::com::sun::star::lang::Locale& _rLocale,
            const IParseContext* _pContext,
		    bool _bIntl,
            bool _bQuote,
            sal_Char _cDecSep,
            bool _bPredicate,
            bool _bParseToSDBC
        );
        ~SQLParseNodeParameter();
    };

	//==========================================================================
	//= OSQLParseNode
	//==========================================================================
	class OOO_DLLPUBLIC_DBTOOLS OSQLParseNode
	{
		friend class OSQLParser;

		OSQLParseNodes					m_aChildren;
		OSQLParseNode*	 				m_pParent;		// pParent fuer Reuckverkettung im Baum
		::rtl::OUString 				m_aNodeValue;	// Token-Name oder leer bei Regeln oder ::rtl::OUString bei
														// ::rtl::OUString, INT, usw. -Werten
		SQLNodeType 					m_eNodeType;	// s. o.
		sal_uInt32						m_nNodeID; 		// ::com::sun::star::chaos::Rule ID (bei IsRule()) oder Token ID (bei !IsRule())
											// ::com::sun::star::chaos::Rule IDs und Token IDs koennen nicht anhand des Wertes
											// unterschieden werden, dafuer ist IsRule() abzufragen!
	public:
		enum Rule
		{
			select_statement = 0,
			table_exp,
			table_ref_commalist,
			table_ref,
			catalog_name,
			schema_name,
			table_name,
			opt_column_commalist,
			column_commalist,
			column_ref_commalist,
			column_ref,
			opt_order_by_clause,
			ordering_spec_commalist,
			ordering_spec,
			opt_asc_desc,
			where_clause,
			opt_where_clause,
			search_condition,
			comparison_predicate,
			between_predicate,
			like_predicate,
			opt_escape,
			test_for_null,
			scalar_exp_commalist,
			scalar_exp,
			parameter_ref,
			parameter,
			general_set_fct,
			range_variable,
			column,
			delete_statement_positioned,
			delete_statement_searched,
			update_statement_positioned,
			update_statement_searched,
			assignment_commalist,
			assignment,
			values_or_query_spec,
			insert_statement,
			insert_atom_commalist,
			insert_atom,
			predicate_check,
			from_clause,
			qualified_join,
			cross_union,
			select_sublist,
			derived_column,
			column_val,
			set_fct_spec,
			boolean_term,
			boolean_primary,
			num_value_exp,
			join_type,
			position_exp,
			extract_exp,
			length_exp,
			char_value_fct,
			odbc_call_spec,
			in_predicate,
			existence_test,
			unique_test,
			all_or_any_predicate,
			named_columns_join,
			join_condition,
            joined_table,
			boolean_factor,
			sql_not,
			boolean_test,
			manipulative_statement,
			subquery,
			value_exp_commalist,
			odbc_fct_spec,
			union_statement,
			outer_join_type,
			char_value_exp,
			term,
			value_exp_primary,
			value_exp,
			selection,
			fold,
			char_substring_fct,
			factor,
            base_table_def,
            base_table_element_commalist,
            data_type,
            column_def,
            table_node,
            as,
            op_column_commalist,
            table_primary_as_range_column,
            datetime_primary,
            concatenation,
            char_factor,
            bit_value_fct,
            comparison_predicate_part_2,
            parenthesized_boolean_value_expression,
            character_string_type,
            other_like_predicate_part_2,
            between_predicate_part_2,
            cast_spec,
            rule_count,             // letzter_wert
            UNKNOWN_RULE            // ID indicating that a node is no rule with a matching Rule-enum value (see getKnownRuleID)
		};

		// must be ascii encoding for the value
		OSQLParseNode(const sal_Char* _pValueStr,
					  SQLNodeType _eNodeType,
					  sal_uInt32 _nNodeID = 0);

		OSQLParseNode(const ::rtl::OString& _rValue,
					  SQLNodeType eNewNodeType,
					  sal_uInt32 nNewNodeID=0);

		OSQLParseNode(const sal_Unicode* _pValue,
					  SQLNodeType _eNodeType,
					  sal_uInt32 _nNodeID = 0);

		OSQLParseNode(const ::rtl::OUString& _rValue,
					  SQLNodeType _eNodeType,
					  sal_uInt32 _nNodeID = 0);

			// Kopiert den entsprechenden ParseNode
		OSQLParseNode(const OSQLParseNode& rParseNode);
		OSQLParseNode& operator=(const OSQLParseNode& rParseNode);

		sal_Bool operator==(OSQLParseNode& rParseNode) const;

		// Destruktor raeumt rekursiv den Baum ab
		virtual ~OSQLParseNode();

		// Parent gibt den Zeiger auf den Parent zurueck
		OSQLParseNode* getParent() const {return m_pParent;};

		// SetParent setzt den Parent-Zeiger eines ParseNodes
		void setParent(OSQLParseNode* pParseNode) {m_pParent = pParseNode;};

		// ChildCount liefert die Anzahl der Kinder eines Knotens
		sal_uInt32 count() const {return m_aChildren.size();};
		inline OSQLParseNode* getChild(sal_uInt32 nPos) const;

		void append(OSQLParseNode* pNewSubTree);
		void insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree);

		OSQLParseNode* replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubTree);
		OSQLParseNode* replace(OSQLParseNode* pOldSubTree, OSQLParseNode* pNewSubTree);

		OSQLParseNode* removeAt(sal_uInt32 nPos);
		OSQLParseNode* remove(OSQLParseNode* pSubTree);

		void replaceNodeValue(const ::rtl::OUString& rTableAlias,const ::rtl::OUString& rColumnName);

        /** parses the node to a string which can be passed to a driver's connection for execution

            Any particles of the parse tree which represent application-level features - such
            as queries appearing in the FROM part - are subsituted, so that the resulting statement can
            be executed at an SDBC-level connection.

            @param  _out_rString
                is an output parameter taking the resulting SQL statement

            @param  _rxConnection
                the connection relative to which to parse. This must be an SDB-level connection (e.g.
                support the XQueriesSupplier interface) for the method to be able to do all necessary
                substitutions.

            @param _rParser
                the SQLParser used to create the node. This is needed in case we need to parse
                sub queries which are present in the SQL statement - those sub queries need to be parsed,
                too, to check whether they contain nested sub queries.

            @param _pErrorHolder
                takes the error which occured while generating the statement, if any. Might be <NULL/>,
                in this case the error is not reported back, and can only be recognized by examing the
                return value.

            @return
                <TRUE/> if and only if the parsing was successful.<br/>

                Currently, there's only one condition how this method can fail: If it contains a nested
                query which causes a cycle. E.g., consider a statement <code>SELECT * from "foo"</code>,
                where <code>bar </code> is a query defined as <code>SELECT * FROM "bar"</code>, where
                <code>bar</code> is defined as <code>SELECT * FROM "foo"</code>. This statement obviously
                cannot be parsed to an executable statement.

                If this method returns <FALSE/>, you're encouraged to check and handle the error in
                <arg>_pErrorHolder</arg>.
        */
        bool parseNodeToExecutableStatement( ::rtl::OUString& _out_rString,
            const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
            OSQLParser& _rParser,
            ::com::sun::star::sdbc::SQLException* _pErrorHolder ) const;

		void parseNodeToStr(::rtl::OUString& rString,
							const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
							const IParseContext* pContext = NULL,
							sal_Bool _bIntl = sal_False,
							sal_Bool _bQuote= sal_True) const;

		// quoted und internationalisert
		void parseNodeToPredicateStr(::rtl::OUString& rString,
									 const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
									 const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter,
									 const ::com::sun::star::lang::Locale& rIntl,
									 sal_Char _cDec,
									 const IParseContext* pContext = NULL ) const;

		void parseNodeToPredicateStr(::rtl::OUString& rString,
									 const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
									 const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter,
									 const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & _xField,
									 const ::com::sun::star::lang::Locale& rIntl,
									 sal_Char _cDec,
									 const IParseContext* pContext = NULL ) const;

		OSQLParseNode* getByRule(OSQLParseNode::Rule eRule) const;

#if OSL_DEBUG_LEVEL > 0
			// zeigt den ParseTree mit tabs und linefeeds
		void showParseTree( ::rtl::OUString& rString ) const;
		void showParseTree( ::rtl::OUStringBuffer& _inout_rBuf, sal_uInt32 nLevel ) const;
#endif

			// GetNodeType gibt den Knotentyp zurueck
		SQLNodeType getNodeType() const {return m_eNodeType;};

			// RuleId liefert die RuleId der Regel des Knotens (nur bei IsRule())
		sal_uInt32 getRuleID() const {return m_nNodeID;}

        /** returns the ID of the rule represented by the node

            If the node does not represent a rule, UNKNOWN_RULE is returned
        */
        Rule getKnownRuleID() const;

			// RuleId liefert die TokenId des Tokens des Knotens (nur bei ! IsRule())
		sal_uInt32 getTokenID() const {return m_nNodeID;}

			// IsRule testet ob ein Node eine Regel (NonTerminal) ist
			// Achtung : Regeln koenne auch Blaetter sein, z.B. leere Listen
		sal_Bool isRule() const
			{ return (m_eNodeType == SQL_NODE_RULE) || (m_eNodeType == SQL_NODE_LISTRULE)
				|| (m_eNodeType == SQL_NODE_COMMALISTRULE);}

			// IsToken testet ob ein Node ein Token (Terminal) ist
		sal_Bool isToken() const {return !isRule();} // ein Token ist keine Regel

				// TokenValue liefert den NodeValue eines Tokens
		const ::rtl::OUString& getTokenValue() const {return m_aNodeValue;}

			// SetTokenValue setzt den NodeValue
		void setTokenValue(const ::rtl::OUString& rString) {	if (isToken()) m_aNodeValue = rString;}

			// IsLeaf testet ob ein Node ein Blatt ist
		sal_Bool isLeaf() const {return m_aChildren.empty();}

		// negate only a searchcondition, any other rule could cause a gpf
		static void negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_Bool bNegate=sal_False);

		// normalize a logic form
		// e.q. (a or b) and (c or d) <=> a and c or a and d or b and c or b and d
		static void disjunctiveNormalForm(OSQLParseNode*& pSearchCondition);

		//	 Simplies logic expressions
		// a * a		= a
		// a + a		= a
		// a * ( a + b) = a
		// a + a * b	= a
		static void absorptions(OSQLParseNode*& pSearchCondition);

		// erase not nessary braces
		static void eraseBraces(OSQLParseNode*& pSearchCondition);

		// makes the logic formula a little more smaller
		static void compress(OSQLParseNode*& pSearchCondition);
		// return the catalog, schema and tablename form this node
		// _pTableNode must be a rule of that above or a SQL_TOKEN_NAME
		static sal_Bool getTableComponents(const OSQLParseNode* _pTableNode,
											::com::sun::star::uno::Any &_rCatalog,
											::rtl::OUString &_rSchema,
											::rtl::OUString &_rTable
                                            ,const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XDatabaseMetaData >& _xMetaData);

		// susbtitute all occurences of :var or [name] into the dynamic parameter ?
		// _pNode will be modified if parameters exists
		static void substituteParameterNames(OSQLParseNode* _pNode);

        /** return a table range when it exists.
        */
        static ::rtl::OUString getTableRange(const OSQLParseNode* _pTableRef);

	protected:
		// ParseNodeToStr konkateniert alle Token (Blaetter) des ParseNodes
		void parseNodeToStr(::rtl::OUString& rString,
							const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection >& _rxConnection,
							const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter,
							const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & _xField,
							const ::com::sun::star::lang::Locale& rIntl,
							const IParseContext* pContext,
							bool _bIntl,
							bool _bQuote,
							sal_Char _cDecSep,
							bool _bPredicate,
                            bool _bSubstitute) const;

	private:
		void impl_parseNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const;
		void impl_parseLikeNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const;
        void impl_parseTableRangeNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const;

        /** parses a table_name node into a SQL statement particle.
            @return
                <TRUE/> if and only if parsing was successful, <FALSE/> if default handling should
                be applied.
        */
		bool impl_parseTableNameNodeToString_throw( ::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam ) const;

        sal_Bool addDateValue(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const;
		::rtl::OUString convertDateTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const;
		::rtl::OUString convertDateString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const;
		::rtl::OUString convertTimeString(const SQLParseNodeParameter& rParam, const ::rtl::OUString& rString) const;
		void parseLeaf(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const;
	};

	//-----------------------------------------------------------------------------
	inline OSQLParseNode* OSQLParseNode::getChild(sal_uInt32 nPos) const
	{
		OSL_ENSURE(nPos < m_aChildren.size(), "Invalid Position");

		//	return m_aChildren[nPos];
		return m_aChildren.at(nPos);
	}

	// Utility-Methoden zum Abfragen auf bestimmte Rules, Token oder Punctuation:
	#define SQL_ISRULE(pParseNode, eRule) 	((pParseNode)->isRule() && (pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::eRule))
	#define SQL_ISTOKEN(pParseNode, token) ((pParseNode)->isToken() && (pParseNode)->getTokenID() == SQL_TOKEN_##token)
	#define SQL_ISPUNCTUATION(pParseNode, aString) ((pParseNode)->getNodeType() == SQL_NODE_PUNCTUATION && !(pParseNode)->getTokenValue().compareToAscii(aString))
}

#endif	//_CONNECTIVITY_SQLNODE_HXX