883 lines
32 KiB
C++
883 lines
32 KiB
C++
/* -*- 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 <connectivity/sqlparse.hxx>
|
|
#include <file/fanalyzer.hxx>
|
|
#include <com/sun/star/sdbc/XColumnLocate.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 <comphelper/diagnose_ex.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;
|
|
}
|
|
|
|
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);
|
|
assert(pTableExp && "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 : SQLFilterOperator::GREATER_EQUAL);
|
|
m_aCodeList.emplace_back(pOperator);
|
|
|
|
execute(pColumn);
|
|
OOperand* pOb2 = execute(p2ndtValue);
|
|
pOperator = new OOp_COMPARE(bNot ? SQLFilterOperator::GREATER : SQLFilterOperator::LESS_EQUAL);
|
|
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:
|
|
case DataType::DOUBLE:
|
|
case DataType::REAL:
|
|
pOb1->setValue(pOb1->getValue().getDouble());
|
|
pOb2->setValue(pOb2->getValue().getDouble());
|
|
break;
|
|
case DataType::FLOAT:
|
|
pOb1->setValue(pOb1->getValue().getFloat());
|
|
pOb2->setValue(pOb2->getValue().getFloat());
|
|
break;
|
|
case DataType::DATE:
|
|
pOb1->setValue(pOb1->getValue().getDate());
|
|
pOb2->setValue(pOb2->getValue().getDate());
|
|
break;
|
|
case DataType::TIME:
|
|
pOb1->setValue(pOb1->getValue().getTime());
|
|
pOb2->setValue(pOb2->getValue().getTime());
|
|
break;
|
|
case DataType::TIMESTAMP:
|
|
pOb1->setValue(pOb1->getValue().getDateTime());
|
|
pOb2->setValue(pOb2->getValue().getDateTime());
|
|
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_THROW)->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 &)
|
|
{
|
|
TOOLS_WARN_EXCEPTION( "connectivity.drivers", "OPredicateCompiler::execute_Operand Exception");
|
|
}
|
|
}
|
|
else if (SQL_ISRULE(pPredicateNode,parameter))
|
|
{
|
|
pOperand = new OOperandParam(++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)
|
|
{
|
|
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");
|
|
assert(pOperand && "Stack error");
|
|
|
|
const bool 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");
|
|
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: */
|