Expr.cpp

#include "Expr.h"

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "SelectStatement.h"

namespace hsql {

FrameBound::FrameBound(int64_t offset, FrameBoundType type, bool unbounded)
    : offset{offset}, type{type}, unbounded{unbounded} {}

FrameDescription::FrameDescription(FrameType type, FrameBound* start, FrameBound* end)
    : type{type}, start{start}, end{end} {}

FrameDescription::~FrameDescription() {
  delete start;
  delete end;
}

WindowDescription::WindowDescription(std::vector<Expr*>* partitionList, std::vector<OrderDescription*>* orderList,
                                     FrameDescription* frameDescription)
    : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {}

WindowDescription::~WindowDescription() {
  if (partitionList) {
    for (Expr* e : *partitionList) {
      delete e;
    }
    delete partitionList;
  }

  if (orderList) {
    for (OrderDescription* orderDescription : *orderList) {
      delete orderDescription;
    }
    delete orderList;
  }

  delete frameDescription;
}

Expr::Expr(ExprType type)
    : type(type),
      expr(nullptr),
      expr2(nullptr),
      exprList(nullptr),
      select(nullptr),
      name(nullptr),
      table(nullptr),
      schema(nullptr),
      alias(nullptr),
      fval(0),
      ival(0),
      ival2(0),
      datetimeField(kDatetimeNone),
      columnType(DataType::UNKNOWN, 0),
      isBoolLiteral(false),
      opType(kOpNone),
      distinct(false),
      windowDescription(nullptr) {}

Expr::~Expr() {
  delete expr;
  delete expr2;
  delete select;
  delete windowDescription;

  free(name);
  free(table);
  free(schema);
  free(alias);

  if (exprList) {
    for (Expr* e : *exprList) {
      delete e;
    }
    delete exprList;
  }
}

Expr* Expr::make(ExprType type) {
  Expr* e = new Expr(type);
  return e;
}

Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr;
  e->expr2 = nullptr;
  return e;
}

Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr1;
  e->expr2 = expr2;
  return e;
}

Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) {
  Expr* e = new Expr(kExprOperator);
  e->expr = expr;
  e->opType = kOpBetween;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(left);
  e->exprList->push_back(right);
  return e;
}

Expr* Expr::makeCaseList(Expr* caseListElement) {
  Expr* e = new Expr(kExprOperator);
  // Case list expressions are temporary and will be integrated into the case
  // expressions exprList - thus assign operator type kOpNone
  e->opType = kOpNone;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(caseListElement);
  return e;
}

Expr* Expr::makeCaseListElement(Expr* when, Expr* then) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCaseListElement;
  e->expr = when;
  e->expr2 = then;
  return e;
}

Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) {
  caseList->exprList->push_back(caseListElement);
  return caseList;
}

Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCase;
  e->expr = expr;
  e->expr2 = elseExpr;
  e->exprList = caseList->exprList;
  caseList->exprList = nullptr;
  delete caseList;
  return e;
}

Expr* Expr::makeLiteral(int64_t val) {
  Expr* e = new Expr(kExprLiteralInt);
  e->ival = val;
  return e;
}

Expr* Expr::makeLiteral(double value) {
  Expr* e = new Expr(kExprLiteralFloat);
  e->fval = value;
  return e;
}

Expr* Expr::makeLiteral(char* string) {
  Expr* e = new Expr(kExprLiteralString);
  e->name = string;
  return e;
}

Expr* Expr::makeLiteral(bool val) {
  Expr* e = new Expr(kExprLiteralInt);
  e->ival = (int)val;
  e->isBoolLiteral = true;
  return e;
}

Expr* Expr::makeNullLiteral() {
  Expr* e = new Expr(kExprLiteralNull);
  return e;
}

Expr* Expr::makeDateLiteral(char* string) {
  Expr* e = new Expr(kExprLiteralDate);
  e->name = string;
  return e;
}

Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) {
  Expr* e = new Expr(kExprLiteralInterval);
  e->ival = duration;
  e->datetimeField = unit;
  return e;
}

Expr* Expr::makeIntervalLiteral(char* duration, DatetimeField unit) {
  Expr* e = new Expr(kExprLiteralInterval);
  e->name = duration;
  e->datetimeField = unit;
  return e;
}

Expr* Expr::makeColumnRef(char* name) {
  Expr* e = new Expr(kExprColumnRef);
  e->name = name;
  return e;
}

Expr* Expr::makeColumnRef(char* table, char* name) {
  Expr* e = new Expr(kExprColumnRef);
  e->name = name;
  e->table = table;
  return e;
}

Expr* Expr::makeStar(void) {
  Expr* e = new Expr(kExprStar);
  return e;
}

Expr* Expr::makeStar(char* table) {
  Expr* e = new Expr(kExprStar);
  e->table = table;
  return e;
}

Expr* Expr::makeFunctionRef(char* func_name, std::vector<Expr*>* exprList, bool distinct, WindowDescription* window) {
  Expr* e = new Expr(kExprFunctionRef);
  e->name = func_name;
  e->exprList = exprList;
  e->distinct = distinct;
  e->windowDescription = window;
  return e;
}

Expr* Expr::makeFunctionRef(char* func_name, char* schema, std::vector<Expr*>* exprList, bool distinct, WindowDescription* window) {
  Expr* e = new Expr(kExprFunctionRef);
  e->name = func_name;
  e->schema = schema;
  e->exprList = exprList;
  e->distinct = distinct;
  e->windowDescription = window;
  return e;
}

Expr* Expr::makeArray(std::vector<Expr*>* exprList) {
  Expr* e = new Expr(kExprArray);
  e->exprList = exprList;
  return e;
}

Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) {
  Expr* e = new Expr(kExprArrayIndex);
  e->expr = expr;
  e->ival = index;
  return e;
}

Expr* Expr::makeParameter(int id) {
  Expr* e = new Expr(kExprParameter);
  e->ival = id;
  return e;
}

Expr* Expr::makeSelect(SelectStatement* select) {
  Expr* e = new Expr(kExprSelect);
  e->select = select;
  return e;
}

Expr* Expr::makeExists(SelectStatement* select) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpExists;
  e->select = select;
  return e;
}

Expr* Expr::makeInOperator(Expr* expr, std::vector<Expr*>* exprList) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpIn;
  e->expr = expr;
  e->exprList = exprList;

  return e;
}

Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpIn;
  e->expr = expr;
  e->select = select;

  return e;
}

Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) {
  Expr* e = new Expr(kExprExtract);
  e->datetimeField = datetimeField;
  e->expr = expr;
  return e;
}

Expr* Expr::makeCast(Expr* expr, ColumnType columnType) {
  Expr* e = new Expr(kExprCast);
  e->columnType = columnType;
  e->expr = expr;
  return e;
}

bool Expr::isType(ExprType exprType) const { return exprType == type; }

bool Expr::isLiteral() const {
  return isType(kExprLiteralInt) || isType(kExprLiteralFloat) || isType(kExprLiteralString) || isType(kExprParameter) ||
         isType(kExprLiteralNull) || isType(kExprLiteralDate) || isType(kExprLiteralInterval);
}

bool Expr::hasAlias() const { return alias != nullptr; }

bool Expr::hasTable() const { return table != nullptr; }

const char* Expr::getName() const {
  if (alias)
    return alias;
  else
    return name;
}

char* substr(const char* source, int from, int to) {
  int len = to - from;
  char* copy = (char*)malloc(len + 1);
  ;
  strncpy(copy, source + from, len);
  copy[len] = '\0';
  return copy;
}
}  // namespace hsql