File indexing completed on 2024-04-21 15:29:55

 /* This file is part of the KDE project
    Copyright (C) 2003-2016 Jarosław Staniek <staniek@kde.org>
 
    Based on nexp.cpp : Parser module of Python-like language
    (C) 2001 Jarosław Staniek, MIMUW (www.mimuw.edu.pl)
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KDbExpression.h"
 #include "KDb.h"
 #include "KDbQuerySchema.h"
 #include "KDbDriver.h"
 #include "kdb_debug.h"
 #include "generated/sqlparser.h"
 
 KDbUnaryExpressionData::KDbUnaryExpressionData()
  : KDbExpressionData()
 {
     ExpressionDebug << "UnaryExpressionData" << ref;
 }
 
 KDbUnaryExpressionData::~KDbUnaryExpressionData()
 {
     ExpressionDebug << "~UnaryExpressionData" << ref;
 }
 
 KDbUnaryExpressionData* KDbUnaryExpressionData::clone()
 {
     ExpressionDebug << "UnaryExpressionData::clone" << *this;
     return new KDbUnaryExpressionData(*this);
 }
 
 void KDbUnaryExpressionData::debugInternal(QDebug dbg, KDb::ExpressionCallStack* callStack) const
 {
     dbg.nospace() << "UnaryExp("
            << token << ",";
     if (children.isEmpty()) {
         dbg.nospace() << "<NONE>";
     }
     else {
         ExplicitlySharedExpressionDataPointer a = arg();
         if (a.data()) {
             a->debug(dbg, callStack);
         }
         else {
             dbg.nospace() << "<NONE>";
         }
     }
     dbg.nospace() << qPrintable(QString::fromLatin1(",type=%1)")
         .arg(KDbDriver::defaultSqlTypeName(type())));
 }
 
 KDbEscapedString KDbUnaryExpressionData::toStringInternal(
                                         const KDbDriver *driver,
                                         KDbQuerySchemaParameterValueListIterator* params,
                                         KDb::ExpressionCallStack* callStack) const
 {
     ExplicitlySharedExpressionDataPointer a = arg();
     KDbEscapedString aString = a.constData()
             ? a->toString(driver, params, callStack) : KDbEscapedString("<NULL>");
     if (token == '(') { //parentheses (special case)
         return "(" + aString + ")";
     }
     if (token.toChar() > 0) {
         return token.toString(driver) + aString;
     }
     switch (token.value()) {
     case NOT:
         return "NOT " + aString;
     case SQL_IS_NULL:
         return aString + " IS NULL";
     case SQL_IS_NOT_NULL:
         return aString + " IS NOT NULL";
     }
     return KDbEscapedString("%1 %2").arg(token.toString(driver)).arg(aString);
 }
 
 void KDbUnaryExpressionData::getQueryParameters(QList<KDbQuerySchemaParameter>* params)
 {
     Q_ASSERT(params);
     ExplicitlySharedExpressionDataPointer a = arg();
     if (a.constData())
         a->getQueryParameters(params);
 }
 
 KDbField::Type KDbUnaryExpressionData::typeInternal(KDb::ExpressionCallStack* callStack) const
 {
     if (children.isEmpty()) {
         return KDbField::InvalidType;
     }
     ExplicitlySharedExpressionDataPointer a = arg();
     if (!a.constData())
         return KDbField::InvalidType;
 
     //NULL IS NOT NULL : BOOLEAN
     //NULL IS NULL : BOOLEAN
     switch (token.value()) {
     case SQL_IS_NULL:
     case SQL_IS_NOT_NULL:
         //! @todo queryParameterExpressionData->m_type still is Text but can be any type
         return KDbField::Boolean;
     }
 
     KDbQueryParameterExpressionData *queryParameterExpressionData = a->convert<KDbQueryParameterExpressionData>();
     if (queryParameterExpressionData) {
         switch (token.value()) {
         case '+':
         case '-':
         case '~':
             queryParameterExpressionData->m_type = KDbField::Integer;
             break;
         case '!':
         case NOT:
             queryParameterExpressionData->m_type = KDbField::Boolean;
             break;
         default:;
         }
     }
     KDbField::Type t = a->type(callStack);
     if (t == KDbField::Null)
         return KDbField::Null;
     if (token == KDbToken::NOT) {
         return t == KDbField::Boolean ? KDbField::Boolean : KDbField::InvalidType;
     }
     return t;
 }
 
 bool KDbUnaryExpressionData::validateInternal(KDbParseInfo *parseInfo, KDb::ExpressionCallStack* callStack)
 {
     ExplicitlySharedExpressionDataPointer a = arg();
     if (!a.constData())
         return false;
 
     if (!a->validate(parseInfo, callStack))
         return false;
 
 //! @todo compare types... e.g. NOT applied to Text makes no sense...
 
     // update type
 //! @todo IMPORTANT: update type
 #if 0
     if (a->toQueryParameter()) {
         a->toQueryParameter()->setType(type());
     }
 #endif
 
     return typeInternal(callStack) != KDbField::InvalidType;
 #if 0
     KDbExpression *n = l.at(0);
 
     n->check();
     /*typ wyniku:
         const bool for "NOT <bool>" (negative)
         int for "# <str>" (string length)
         int for "+/- <int>"
         */
     if (is(NOT) && n->nodeTypeIs(TYP_BOOL)) {
         node_type = new NConstType(TYP_BOOL);
     } else if (is('#') && n->nodeTypeIs(TYP_STR)) {
         node_type = new NConstType(TYP_INT);
     } else if ((is('+') || is('-')) && n->nodeTypeIs(TYP_INT)) {
         node_type = new NConstType(TYP_INT);
     } else {
         ERR("Invalid argument of type '%s' for operator '%s'",
             n->nodeTypeName(), is(NOT) ? QString("not") : QChar(typ()));
     }
 #endif
 }
 
 //=========================================
 
 KDbUnaryExpression::KDbUnaryExpression()
  : KDbExpression(new KDbUnaryExpressionData)
 {
     ExpressionDebug << "KDbUnaryExpression() ctor" << *this;
 }
 
 KDbUnaryExpression::KDbUnaryExpression(KDbToken token, const KDbExpression& arg)
         : KDbExpression(new KDbUnaryExpressionData, KDb::UnaryExpression, token)
 {
     appendChild(arg.d);
 }
 
 KDbUnaryExpression::KDbUnaryExpression(KDbExpressionData* data)
  : KDbExpression(data)
 {
     ExpressionDebug << "KDbUnaryExpression(KDbExpressionData*) ctor" << *this;
 }
 
 KDbUnaryExpression::KDbUnaryExpression(const KDbUnaryExpression& expr)
         : KDbExpression(expr)
 {
 }
 
 KDbUnaryExpression::KDbUnaryExpression(const ExplicitlySharedExpressionDataPointer &ptr)
     : KDbExpression(ptr)
 {
 }
 
 KDbUnaryExpression::~KDbUnaryExpression()
 {
 }
 
 KDbExpression KDbUnaryExpression::arg() const
 {
     return KDbExpression(d->convertConst<KDbUnaryExpressionData>()->arg());
 }
 
 void KDbUnaryExpression::setArg(const KDbExpression &arg)
 {
     if (!d->children.isEmpty()) {
         removeChild(0);
     }
     insertChild(0, arg);
 }