    /* -*- 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 .
     */

    #include <file/fcomp.hxx>
    #include <tools/debug.hxx>
    #include <TConnection.hxx>
    #include <connectivity/sqlparse.hxx>
    #include <file/fanalyzer.hxx>
    #include <com/sun/star/sdbc/XColumnLocate.hpp>
    #include <com/sun/star/util/DateTime.hpp>
    #include <com/sun/star/util/Date.hpp>
    #include <com/sun/star/util/Time.hpp>
    #include <connectivity/dbexception.hxx>
    #include <connectivity/dbconversion.hxx>
    #include <com/sun/star/sdb/SQLFilterOperator.hpp>
    #include <file/FStringFunctions.hxx>
    #include <file/FDateFunctions.hxx>
    #include <file/FNumericFunctions.hxx>
    #include <file/FConnection.hxx>
    #include <sqlbison.hxx>
    #include <strings.hrc>

    using namespace connectivity;
    using namespace connectivity::file;
    using namespace com::sun::star::uno;
    using namespace com::sun::star::sdbc;
    using namespace com::sun::star::sdb;
    using namespace ::com::sun::star::container;
    using namespace com::sun::star;

    OPredicateCompiler::OPredicateCompiler(OSQLAnalyzer* pAnalyzer)//,OCursor& rCurs)
                         : m_pAnalyzer(pAnalyzer)
                         , m_nParamCounter(0)
    {
    }

    OPredicateCompiler::~OPredicateCompiler()
    {
        Clean();
    }

    void OPredicateCompiler::dispose()
    {
        Clean();
        m_orgColumns        = nullptr;
        m_xIndexes.clear();
    }

    void OPredicateCompiler::start(OSQLParseNode const * pSQLParseNode)
    {
        if (!pSQLParseNode)
            return;

        m_nParamCounter = 0;
        // analyse Parse Tree (depending on Statement-type)
        // and set pointer on WHERE-clause:
        OSQLParseNode * pWhereClause = nullptr;

        if (SQL_ISRULE(pSQLParseNode,select_statement))
        {
            OSQLParseNode * pOrderbyClause = nullptr;
            DBG_ASSERT(pSQLParseNode->count() >= 4,"OFILECursor: Error in Parse Tree");

            OSQLParseNode * pTableExp = pSQLParseNode->getChild(3);
            DBG_ASSERT(pTableExp != nullptr,"Error in Parse Tree");
            DBG_ASSERT(SQL_ISRULE(pTableExp,table_exp)," Error in Parse Tree");
            DBG_ASSERT(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"Error in Parse Tree");

            // check that we don't use anything other than count(*) as function
            OSQLParseNode* pSelection = pSQLParseNode->getChild(2);
            if ( SQL_ISRULE(pSelection,scalar_exp_commalist) )
            {
                for (size_t i = 0; i < pSelection->count(); i++)
                {
                    OSQLParseNode *pColumnRef = pSelection->getChild(i)->getChild(0);
                    if ( SQL_ISRULE(pColumnRef,general_set_fct) && pColumnRef->count() != 4 )
                    {
                        m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_COMPLEX_COUNT,nullptr);
                    }
                }
            }

            pWhereClause    = pTableExp->getChild(1);
            pOrderbyClause  = pTableExp->getChild(ORDER_BY_CHILD_POS);
            (void)pOrderbyClause;
        }
        else if (SQL_ISRULE(pSQLParseNode,update_statement_searched))
        {
            DBG_ASSERT(pSQLParseNode->count() == 5,"OFILECursor: Error in Parse Tree");
            pWhereClause = pSQLParseNode->getChild(4);
        }
        else if (SQL_ISRULE(pSQLParseNode,delete_statement_searched))
        {
            DBG_ASSERT(pSQLParseNode->count() == 4,"Error in Parse Tree");
            pWhereClause = pSQLParseNode->getChild(3);
        }
        else
                // Other Statement. no selection-criteria
            return;

        if (SQL_ISRULE(pWhereClause,where_clause))
        {
            // a where-clause is not allowed to be empty:
            DBG_ASSERT(pWhereClause->count() == 2,"OFILECursor: Error in Parse Tree");

            OSQLParseNode * pComparisonPredicate = pWhereClause->getChild(1);
            DBG_ASSERT(pComparisonPredicate != nullptr,"OFILECursor: Error in Parse Tree");

            execute( pComparisonPredicate );
        }
        else
        {
            // The where-clause is optionally in the majority of cases, i.e. it might be an "optional-where-clause".
            DBG_ASSERT(SQL_ISRULE(pWhereClause,opt_where_clause),"OPredicateCompiler: Error in Parse Tree");
        }
    }

    OOperand* OPredicateCompiler::execute(OSQLParseNode const * pPredicateNode)
    {
        OOperand* pOperand = nullptr;
        if (pPredicateNode->count() == 3 &&                         // Expression is bracketed
            SQL_ISPUNCTUATION(pPredicateNode->getChild(0),"(") &&
            SQL_ISPUNCTUATION(pPredicateNode->getChild(2),")"))
        {
            execute(pPredicateNode->getChild(1));
        }
        else if ((SQL_ISRULE(pPredicateNode,search_condition) || SQL_ISRULE(pPredicateNode,boolean_term))
                                &&          // AND/OR-linkage:
                                pPredicateNode->count() == 3)
        {
            execute(pPredicateNode->getChild(0));                           // process the left branch
            execute(pPredicateNode->getChild(2));                           // process the right branch

            if (SQL_ISTOKEN(pPredicateNode->getChild(1),OR))                // OR-Operator
            {
                m_aCodeList.emplace_back(new OOp_OR);
            }
            else if (SQL_ISTOKEN(pPredicateNode->getChild(1),AND))      // AND-Operator
                m_aCodeList.emplace_back(new OOp_AND);
            else
            {
                OSL_FAIL("OPredicateCompiler: Error in Parse Tree");
            }
        }
        else if (SQL_ISRULE(pPredicateNode,boolean_factor))
        {
            execute(pPredicateNode->getChild(1));
            m_aCodeList.emplace_back(new OOp_NOT);
        }
        else if (SQL_ISRULE(pPredicateNode,comparison_predicate))
        {
            execute_COMPARE(pPredicateNode);
        }
        else if (SQL_ISRULE(pPredicateNode,like_predicate))
        {
            execute_LIKE(pPredicateNode);
        }
        else if (SQL_ISRULE(pPredicateNode,between_predicate))
        {
            execute_BETWEEN(pPredicateNode);
        }
        else if (SQL_ISRULE(pPredicateNode,test_for_null))
        {
            execute_ISNULL(pPredicateNode);
        }
        else if(SQL_ISRULE(pPredicateNode,num_value_exp))
        {
            execute(pPredicateNode->getChild(0));                           // process the left branch
            execute(pPredicateNode->getChild(2));                           // process the right branch
            if (SQL_ISPUNCTUATION(pPredicateNode->getChild(1),"+"))
            {
                m_aCodeList.emplace_back(new OOp_ADD);
            }
            else if (SQL_ISPUNCTUATION(pPredicateNode->getChild(1),"-"))
                m_aCodeList.emplace_back(new OOp_SUB);
            else
            {
                OSL_FAIL("OPredicateCompiler: Error in Parse Tree num_value_exp");
            }
        }
        else if(SQL_ISRULE(pPredicateNode,term))
        {
            execute(pPredicateNode->getChild(0));                           // process the left branch
            execute(pPredicateNode->getChild(2));                           // process the right branch
            if (SQL_ISPUNCTUATION(pPredicateNode->getChild(1),"*"))
            {
                m_aCodeList.emplace_back(new OOp_MUL);
            }
            else if (SQL_ISPUNCTUATION(pPredicateNode->getChild(1),"/"))
                m_aCodeList.emplace_back(new OOp_DIV);
            else
            {
                OSL_FAIL("OPredicateCompiler: Error in Parse Tree num_value_exp");
            }
        }
        else
            pOperand = execute_Operand(pPredicateNode);                     // now only simple operands will be processed

        return pOperand;
    }

    void OPredicateCompiler::execute_COMPARE(OSQLParseNode const * pPredicateNode)
    {
        DBG_ASSERT(pPredicateNode->count() == 3,"OFILECursor: Error in Parse Tree");

        if ( !(SQL_ISRULE(pPredicateNode->getChild(0),column_ref)               ||
              pPredicateNode->getChild(2)->getNodeType() == SQLNodeType::String     ||
              pPredicateNode->getChild(2)->getNodeType() == SQLNodeType::IntNum     ||
              pPredicateNode->getChild(2)->getNodeType() == SQLNodeType::ApproxNum  ||
              SQL_ISTOKEN(pPredicateNode->getChild(2),TRUE)                     ||
              SQL_ISTOKEN(pPredicateNode->getChild(2),FALSE)                    ||
              SQL_ISRULE(pPredicateNode->getChild(2),parameter)                 ||
              // odbc date
              SQL_ISRULE(pPredicateNode->getChild(2),set_fct_spec)              ||
              SQL_ISRULE(pPredicateNode->getChild(2),position_exp)              ||
              SQL_ISRULE(pPredicateNode->getChild(2),char_substring_fct)        ||
              // upper, lower etc.
              SQL_ISRULE(pPredicateNode->getChild(2),fold)) )
        {
            m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,nullptr);
            return;
        }

        sal_Int32 ePredicateType( SQLFilterOperator::EQUAL );
        OSQLParseNode *pPrec = pPredicateNode->getChild(1);

        if (pPrec->getNodeType() == SQLNodeType::Equal)
            ePredicateType = SQLFilterOperator::EQUAL;
        else if (pPrec->getNodeType() == SQLNodeType::NotEqual)
            ePredicateType = SQLFilterOperator::NOT_EQUAL;
        else if (pPrec->getNodeType() == SQLNodeType::Less)
            ePredicateType = SQLFilterOperator::LESS;
        else if (pPrec->getNodeType() == SQLNodeType::LessEq)
            ePredicateType = SQLFilterOperator::LESS_EQUAL;
        else if (pPrec->getNodeType() == SQLNodeType::GreatEq)
            ePredicateType = SQLFilterOperator::GREATER_EQUAL;
        else if (pPrec->getNodeType() == SQLNodeType::Great)
            ePredicateType = SQLFilterOperator::GREATER;
        else
            OSL_FAIL( "OPredicateCompiler::execute_COMPARE: unexpected node type!" );

        execute(pPredicateNode->getChild(0));
        execute(pPredicateNode->getChild(2));
        m_aCodeList.emplace_back( new OOp_COMPARE(ePredicateType) );
    }

    void OPredicateCompiler::execute_LIKE(OSQLParseNode const * pPredicateNode)
    {
        DBG_ASSERT(pPredicateNode->count() == 2,"OFILECursor: Error in Parse Tree");
        const OSQLParseNode* pPart2 = pPredicateNode->getChild(1);

        sal_Unicode cEscape = L'\0';
        const bool bNotLike = pPart2->getChild(0)->isToken();

        OSQLParseNode* pAtom        = pPart2->getChild(pPart2->count()-2);
        OSQLParseNode* pOptEscape   = pPart2->getChild(pPart2->count()-1);

        if (!(pAtom->getNodeType() == SQLNodeType::String   ||
              SQL_ISRULE(pAtom,parameter)               ||
              // odbc date
              SQL_ISRULE(pAtom,set_fct_spec)            ||
              SQL_ISRULE(pAtom,position_exp)            ||
              SQL_ISRULE(pAtom,char_substring_fct)      ||
              // upper, lower etc.
              SQL_ISRULE(pAtom,fold)) )
        {
            m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,nullptr);
            return;
        }

        if (pOptEscape->count() != 0)
        {
            if (pOptEscape->count() != 2)
            {
                m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_INVALID_LIKE_STRING,nullptr);
            }
            OSQLParseNode *pEscNode = pOptEscape->getChild(1);
            if (pEscNode->getNodeType() != SQLNodeType::String)
            {
                m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_INVALID_LIKE_STRING,nullptr);
            }
            else
                cEscape = pEscNode->getTokenValue().toChar();
        }

        execute(pPredicateNode->getChild(0));
        execute(pAtom);

        OBoolOperator* pOperator = bNotLike
                                        ? new OOp_NOTLIKE(cEscape)
                                        : new OOp_LIKE(cEscape);
        m_aCodeList.emplace_back(pOperator);
    }

    void OPredicateCompiler::execute_BETWEEN(OSQLParseNode const * pPredicateNode)
    {
        DBG_ASSERT(pPredicateNode->count() == 2,"OFILECursor: Error in Parse Tree");

        OSQLParseNode* pColumn = pPredicateNode->getChild(0);
        const OSQLParseNode* pPart2 = pPredicateNode->getChild(1);
        OSQLParseNode* p1stValue = pPart2->getChild(2);
        OSQLParseNode* p2ndtValue = pPart2->getChild(4);

        if (
                !(p1stValue->getNodeType() == SQLNodeType::String || SQL_ISRULE(p1stValue,parameter))
            &&  !(p2ndtValue->getNodeType() == SQLNodeType::String || SQL_ISRULE(p2ndtValue,parameter))
            )
        {
            m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_INVALID_BETWEEN,nullptr);
        }

        bool bNot = SQL_ISTOKEN(pPart2->getChild(0),NOT);

        OOperand* pColumnOp = execute(pColumn);
        OOperand* pOb1 = execute(p1stValue);
        OBoolOperator* pOperator = new OOp_COMPARE(bNot ? SQLFilterOperator::LESS_EQUAL : SQLFilterOperator::GREATER);
        m_aCodeList.emplace_back(pOperator);

        execute(pColumn);
        OOperand* pOb2 = execute(p2ndtValue);
        pOperator = new OOp_COMPARE(bNot ? SQLFilterOperator::GREATER_EQUAL : SQLFilterOperator::LESS);
        m_aCodeList.emplace_back(pOperator);

        if ( pColumnOp && pOb1 && pOb2 )
        {
            switch(pColumnOp->getDBType())
            {
                case DataType::CHAR:
                case DataType::VARCHAR:
                case DataType::LONGVARCHAR:
                    pOb1->setValue(pOb1->getValue().getString());
                    pOb2->setValue(pOb2->getValue().getString());
                    break;
                case DataType::DECIMAL:
                case DataType::NUMERIC:
                    pOb1->setValue(static_cast<double>(pOb1->getValue()));
                    pOb2->setValue(static_cast<double>(pOb2->getValue()));
                    break;
                case DataType::FLOAT:
                    pOb1->setValue(static_cast<float>(pOb1->getValue()));
                    pOb2->setValue(static_cast<float>(pOb2->getValue()));
                    break;
                case DataType::DOUBLE:
                case DataType::REAL:
                    pOb1->setValue(static_cast<double>(pOb1->getValue()));
                    pOb2->setValue(static_cast<double>(pOb2->getValue()));
                    break;
                case DataType::DATE:
                    pOb1->setValue(static_cast<util::Date>(pOb1->getValue()));
                    pOb2->setValue(static_cast<util::Date>(pOb2->getValue()));
                    break;
                case DataType::TIME:
                    pOb1->setValue(static_cast<util::Time>(pOb1->getValue()));
                    pOb2->setValue(static_cast<util::Time>(pOb2->getValue()));
                    break;
                case DataType::TIMESTAMP:
                    pOb1->setValue(static_cast<util::DateTime>(pOb1->getValue()));
                    pOb2->setValue(static_cast<util::DateTime>(pOb2->getValue()));
                    break;
            }
        }

        OBoolOperator* pBoolOp = nullptr;
        if ( bNot )
            pBoolOp = new OOp_OR;
        else
            pBoolOp = new OOp_AND;
        m_aCodeList.emplace_back(pBoolOp);
    }

    void OPredicateCompiler::execute_ISNULL(OSQLParseNode const * pPredicateNode)
    {
        DBG_ASSERT(pPredicateNode->count() == 2,"OFILECursor: Error in Parse Tree");
        const OSQLParseNode* pPart2 = pPredicateNode->getChild(1);
        DBG_ASSERT(SQL_ISTOKEN(pPart2->getChild(0),IS),"OFILECursor: Error in Parse Tree");

        sal_Int32 ePredicateType;
        if (SQL_ISTOKEN(pPart2->getChild(1),NOT))
            ePredicateType = SQLFilterOperator::NOT_SQLNULL;
        else
            ePredicateType = SQLFilterOperator::SQLNULL;

        execute(pPredicateNode->getChild(0));
        OBoolOperator* pOperator = (ePredicateType == SQLFilterOperator::SQLNULL) ?
                                    new OOp_ISNULL : new OOp_ISNOTNULL;
        m_aCodeList.emplace_back(pOperator);
    }

    OOperand* OPredicateCompiler::execute_Operand(OSQLParseNode const * pPredicateNode)
    {
        OOperand* pOperand = nullptr;

        if (SQL_ISRULE(pPredicateNode,column_ref))
        {
            OUString aColumnName;
            if (pPredicateNode->count() == 1)
            {
                aColumnName = pPredicateNode->getChild(0)->getTokenValue();
            }
            else if (pPredicateNode->count() == 3)
            {
                if(SQL_ISRULE(pPredicateNode->getChild(2),column_val))
                    aColumnName = pPredicateNode->getChild(2)->getChild(0)->getTokenValue();
                else
                    aColumnName = pPredicateNode->getChild(2)->getTokenValue();
            }

            if(!m_orgColumns->hasByName(aColumnName))
            {
                const OUString sError( m_pAnalyzer->getConnection()->getResources().getResourceStringWithSubstitution(
                        STR_INVALID_COLUMNNAME,
                        "$columnname$", aColumnName
                     ) );
                ::dbtools::throwGenericSQLException( sError, nullptr );
            }
            css::uno::Reference< css::beans::XPropertySet> xCol;
            try
            {
                if (m_orgColumns->getByName(aColumnName) >>= xCol)
                {
                    pOperand = OSQLAnalyzer::createOperandAttr(Reference< XColumnLocate>(m_orgColumns,UNO_QUERY)->findColumn(aColumnName),xCol);
                }
                else
                {// Column doesn't exist in the Result-set
                    const OUString sError( m_pAnalyzer->getConnection()->getResources().getResourceStringWithSubstitution(
                        STR_INVALID_COLUMNNAME,
                        "$columnname$", aColumnName
                     ) );
                    ::dbtools::throwGenericSQLException( sError, nullptr );
                }
            }
            catch(Exception &)
            {
                OSL_FAIL("OPredicateCompiler::execute_Operand Exception");
            }
        }
        else if (SQL_ISRULE(pPredicateNode,parameter))
        {
            pOperand = new OOperandParam(pPredicateNode, ++m_nParamCounter);
        }
        else if (pPredicateNode->getNodeType() == SQLNodeType::String ||
                 pPredicateNode->getNodeType() == SQLNodeType::IntNum ||
                 pPredicateNode->getNodeType() == SQLNodeType::ApproxNum ||
                 pPredicateNode->getNodeType() == SQLNodeType::Name ||
                 SQL_ISTOKEN(pPredicateNode,TRUE) ||
                 SQL_ISTOKEN(pPredicateNode,FALSE) ||
                 SQL_ISRULE(pPredicateNode,parameter))
        {
            pOperand = new OOperandConst(*pPredicateNode, pPredicateNode->getTokenValue());
        }
        else if((pPredicateNode->count() == 2) &&
                (SQL_ISPUNCTUATION(pPredicateNode->getChild(0),"+") || SQL_ISPUNCTUATION(pPredicateNode->getChild(0),"-")) &&
                pPredicateNode->getChild(1)->getNodeType() == SQLNodeType::IntNum)
        { // if -1 or +1 is there
            OUString aValue = pPredicateNode->getChild(0)->getTokenValue() + pPredicateNode->getChild(1)->getTokenValue();
            pOperand = new OOperandConst(*pPredicateNode->getChild(1), aValue);
        }
        else if( SQL_ISRULE(pPredicateNode,set_fct_spec) && SQL_ISPUNCTUATION(pPredicateNode->getChild(0),"{") )
        {
            const OSQLParseNode* pODBCNode = pPredicateNode->getChild(1);
            const OSQLParseNode* pODBCNodeChild = pODBCNode->getChild(0);

            // Odbc Date or time
            if (pODBCNodeChild->getNodeType() == SQLNodeType::Keyword && (
                SQL_ISTOKEN(pODBCNodeChild,D) ||
                SQL_ISTOKEN(pODBCNodeChild,T) ||
                SQL_ISTOKEN(pODBCNodeChild,TS) ))
            {
                OUString sDateTime = pODBCNode->getChild(1)->getTokenValue();
                pOperand = new OOperandConst(*pODBCNode->getChild(1), sDateTime);
                if(SQL_ISTOKEN(pODBCNodeChild,D))
                {
                    pOperand->setValue(::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDate(sDateTime)));
                }
                else if(SQL_ISTOKEN(pODBCNodeChild,T))
                {
                    pOperand->setValue(::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toTime(sDateTime)));
                }
                else if(SQL_ISTOKEN(pODBCNodeChild,TS))
                {
                    pOperand->setValue(::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDateTime(sDateTime)));
                }
            }
            else
                m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,nullptr);

        }
        else if( SQL_ISRULE(pPredicateNode,fold) )
        {
            execute_Fold(pPredicateNode);
        }
        else if(    SQL_ISRULE(pPredicateNode,set_fct_spec)
                ||  SQL_ISRULE(pPredicateNode,position_exp)
                ||  SQL_ISRULE(pPredicateNode,char_substring_fct)
                )
        {
            executeFunction(pPredicateNode);
        }
        else if( SQL_ISRULE(pPredicateNode,length_exp) )
        {
            executeFunction(pPredicateNode->getChild(0));
        }
        else
        {
            m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,nullptr);
        }
        if (pOperand)
            m_aCodeList.emplace_back(pOperand);
        return pOperand;
    }

    bool OPredicateInterpreter::evaluate(OCodeList& rCodeList)
    {
        static bool bResult;

        if (!(rCodeList[0]))
            return true;        // no Predicate

        for (auto const& code : rCodeList)
        {
            OOperand* pOperand = dynamic_cast<OOperand* >(code.get());
            if (pOperand)
                m_aStack.push(pOperand);
            else
                static_cast<OOperator *>(code.get())->Exec(m_aStack);
        }

        OOperand* pOperand = m_aStack.top();
        m_aStack.pop();

        DBG_ASSERT(m_aStack.empty(), "Stack error");
        DBG_ASSERT(pOperand, "Stack error");

        bResult = pOperand->isValid();
        if (typeid(OOperandResult) == typeid(*pOperand))
            delete pOperand;
        return bResult;
    }

    void OPredicateInterpreter::evaluateSelection(OCodeList& rCodeList, ORowSetValueDecoratorRef const & _rVal)
    {
        if (!(rCodeList[0]))
            return ;        // no Predicate

        for (auto const& code : rCodeList)
        {
            OOperand* pOperand = dynamic_cast<OOperand* >(code.get());
            if (pOperand)
                m_aStack.push(pOperand);
            else
                static_cast<OOperator *>(code.get())->Exec(m_aStack);
        }

        OOperand* pOperand = m_aStack.top();
        m_aStack.pop();

        DBG_ASSERT(m_aStack.empty(), "Stack error");
        DBG_ASSERT(pOperand, "Stack error");

        (*_rVal) = pOperand->getValue();
        if (typeid(OOperandResult) == typeid(*pOperand))
            delete pOperand;
    }

    void OPredicateCompiler::execute_Fold(OSQLParseNode const * pPredicateNode)
    {
        DBG_ASSERT(pPredicateNode->count() >= 4,"OFILECursor: Error in Parse Tree");

        bool bUpper = SQL_ISTOKEN(pPredicateNode->getChild(0),UPPER);

        execute(pPredicateNode->getChild(2));
        OOperator* pOperator = nullptr;
        if ( bUpper )
            pOperator = new OOp_Upper;
        else
            pOperator = new OOp_Lower;

        m_aCodeList.emplace_back(pOperator);
    }

    void OPredicateCompiler::executeFunction(OSQLParseNode const * pPredicateNode)
    {
        OOperator* pOperator = nullptr;

        OSL_ENSURE(pPredicateNode->getChild(0)->isToken(),"The first one must be the name of the function!");
        sal_Int32 nTokenId = pPredicateNode->getChild(0)->getTokenID();
        switch ( nTokenId )
        {
            case SQL_TOKEN_CHAR_LENGTH:
            case SQL_TOKEN_LENGTH:
            case SQL_TOKEN_OCTET_LENGTH:
            case SQL_TOKEN_ASCII:
            case SQL_TOKEN_LCASE:
            case SQL_TOKEN_LTRIM:
            case SQL_TOKEN_RTRIM:
            case SQL_TOKEN_SPACE:
            case SQL_TOKEN_UCASE:
            case SQL_TOKEN_ABS:
            case SQL_TOKEN_ACOS:
            case SQL_TOKEN_ASIN:
            case SQL_TOKEN_ATAN:
            case SQL_TOKEN_CEILING:
            case SQL_TOKEN_COS:
            case SQL_TOKEN_DEGREES:
            case SQL_TOKEN_EXP:
            case SQL_TOKEN_FLOOR:
            case SQL_TOKEN_LOG10:
            case SQL_TOKEN_LN:
            case SQL_TOKEN_RADIANS:
            case SQL_TOKEN_SIGN:
            case SQL_TOKEN_SIN:
            case SQL_TOKEN_SQRT:
            case SQL_TOKEN_TAN:
            case SQL_TOKEN_DAYNAME:
            case SQL_TOKEN_DAYOFMONTH:
            case SQL_TOKEN_DAYOFWEEK:
            case SQL_TOKEN_DAYOFYEAR:
            case SQL_TOKEN_HOUR:
            case SQL_TOKEN_MINUTE:
            case SQL_TOKEN_MONTH:
            case SQL_TOKEN_MONTHNAME:
            case SQL_TOKEN_QUARTER:
            case SQL_TOKEN_SECOND:
            case SQL_TOKEN_YEAR:

                execute(pPredicateNode->getChild(2));

                switch( nTokenId )
                {
                    case SQL_TOKEN_CHAR_LENGTH:
                    case SQL_TOKEN_LENGTH:
                    case SQL_TOKEN_OCTET_LENGTH:
                        pOperator = new OOp_CharLength;
                        break;
                    case SQL_TOKEN_ASCII:
                        pOperator = new OOp_Ascii;
                        break;
                    case SQL_TOKEN_LCASE:
                        pOperator = new OOp_Lower;
                        break;

                    case SQL_TOKEN_LTRIM:
                        pOperator = new OOp_LTrim;
                        break;
                    case SQL_TOKEN_RTRIM:
                        pOperator = new OOp_RTrim;
                        break;
                    case SQL_TOKEN_SPACE:
                        pOperator = new OOp_Space;
                        break;
                    case SQL_TOKEN_UCASE:
                        pOperator = new OOp_Upper;
                        break;
                    case SQL_TOKEN_ABS:
                        pOperator = new OOp_Abs;
                        break;
                    case SQL_TOKEN_ACOS:
                        pOperator = new OOp_ACos;
                        break;
                    case SQL_TOKEN_ASIN:
                        pOperator = new OOp_ASin;
                        break;
                    case SQL_TOKEN_ATAN:
                        pOperator = new OOp_ATan;
                        break;
                    case SQL_TOKEN_CEILING:
                        pOperator = new OOp_Ceiling;
                        break;
                    case SQL_TOKEN_COS:
                        pOperator = new OOp_Cos;
                        break;
                    case SQL_TOKEN_DEGREES:
                        pOperator = new OOp_Degrees;
                        break;
                    case SQL_TOKEN_EXP:
                        pOperator = new OOp_Exp;
                        break;
                    case SQL_TOKEN_FLOOR:
                        pOperator = new OOp_Floor;
                        break;
                    case SQL_TOKEN_LOG10:
                        pOperator = new OOp_Log10;
                        break;
                    case SQL_TOKEN_LN:
                        pOperator = new OOp_Ln;
                        break;
                    case SQL_TOKEN_RADIANS:
                        pOperator = new OOp_Radians;
                        break;
                    case SQL_TOKEN_SIGN:
                        pOperator = new OOp_Sign;
                        break;
                    case SQL_TOKEN_SIN:
                        pOperator = new OOp_Sin;
                        break;
                    case SQL_TOKEN_SQRT:
                        pOperator = new OOp_Sqrt;
                        break;
                    case SQL_TOKEN_TAN:
                        pOperator = new OOp_Tan;
                        break;
                    case SQL_TOKEN_DAYOFWEEK:
                        pOperator = new OOp_DayOfWeek;
                        break;
                    case SQL_TOKEN_DAYOFMONTH:
                        pOperator = new OOp_DayOfMonth;
                        break;
                    case SQL_TOKEN_DAYOFYEAR:
                        pOperator = new OOp_DayOfYear;
                        break;
                    case SQL_TOKEN_MONTH:
                        pOperator = new OOp_Month;
                        break;
                    case SQL_TOKEN_DAYNAME:
                        pOperator = new OOp_DayName;
                        break;
                    case SQL_TOKEN_MONTHNAME:
                        pOperator = new OOp_MonthName;
                        break;
                    case SQL_TOKEN_QUARTER:
                        pOperator = new OOp_Quarter;
                        break;
                    case SQL_TOKEN_YEAR:
                        pOperator = new OOp_Year;
                        break;
                    case SQL_TOKEN_HOUR:
                        pOperator = new OOp_Hour;
                        break;
                    case SQL_TOKEN_MINUTE:
                        pOperator = new OOp_Minute;
                        break;
                    case SQL_TOKEN_SECOND:
                        pOperator = new OOp_Second;
                        break;
                    default:
                        OSL_FAIL("Error in switch!");
                }
                break;
            case SQL_TOKEN_CHAR:
            case SQL_TOKEN_CONCAT:
            case SQL_TOKEN_INSERT:
            case SQL_TOKEN_LEFT:
            case SQL_TOKEN_LOCATE:
            case SQL_TOKEN_LOCATE_2:
            case SQL_TOKEN_REPEAT:
            case SQL_TOKEN_REPLACE:
            case SQL_TOKEN_RIGHT:
            case SQL_TOKEN_MOD:
            case SQL_TOKEN_ROUND:
            case SQL_TOKEN_LOGF:
            case SQL_TOKEN_LOG:
            case SQL_TOKEN_POWER:
            case SQL_TOKEN_ATAN2:
            case SQL_TOKEN_PI:
            case SQL_TOKEN_CURDATE:
            case SQL_TOKEN_CURTIME:
            case SQL_TOKEN_NOW:
            case SQL_TOKEN_WEEK:
                {
                    m_aCodeList.emplace_back(new OStopOperand);
                    OSQLParseNode* pList = pPredicateNode->getChild(2);
                    for (size_t i=0; i < pList->count(); ++i)
                        execute(pList->getChild(i));

                    switch( nTokenId )
                    {
                        case SQL_TOKEN_CHAR:
                            pOperator = new OOp_Char;
                            break;
                        case SQL_TOKEN_CONCAT:
                            pOperator = new OOp_Concat;
                            break;
                        case SQL_TOKEN_INSERT:
                            pOperator = new OOp_Insert;
                            break;
                        case SQL_TOKEN_LEFT:
                            pOperator = new OOp_Left;
                            break;
                        case SQL_TOKEN_LOCATE:
                        case SQL_TOKEN_LOCATE_2:
                            pOperator = new OOp_Locate;
                            break;
                        case SQL_TOKEN_REPEAT:
                            pOperator = new OOp_Repeat;
                            break;
                        case SQL_TOKEN_REPLACE:
                            pOperator = new OOp_Replace;
                            break;
                        case SQL_TOKEN_RIGHT:
                            pOperator = new OOp_Right;
                            break;
                        case SQL_TOKEN_MOD:
                            pOperator = new OOp_Mod;
                            break;
                        case SQL_TOKEN_ROUND:
                            pOperator = new OOp_Round;
                            break;
                        case SQL_TOKEN_LOGF:
                        case SQL_TOKEN_LOG:
                            pOperator = new OOp_Log;
                            break;
                        case SQL_TOKEN_POWER:
                            pOperator = new OOp_Pow;
                            break;
                        case SQL_TOKEN_ATAN2:
                            pOperator = new OOp_ATan2;
                            break;
                        case SQL_TOKEN_PI:
                            pOperator = new OOp_Pi;
                            break;
                        case SQL_TOKEN_CURDATE:
                            pOperator = new OOp_CurDate;
                            break;
                        case SQL_TOKEN_CURTIME:
                            pOperator = new OOp_CurTime;
                            break;
                        case SQL_TOKEN_NOW:
                            pOperator = new OOp_Now;
                            break;
                        case SQL_TOKEN_WEEK:
                            pOperator = new OOp_Week;
                            break;
                        default:
                            OSL_FAIL("Error in switch!");
                    }
                }
                break;

            case SQL_TOKEN_SUBSTRING:
                m_aCodeList.emplace_back(new OStopOperand);
                if ( pPredicateNode->count() == 4 ) //char_substring_fct
                {
                    OSQLParseNode* pList = pPredicateNode->getChild(2);
                    for (size_t i=0; i < pList->count(); ++i)
                        execute(pList->getChild(i));
                }
                else
                {
                    execute(pPredicateNode->getChild(2));
                    execute(pPredicateNode->getChild(4));
                    execute(pPredicateNode->getChild(5)->getChild(1));
                }
                pOperator = new OOp_SubString;
                break;

            case SQL_TOKEN_POSITION:
                m_aCodeList.emplace_back(new OStopOperand);
                if ( pPredicateNode->count() == 4 ) //position_exp
                {
                    OSQLParseNode* pList = pPredicateNode->getChild(2);
                    for (size_t i=0; i < pList->count(); ++i)
                        execute(pList->getChild(i));
                }
                else
                {
                    execute(pPredicateNode->getChild(2));
                    execute(pPredicateNode->getChild(4));
                }
                pOperator = new OOp_Locate;
                break;
            default:
                m_pAnalyzer->getConnection()->throwGenericSQLException(STR_QUERY_FUNCTION_NOT_SUPPORTED,nullptr);
        }

        m_aCodeList.emplace_back(pOperator);
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'm_aCodeList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.