sqliterator.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
#ifndef INCLUDED_CONNECTIVITY_SQLITERATOR_HXX
#define INCLUDED_CONNECTIVITY_SQLITERATOR_HXX
 
#include <connectivity/dbtoolsdllapi.hxx>
#include <connectivity/IParseContext.hxx>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/sdbc/SQLException.hpp>
#include <connectivity/CommonTools.hxx>
#include <rtl/ref.hxx>
 
#include <memory>
#include <optional>
#include <vector>
#include <o3tl/typed_flags_set.hxx>
 
namespace com::sun::star::sdbc { class XConnection; }
namespace com::sun::star::beans { class XPropertySet; }
 
namespace connectivity
{
    enum class TraversalParts
    {
        Parameters      = 0x0001,
        TableNames      = 0x0002,
        SelectColumns   = 0x0006,   // note that this includes TableNames. No SelectColumns without TableNames
 
        // Those are not implemented currently
        // GroupColumns    = 0x0008,
        // OrderColumns    = 0x0010,
        // SelectColumns   = 0x0020,
        // CreateColumns   = 0x0040,
 
        All             = 0xFFFF
    };
}
namespace o3tl
{
    template<> struct typed_flags<connectivity::TraversalParts> : is_typed_flags<connectivity::TraversalParts, 0xffff> {};
}
 
namespace connectivity
{
 
    class OSQLParseNode;
    class OSQLParser;
 
    typedef ::std::pair<const OSQLParseNode*,const OSQLParseNode* > TNodePair;
 
    enum class OSQLStatementType {
        Unknown,
        Select,
        Insert,
        Update,
        Delete,
        OdbcCall,
        CreateTable
    };
 
    struct OSQLParseTreeIteratorImpl;
 
    class OOO_DLLPUBLIC_DBTOOLS OSQLParseTreeIterator final
    {
    private:
        std::optional<css::sdbc::SQLException>              m_xErrors;          // contains the error while iterating through the statement
        const OSQLParseNode*                                m_pParseTree;       // current ParseTree
        const OSQLParser&                                   m_rParser;          // if set used for general error messages from the context
        OSQLStatementType                                   m_eStatementType;
        ::rtl::Reference<OSQLColumns>                       m_aSelectColumns;   // all columns from the Select clause
        ::rtl::Reference<OSQLColumns>                       m_aParameters;      // all parameters
        ::rtl::Reference<OSQLColumns>                       m_aGroupColumns;    // the group by columns
        ::rtl::Reference<OSQLColumns>                       m_aOrderColumns;    // the order by columns
        ::rtl::Reference<OSQLColumns>                       m_aCreateColumns;   // the columns for Create table clause
 
        ::std::unique_ptr< OSQLParseTreeIteratorImpl >  m_pImpl;
 
        void                traverseParameter(const OSQLParseNode* _pParseNode,const OSQLParseNode* _pColumnRef,const OUString& _aColumnName, OUString& _aTableRange, const OUString& _rColumnAlias);
        // inserts a table into the map
        void                traverseOneTableName( OSQLTables& _rTables,const OSQLParseNode * pTableName, const OUString & rTableRange );
        void                traverseSearchCondition(OSQLParseNode const * pSearchCondition);
        void                traverseOnePredicate(
                                                OSQLParseNode const * pColumnRef,
                                                OUString& aValue,
                                                OSQLParseNode const * pParameter);
        void traverseByColumnNames(const OSQLParseNode* pSelectNode, bool _bOrder);
        void                traverseParameters(const OSQLParseNode* pSelectNode);
 
        const OSQLParseNode*    getTableNode( OSQLTables& _rTables, const OSQLParseNode* pTableRef, OUString& aTableRange );
        void                    getQualified_join( OSQLTables& _rTables, const OSQLParseNode *pTableRef, OUString& aTableRange );
        void                    getSelect_statement(OSQLTables& _rTables,const OSQLParseNode* pSelect);
        // get all the column names of m_aSelectColumns and return in a vector sorted by a UStringMixLess that's constructed from
        // isCaseSensitive()
        std::vector<OUString> getSelectColumnNames() const;
        // rColumnNames is expected to be sorted as returned by getSelectColumnNames
        OUString getUniqueColumnName(const std::vector<OUString>& rColumnNames, const OUString & rColumnName) const;
 
        static css::uno::Reference< css::beans::XPropertySet > findColumn(
            const OSQLTables& _rTables, const OUString & rColumnName, OUString & rTableRange );
 
        css::uno::Reference< css::beans::XPropertySet > findColumn(
            const OUString & rColumnName, OUString & rTableRange, bool _bLookInSubTables );
 
        css::uno::Reference< css::beans::XPropertySet > findSelectColumn(
            std::u16string_view rColumnName );
 
        void setSelectColumnName(const OUString& rColumnName, const OUString& rColumnAlias, const OUString& rTableRange, bool bFkt = false, sal_Int32 _nType = css::sdbc::DataType::VARCHAR, bool bAggFkt = false);
        void appendColumns(const OUString& _rTableAlias, const OSQLTable& _rTable);
        // Other member variables that should be available in the "set" functions
        // can be defined in the derived class. They can be initialized
        // in its constructor and, after the "traverse" routines have been used,
        // they can be queried using other functions.
 
        OSQLParseTreeIterator(const OSQLParseTreeIterator & rIter) = delete;
 
      public:
        OSQLParseTreeIterator(
            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
            const css::uno::Reference< css::container::XNameAccess >& _rxTables,
            const OSQLParser& _rParser );
        ~OSQLParseTreeIterator();
 
        void dispose();
        bool isCaseSensitive() const;
        // The parse tree to be analysed/traversed:
        // If NULL is passed, the current parse tree will be deleted and the error status cleared.
        void setParseTree(const OSQLParseNode * pNewParseTree);
        const OSQLParseNode * getParseTree() const { return m_pParseTree; };
 
        // subtrees in case of a select statement
        const OSQLParseNode* getWhereTree() const;
        const OSQLParseNode* getOrderTree() const;
        const OSQLParseNode* getGroupByTree() const;
        const OSQLParseNode* getHavingTree() const;
 
        const OSQLParseNode* getSimpleWhereTree() const;
        const OSQLParseNode* getSimpleOrderTree() const;
        const OSQLParseNode* getSimpleGroupByTree() const;
        const OSQLParseNode* getSimpleHavingTree() const;
 
        const css::sdbc::SQLException&   getErrors() const { return *m_xErrors; }
        bool hasErrors() const { return bool(m_xErrors); }
 
        // statement type (already set in setParseTree):
        OSQLStatementType getStatementType() const { return m_eStatementType; }
 
        void traverseAll();
 
        // The TableRangeMap contains all tables associated with the range name found first.
        const OSQLTables& getTables() const;
 
        const ::rtl::Reference<OSQLColumns>& getSelectColumns() const { return m_aSelectColumns;}
        const ::rtl::Reference<OSQLColumns>& getGroupColumns() const { return m_aGroupColumns;}
        const ::rtl::Reference<OSQLColumns>& getOrderColumns() const { return m_aOrderColumns;}
        const ::rtl::Reference<OSQLColumns>& getParameters()   const { return m_aParameters; }
 
        void getColumnRange(    const OSQLParseNode* _pColumnRef,
                                OUString &_rColumnName,
                                OUString& _rTableRange) const;
 
        void getColumnRange(    const OSQLParseNode* _pColumnRef,
                                OUString& _out_rColumnName,
                                OUString& _out_rTableRange,
                                OUString& _out_rColumnAliasIfPresent
                                ) const;
 
        static OUString getColumnAlias(const OSQLParseNode* _pDerivedColumn);
 
        static void getColumnRange( const OSQLParseNode* _pColumnRef,
                                    const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
                                    OUString &_rColumnName,
                                    OUString& _rTableRange);
 
        // return true when the tableNode is a rule like catalog_name, schema_name or table_name
        static bool isTableNode(const OSQLParseNode* _pTableNode);
 
        // tries to find the correct type of the function
        sal_Int32 getFunctionReturnType(const OSQLParseNode* _pNode );
 
        // returns a lis of all joined columns
        ::std::vector< TNodePair >& getJoinConditions() const;
 
    private:
 
        bool traverseTableNames( OSQLTables& _rTables );
 
        bool traverseSelectColumnNames(const OSQLParseNode* pSelectNode);
        void traverseCreateColumns(const OSQLParseNode* pSelectNode);
 
        bool traverseOrderByColumnNames(const OSQLParseNode* pSelectNode);
        bool traverseGroupByColumnNames(const OSQLParseNode* pSelectNode);
 
        bool traverseSelectionCriteria(const OSQLParseNode* pSelectNode);
 
        OSQLParseTreeIterator(
            const OSQLParseTreeIterator& _rParentIterator,
            const OSQLParser& _rParser,
            const OSQLParseNode* pRoot );
 
        OSQLTable   impl_createTableObject(
            const OUString& rTableName, const OUString& rCatalogName, const OUString& rSchemaName );
 
        OSQLTable   impl_locateRecordSource(
            const OUString& _rComposedName
        );
 
        void    impl_traverse( TraversalParts _nIncludeMask );
 
        void    impl_getQueryParameterColumns( const OSQLTable& _rQuery );
 
        void setOrderByColumnName(const OUString & rColumnName, OUString & rTableRange, bool bAscending);
        void setGroupByColumnName(const OUString & rColumnName, OUString & rTableRange);
 
        void impl_appendError( IParseContext::ErrorCode _eError,
            const OUString* _pReplaceToken1 = nullptr, const OUString* _pReplaceToken2 = nullptr );
 
        void impl_appendError( const css::sdbc::SQLException& _rError );
 
        void impl_fillJoinConditions(const OSQLParseNode* i_pJoinCondition);
    };
}
 
#endif // INCLUDED_CONNECTIVITY_SQLITERATOR_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */