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