connectivity/source/drivers/file/fcode.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <file/fcode.hxx>
  21 #include <osl/diagnose.h>
  22 #include <sal/log.hxx>
  23 #include <connectivity/sqlparse.hxx>
  24 #include <sqlbison.hxx>
  25 #include <com/sun/star/sdb/SQLFilterOperator.hpp>
  26
  27 using namespace ::comphelper;
  28 using namespace connectivity;
  29 using namespace connectivity::file;
  30 using namespace ::com::sun::star::sdbc;
  31 using namespace ::com::sun::star::sdb;
  32
  33 OCode::~OCode() = default;
  34
  35 OOperandRow::OOperandRow(sal_uInt16 _nPos, sal_Int32 _rType)
  36     : OOperand(_rType)
  37     , m_nRowPos(_nPos)
  38 {}
  39
  40 void OOperandRow::bindValue(const OValueRefRow& _pRow)
  41 {
  42     OSL_ENSURE(_pRow.is(),"NO EMPTY row allowed!");
  43     m_pRow = _pRow;
  44     OSL_ENSURE(m_pRow.is() && m_nRowPos < m_pRow->size(),"Invalid RowPos is >= vector.size()");
  45     (*m_pRow)[m_nRowPos]->setBound(true);
  46 }
  47
  48 void OOperandRow::setValue(const ORowSetValue& _rVal)
  49 {
  50     OSL_ENSURE(m_pRow.is() && m_nRowPos < m_pRow->size(),"Invalid RowPos is >= vector.size()");
  51     (*(*m_pRow)[m_nRowPos]) = _rVal;
  52 }
  53
  54 const ORowSetValue& OOperandRow::getValue() const
  55 {
  56     OSL_ENSURE(m_pRow.is() && m_nRowPos < m_pRow->size(),"Invalid RowPos is >= vector.size()");
  57     return (*m_pRow)[m_nRowPos]->getValue();
  58 }
  59
  60
  61 void OOperandValue::setValue(const ORowSetValue& _rVal)
  62 {
  63     m_aValue = _rVal;
  64 }
  65
  66 OOperandParam::OOperandParam(OSQLParseNode const * pNode, sal_Int32 _nPos)
  67     : OOperandRow(static_cast<sal_uInt16>(_nPos), DataType::VARCHAR)         // Standard-Type
  68 {
  69     OSL_ENSURE(SQL_ISRULE(pNode,parameter),"Argument is not a parameter");
  70     OSL_ENSURE(pNode->count() > 0,"Error in Parse Tree");
  71     OSQLParseNode *pMark = pNode->getChild(0);
  72
  73     OUString aParameterName;
  74     if (SQL_ISPUNCTUATION(pMark, "?"))
  75         aParameterName = "?";
  76     else if (SQL_ISPUNCTUATION(pMark, ":"))
  77         aParameterName = pNode->getChild(1)->getTokenValue();
  78     else
  79     {
  80         SAL_WARN( "connectivity.drivers","Error in Parse Tree");
  81     }
  82
  83     // set up Parameter-Column with default type, can be specified more precisely later using Describe-Parameter
  84
  85     // save Identity (not especially necessary here, just for the sake of symmetry)
  86
  87     // todo
  88     //  OColumn* pColumn = new OFILEColumn(aParameterName,eDBType,255,0,SQL_FLAGS_NULLALLOWED);
  89     //  rParamColumns->AddColumn(pColumn);
  90
  91     // the value will be set just before the evaluation
  92 }
  93
  94
  95 const ORowSetValue& OOperandValue::getValue() const
  96 {
  97     return m_aValue;
  98 }
  99
 100
 101 OOperandConst::OOperandConst(const OSQLParseNode& rColumnRef, const OUString& aStrValue)
 102 {
 103     switch (rColumnRef.getNodeType())
 104     {
 105     case SQLNodeType::String:
 106         m_aValue = aStrValue;
 107         m_eDBType = DataType::VARCHAR;
 108         m_aValue.setBound(true);
 109         return;
 110     case SQLNodeType::IntNum:
 111     case SQLNodeType::ApproxNum:
 112         m_aValue = aStrValue.toDouble();
 113         m_eDBType = DataType::DOUBLE;
 114         m_aValue.setBound(true);
 115         return;
 116     default:
 117         break;
 118     }
 119
 120     if (SQL_ISTOKEN(&rColumnRef, TRUE))
 121     {
 122         m_aValue = 1.0;
 123         m_eDBType = DataType::BIT;
 124     }
 125     else if (SQL_ISTOKEN(&rColumnRef, FALSE))
 126     {
 127         m_aValue = 0.0;
 128         m_eDBType = DataType::BIT;
 129     }
 130     else
 131     {
 132         SAL_WARN( "connectivity.drivers", "Parse Error");
 133     }
 134     m_aValue.setBound(true);
 135 }
 136
 137
 138 // Implementation of the operators
 139
 140
 141 bool OBoolOperator::operate(const OOperand*, const OOperand*) const
 142 {
 143     return false;
 144 }
 145
 146
 147 void OBoolOperator::Exec(OCodeStack& rCodeStack)
 148 {
 149     OOperand  *pRight   = rCodeStack.top();
 150     rCodeStack.pop();
 151     OOperand  *pLeft    = rCodeStack.top();
 152     rCodeStack.pop();
 153
 154     rCodeStack.push(new OOperandResultBOOL(operate(pLeft, pRight)));
 155     if( typeid(OOperandResult) == typeid(*pLeft))
 156         delete pLeft;
 157     if( typeid(OOperandResult) == typeid(*pRight))
 158         delete pRight;
 159 }
 160
 161 bool OOp_NOT::operate(const OOperand* pLeft, const OOperand* ) const
 162 {
 163     return !pLeft->isValid();
 164 }
 165
 166 void OOp_NOT::Exec(OCodeStack& rCodeStack)
 167 {
 168     OOperand* pOperand = rCodeStack.top();
 169     rCodeStack.pop();
 170
 171     rCodeStack.push(new OOperandResultBOOL(operate(pOperand, nullptr)));
 172
 173     if( typeid(OOperandResult) == typeid(*pOperand))
 174         delete pOperand;
 175 }
 176
 177 bool OOp_AND::operate(const OOperand* pLeft, const OOperand* pRight) const
 178 {
 179     return pLeft->isValid() && pRight->isValid();
 180 }
 181
 182
 183 bool OOp_OR::operate(const OOperand* pLeft, const OOperand* pRight) const
 184 {
 185     return pLeft->isValid() || pRight->isValid();
 186 }
 187
 188
 189 void OOp_ISNULL::Exec(OCodeStack& rCodeStack)
 190 {
 191     OOperand* pOperand = rCodeStack.top();
 192     rCodeStack.pop();
 193
 194     rCodeStack.push(new OOperandResultBOOL(operate(pOperand, nullptr)));
 195     if( typeid(OOperandResult) == typeid(*pOperand))
 196         delete pOperand;
 197 }
 198
 199
 200 bool OOp_ISNULL::operate(const OOperand* pOperand, const OOperand*) const
 201 {
 202     return pOperand->getValue().isNull();
 203 }
 204
 205
 206 bool OOp_ISNOTNULL::operate(const OOperand* pOperand, const OOperand*) const
 207 {
 208     return !OOp_ISNULL::operate(pOperand, nullptr);
 209 }
 210
 211
 212 bool OOp_LIKE::operate(const OOperand* pLeft, const OOperand* pRight) const
 213 {
 214     bool bMatch;
 215     const ORowSetValue& aLH(pLeft->getValue());
 216     const ORowSetValue& aRH(pRight->getValue());
 217
 218     if (aLH.isNull() || aRH.isNull())
 219         bMatch = false;
 220     else
 221     {
 222         bMatch = match(aRH.getString(), aLH.getString(), cEscape);
 223     }
 224     return bMatch;
 225 }
 226
 227
 228 bool OOp_NOTLIKE::operate(const OOperand* pLeft, const OOperand* pRight) const
 229 {
 230     return !OOp_LIKE::operate(pLeft, pRight);
 231 }
 232
 233
 234 bool OOp_COMPARE::operate(const OOperand* pLeft, const OOperand* pRight) const
 235 {
 236     const ORowSetValue& aLH(pLeft->getValue());
 237     const ORowSetValue& aRH(pRight->getValue());
 238
 239     if (aLH.isNull() || aRH.isNull()) // if (!aLH.getValue() || !aRH.getValue())
 240         return false;
 241
 242     bool bResult = false;
 243     sal_Int32 eDBType = pLeft->getDBType();
 244
 245     // Comparison (depending on Data-type):
 246     switch (eDBType)
 247     {
 248         case DataType::CHAR:
 249         case DataType::VARCHAR:
 250         case DataType::LONGVARCHAR:
 251         {
 252             OUString sLH = aLH, sRH = aRH;
 253             sal_Int32 nRes = sLH.compareToIgnoreAsciiCase(sRH);
 254             switch(aPredicateType)
 255             {
 256                 case SQLFilterOperator::EQUAL:          bResult = (nRes == 0); break;
 257                 case SQLFilterOperator::NOT_EQUAL:          bResult = (nRes != 0); break;
 258                 case SQLFilterOperator::LESS:               bResult = (nRes <  0); break;
 259                 case SQLFilterOperator::LESS_EQUAL:     bResult = (nRes <= 0); break;
 260                 case SQLFilterOperator::GREATER:            bResult = (nRes >  0); break;
 261                 case SQLFilterOperator::GREATER_EQUAL:  bResult = (nRes >= 0); break;
 262                 default:                        bResult = false;
 263             }
 264         } break;
 265         case DataType::TINYINT:
 266         case DataType::SMALLINT:
 267         case DataType::INTEGER:
 268         case DataType::DECIMAL:
 269         case DataType::NUMERIC:
 270         case DataType::REAL:
 271         case DataType::DOUBLE:
 272         case DataType::BIT:
 273         case DataType::TIMESTAMP:
 274         case DataType::DATE:
 275         case DataType::TIME:
 276         {
 277             double n = aLH ,m = aRH;
 278
 279             switch (aPredicateType)
 280             {
 281                 case SQLFilterOperator::EQUAL:          bResult = (n == m); break;
 282                 case SQLFilterOperator::LIKE:               bResult = (n == m); break;
 283                 case SQLFilterOperator::NOT_EQUAL:          bResult = (n != m); break;
 284                 case SQLFilterOperator::NOT_LIKE:           bResult = (n != m); break;
 285                 case SQLFilterOperator::LESS:               bResult = (n < m); break;
 286                 case SQLFilterOperator::LESS_EQUAL:     bResult = (n <= m); break;
 287                 case SQLFilterOperator::GREATER:            bResult = (n > m); break;
 288                 case SQLFilterOperator::GREATER_EQUAL:  bResult = (n >= m); break;
 289                 default:                        bResult = false;
 290             }
 291         } break;
 292         default:
 293             bResult = aLH == aRH;
 294     }
 295     return bResult;
 296 }
 297
 298
 299 void ONumOperator::Exec(OCodeStack& rCodeStack)
 300 {
 301     OOperand  *pRight   = rCodeStack.top();
 302     rCodeStack.pop();
 303     OOperand  *pLeft    = rCodeStack.top();
 304     rCodeStack.pop();
 305
 306     rCodeStack.push(new OOperandResultNUM(operate(pLeft->getValue(), pRight->getValue())));
 307     if( typeid(OOperandResult) == typeid(*pLeft))
 308         delete pLeft;
 309     if( typeid(OOperandResult) == typeid(*pRight))
 310         delete pRight;
 311 }
 312
 313 double OOp_ADD::operate(const double& fLeft,const double& fRight) const
 314 {
 315     return fLeft + fRight;
 316 }
 317
 318
 319 double OOp_SUB::operate(const double& fLeft,const double& fRight) const
 320 {
 321     return fLeft - fRight;
 322 }
 323
 324
 325 double OOp_MUL::operate(const double& fLeft,const double& fRight) const
 326 {
 327     return fLeft * fRight;
 328 }
 329
 330
 331 double OOp_DIV::operate(const double& fLeft,const double& fRight) const
 332 {
 333     return fLeft / fRight;
 334 }
 335
 336 void ONthOperator::Exec(OCodeStack& rCodeStack)
 337 {
 338     std::vector<ORowSetValue> aValues;
 339     std::vector<OOperand*> aOperands;
 340     OOperand* pOperand;
 341     do
 342     {
 343         OSL_ENSURE(!rCodeStack.empty(),"Stack must be none empty!");
 344         pOperand    = rCodeStack.top();
 345         rCodeStack.pop();
 346         assert(pOperand);
 347         if (pOperand && typeid(OStopOperand) != typeid(*pOperand))
 348             aValues.push_back( pOperand->getValue() );
 349         aOperands.push_back( pOperand );
 350     }
 351     while (pOperand && typeid(OStopOperand) != typeid(*pOperand));
 352
 353     rCodeStack.push(new OOperandResult(operate(aValues)));
 354
 355     for (const auto& rpOperand : aOperands)
 356     {
 357         if (typeid(OOperandResult) == typeid(*rpOperand))
 358             delete rpOperand;
 359     }
 360 }
 361
 362 void OBinaryOperator::Exec(OCodeStack& rCodeStack)
 363 {
 364     OOperand  *pRight   = rCodeStack.top();
 365     rCodeStack.pop();
 366     OOperand  *pLeft    = rCodeStack.top();
 367     rCodeStack.pop();
 368
 369     if ( !rCodeStack.empty() && typeid(OStopOperand) == typeid(*rCodeStack.top()) )
 370         rCodeStack.pop();
 371
 372     rCodeStack.push(new OOperandResult(operate(pLeft->getValue(),pRight->getValue())));
 373     if(typeid(OOperandResult) == typeid(*pRight))
 374         delete pRight;
 375     if(typeid(OOperandResult) == typeid(*pLeft))
 376         delete pLeft;
 377 }
 378
 379 void OUnaryOperator::Exec(OCodeStack& rCodeStack)
 380 {
 381     OSL_ENSURE(!rCodeStack.empty(),"Stack is empty!");
 382     OOperand* pOperand = rCodeStack.top();
 383     rCodeStack.pop();
 384
 385     rCodeStack.push(new OOperandResult(operate(pOperand->getValue())));
 386     if (typeid(OOperandResult) == typeid(*pOperand))
 387         delete pOperand;
 388 }
 389
 390
 391 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */