CalciteDeserializerUtils.h File Reference

#include "DateAdd.h"
#include "DateTruncate.h"
#include "../Shared/sqldefs.h"
#include "../Shared/sqltypes.h"
#include "Logger/Logger.h"

Include dependency graph for CalciteDeserializerUtils.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
	Analyzer

Functions
SQLOps	to_sql_op (const std::string &op_str)
SQLAgg	to_agg_kind (const std::string &agg_name)
SQLTypes	to_sql_type (const std::string &type_name)
SQLTypeInfo	get_agg_type (const SQLAgg agg_kind, const Analyzer::Expr *arg_expr)
ExtractField	to_datepart_field (const std::string &)
DateaddField	to_dateadd_field (const std::string &)
DatetruncField	to_datediff_field (const std::string &)
std::shared_ptr < Analyzer::Constant >	make_fp_constant (const int64_t val, const SQLTypeInfo &ti)

Function Documentation

SQLTypeInfo get_agg_type	(	const SQLAgg	agg_kind,
		const Analyzer::Expr *	arg_expr
	)

Definition at line 26 of file CalciteDeserializerUtils.cpp.

References g_bigint_count, Analyzer::Expr::get_type_info(), SQLTypeInfo::get_type_name(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_varlen(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kAVG, kBIGINT, kCOUNT, kCOUNT_IF, kDOUBLE, kINT, kMAX, kMIN, kMODE, kSAMPLE, kSINGLE_VALUE, kSUM, kSUM_IF, and UNREACHABLE.

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::decide_approx_count_distinct_implementation(), and RelAlgTranslator::translateAggregateRex().

                                                                              {
  switch (agg_kind) {
    case kCOUNT:
      return SQLTypeInfo(g_bigint_count ? kBIGINT : kINT, true);
    case kCOUNT_IF:
      return SQLTypeInfo(g_bigint_count ? kBIGINT : kINT, false);
    case kMIN:
    case kMAX:
      return arg_expr->get_type_info();
    case kSUM:
    case kSUM_IF:
      return arg_expr->get_type_info().is_integer() ? SQLTypeInfo(kBIGINT, false)
                                                    : arg_expr->get_type_info();
    case kAVG:
      return SQLTypeInfo(kDOUBLE, false);
    case kAPPROX_COUNT_DISTINCT:
      return SQLTypeInfo(kBIGINT, true);
    case kAPPROX_QUANTILE:
      return SQLTypeInfo(kDOUBLE, false);
    case kSINGLE_VALUE:
      if (arg_expr->get_type_info().is_varlen()) {
        throw std::runtime_error("SINGLE_VALUE not supported on '" +
                                 arg_expr->get_type_info().get_type_name() + "' input.");
      }  // else fall through
    case kSAMPLE:
    case kMODE:
      return arg_expr->get_type_info();
    default:
      UNREACHABLE() << "Unsupported agg_kind: " << agg_kind;
      return {};
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Constant> make_fp_constant	(	const int64_t	val,
		const SQLTypeInfo &	ti
	)

Definition at line 213 of file CalciteDeserializerUtils.cpp.

References CHECK, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), kDOUBLE, and kFLOAT.

Referenced by RelAlgTranslator::translateLiteral().

                                                                            {
  Datum d;
  switch (ti.get_type()) {
    case kFLOAT:
      d.floatval = val;
      break;
    case kDOUBLE:
      d.doubleval = val;
      break;
    default:
      CHECK(false);
  }
  return makeExpr<Analyzer::Constant>(ti, false, d);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLAgg to_agg_kind ( const std::string &  agg_name )

inline

Definition at line 97 of file CalciteDeserializerUtils.h.

References kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kAVG, kCOUNT, kCOUNT_IF, kMAX, kMIN, kMODE, kSAMPLE, kSINGLE_VALUE, kSUM, and kSUM_IF.

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_aggregate_expr().

                                                     {
  if (agg_name == std::string("COUNT")) {
    return kCOUNT;
  }
  if (agg_name == std::string("MIN")) {
    return kMIN;
  }
  if (agg_name == std::string("MAX")) {
    return kMAX;
  }
  if (agg_name == std::string("SUM")) {
    return kSUM;
  }
  if (agg_name == std::string("AVG")) {
    return kAVG;
  }
  if (agg_name == std::string("APPROX_COUNT_DISTINCT")) {
    return kAPPROX_COUNT_DISTINCT;
  }
  if (agg_name == "APPROX_MEDIAN" || agg_name == "APPROX_PERCENTILE" ||
      agg_name == "APPROX_QUANTILE") {
    return kAPPROX_QUANTILE;
  }
  if (agg_name == std::string("ANY_VALUE") || agg_name == std::string("SAMPLE") ||
      agg_name == std::string("LAST_SAMPLE")) {
    return kSAMPLE;
  }
  if (agg_name == std::string("SINGLE_VALUE")) {
    return kSINGLE_VALUE;
  }
  if (agg_name == "MODE") {
    return kMODE;
  }
  if (agg_name == "COUNT_IF") {
    return kCOUNT_IF;
  }
  if (agg_name == "SUM_IF") {
    return kSUM_IF;
  }
  throw std::runtime_error("Aggregate function " + agg_name + " not supported");
}

Here is the caller graph for this function:

DateaddField to_dateadd_field

(

const std::string &

)

Definition at line 111 of file CalciteDeserializerUtils.cpp.

References daCENTURY, daDAY, daDECADE, daHOUR, daMICROSECOND, daMILLENNIUM, daMILLISECOND, daMINUTE, daMONTH, daNANOSECOND, daQUARTER, daSECOND, daWEEK, daWEEKDAY, and daYEAR.

Referenced by RelAlgTranslator::translateDateadd(), and RelAlgTranslator::translateIntervalExprForWindowFraming().

                                                      {
  DateaddField fieldno;
  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
      boost::iequals(field, "yyyy") || boost::iequals(field, "sql_tsi_year")) {
    fieldno = daYEAR;
  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
             boost::iequals(field, "q") || boost::iequals(field, "sql_tsi_quarter")) {
    fieldno = daQUARTER;
  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
             boost::iequals(field, "m") || boost::iequals(field, "sql_tsi_month")) {
    fieldno = daMONTH;
  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
             boost::iequals(field, "d") || boost::iequals(field, "sql_tsi_day")) {
    fieldno = daDAY;
  } else if (boost::iequals(field, "week") || boost::iequals(field, "ww") ||
             boost::iequals(field, "w") || boost::iequals(field, "sql_tsi_week")) {
    fieldno = daWEEK;
  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh") ||
             boost::iequals(field, "sql_tsi_hour")) {
    fieldno = daHOUR;
  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
             boost::iequals(field, "n") || boost::iequals(field, "sql_tsi_minute")) {
    fieldno = daMINUTE;
  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
             boost::iequals(field, "s") || boost::iequals(field, "sql_tsi_second")) {
    fieldno = daSECOND;
  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
    fieldno = daMILLISECOND;
  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us") ||
             boost::iequals(field, "sql_tsi_microsecond") ||
             boost::iequals(field, "frac_second")) {
    fieldno = daMICROSECOND;
  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns") ||
             boost::iequals(field, "sql_tsi_frac_second")) {
    fieldno = daNANOSECOND;
  } else if (boost::iequals(field, "weekday") || boost::iequals(field, "dw")) {
    fieldno = daWEEKDAY;
  } else if (boost::iequals(field, "decade") || boost::iequals(field, "dc")) {
    fieldno = daDECADE;
  } else if (boost::iequals(field, "century")) {
    fieldno = daCENTURY;
  } else if (boost::iequals(field, "millennium")) {
    fieldno = daMILLENNIUM;
  } else {
    throw std::runtime_error("Unsupported field in DATEADD function: " + field);
  }
  return fieldno;
}

Here is the caller graph for this function:

DatetruncField to_datediff_field

(

const std::string &

)

Definition at line 160 of file CalciteDeserializerUtils.cpp.

References dtCENTURY, dtDAY, dtDECADE, dtHOUR, dtMICROSECOND, dtMILLENNIUM, dtMILLISECOND, dtMINUTE, dtMONTH, dtNANOSECOND, dtQUARTER, dtQUARTERDAY, dtSECOND, dtWEEK, dtWEEK_SATURDAY, dtWEEK_SUNDAY, and dtYEAR.

Referenced by RelAlgTranslator::translateDatediff().

                                                         {
  DatetruncField fieldno;
  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
      boost::iequals(field, "yyyy") || boost::iequals(field, "sql_tsi_year")) {
    fieldno = dtYEAR;
  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
             boost::iequals(field, "q") || boost::iequals(field, "sql_tsi_quarter")) {
    fieldno = dtQUARTER;
  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
             boost::iequals(field, "m") || boost::iequals(field, "sql_tsi_month")) {
    fieldno = dtMONTH;
  } else if (boost::iequals(field, "week") || boost::iequals(field, "ww") ||
             boost::iequals(field, "w") || boost::iequals(field, "sql_tsi_week")) {
    fieldno = dtWEEK;
  } else if (boost::iequals(field, "week_sunday")) {
    fieldno = dtWEEK_SUNDAY;
  } else if (boost::iequals(field, "week_saturday")) {
    fieldno = dtWEEK_SATURDAY;
  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
             boost::iequals(field, "d") || boost::iequals(field, "sql_tsi_day")) {
    fieldno = dtDAY;
  } else if (boost::iequals(field, "quarterday")) {
    fieldno = dtQUARTERDAY;
  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh") ||
             boost::iequals(field, "sql_tsi_hour")) {
    fieldno = dtHOUR;
  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
             boost::iequals(field, "n") || boost::iequals(field, "sql_tsi_minute")) {
    fieldno = dtMINUTE;
  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
             boost::iequals(field, "s") || boost::iequals(field, "sql_tsi_second")) {
    fieldno = dtSECOND;
  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
    fieldno = dtMILLISECOND;
  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us") ||
             boost::iequals(field, "sql_tsi_microsecond") ||
             boost::iequals(field, "frac_second")) {
    fieldno = dtMICROSECOND;
  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns") ||
             boost::iequals(field, "sql_tsi_frac_second")) {
    fieldno = dtNANOSECOND;
  } else if (boost::iequals(field, "decade") || boost::iequals(field, "dc")) {
    fieldno = dtDECADE;
  } else if (boost::iequals(field, "century")) {
    fieldno = dtCENTURY;
  } else if (boost::iequals(field, "millennium")) {
    fieldno = dtMILLENNIUM;
  } else {
    throw std::runtime_error("Unsupported field in DATEDIFF function: " + field);
  }
  return fieldno;
}

Here is the caller graph for this function:

ExtractField to_datepart_field

(

const std::string &

)

Definition at line 59 of file CalciteDeserializerUtils.cpp.

References kDAY, kDOY, kHOUR, kISODOW, kMICROSECOND, kMILLISECOND, kMINUTE, kMONTH, kNANOSECOND, kQUARTER, kQUARTERDAY, kSECOND, kWEEK, kWEEK_SATURDAY, kWEEK_SUNDAY, and kYEAR.

Referenced by RelAlgTranslator::translateDatepart().

                                                       {
  ExtractField fieldno;
  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
      boost::iequals(field, "yyyy") || boost::iequals(field, "sql_tsi_year")) {
    fieldno = kYEAR;
  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
             boost::iequals(field, "q") || boost::iequals(field, "sql_tsi_quarter")) {
    fieldno = kQUARTER;
  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
             boost::iequals(field, "m") || boost::iequals(field, "sql_tsi_month")) {
    fieldno = kMONTH;
  } else if (boost::iequals(field, "dayofyear") || boost::iequals(field, "dy") ||
             boost::iequals(field, "y")) {
    fieldno = kDOY;
  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
             boost::iequals(field, "d") || boost::iequals(field, "sql_tsi_day")) {
    fieldno = kDAY;
  } else if (boost::iequals(field, "week") || boost::iequals(field, "ww") ||
             boost::iequals(field, "w") || boost::iequals(field, "sql_tsi_week")) {
    fieldno = kWEEK;
  } else if (boost::iequals(field, "week_sunday")) {
    fieldno = kWEEK_SUNDAY;
  } else if (boost::iequals(field, "week_saturday")) {
    fieldno = kWEEK_SATURDAY;
  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh") ||
             boost::iequals(field, "sql_tsi_hour")) {
    fieldno = kHOUR;
  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
             boost::iequals(field, "n") || boost::iequals(field, "sql_tsi_minute")) {
    fieldno = kMINUTE;
  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
             boost::iequals(field, "s") || boost::iequals(field, "sql_tsi_second")) {
    fieldno = kSECOND;
  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
    fieldno = kMILLISECOND;
  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us") ||
             boost::iequals(field, "sql_tsi_microsecond") ||
             boost::iequals(field, "frac_second")) {
    fieldno = kMICROSECOND;
  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns") ||
             boost::iequals(field, "sql_tsi_frac_second")) {
    fieldno = kNANOSECOND;
  } else if (boost::iequals(field, "weekday") || boost::iequals(field, "dw")) {
    fieldno = kISODOW;
  } else if (boost::iequals(field, "quarterday") || boost::iequals(field, "dq")) {
    fieldno = kQUARTERDAY;
  } else {
    throw std::runtime_error("Unsupported field in DATEPART function: " + field);
  }
  return fieldno;
}

Here is the caller graph for this function:

SQLOps to_sql_op ( const std::string &  op_str )

inline

Definition at line 27 of file CalciteDeserializerUtils.h.

References kAND, kBW_EQ, kCAST, kDIVIDE, kENCODE_TEXT, kEQ, kFUNCTION, kGE, kGT, kIN, kISNOTNULL, kISNULL, kLE, kLT, kMINUS, kMODULO, kMULTIPLY, kNE, kNOT, kOR, kPLUS, and kUNNEST.

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_operator().

                                                 {
  if (op_str == std::string(">")) {
    return kGT;
  }
  if (op_str == std::string("IS NOT DISTINCT FROM")) {
    return kBW_EQ;
  }
  if (op_str == std::string(">=")) {
    return kGE;
  }
  if (op_str == std::string("<")) {
    return kLT;
  }
  if (op_str == std::string("<=")) {
    return kLE;
  }
  if (op_str == std::string("=")) {
    return kEQ;
  }
  if (op_str == std::string("<>")) {
    return kNE;
  }
  if (op_str == std::string("+")) {
    return kPLUS;
  }
  if (op_str == std::string("-")) {
    return kMINUS;
  }
  if (op_str == std::string("*")) {
    return kMULTIPLY;
  }
  if (op_str == std::string("/")) {
    return kDIVIDE;
  }
  if (op_str == "MOD") {
    return kMODULO;
  }
  if (op_str == std::string("AND")) {
    return kAND;
  }
  if (op_str == std::string("OR")) {
    return kOR;
  }
  if (op_str == std::string("CAST")) {
    return kCAST;
  }
  if (op_str == std::string("ENCODE_TEXT")) {
    return kENCODE_TEXT;
  }
  if (op_str == std::string("NOT")) {
    return kNOT;
  }
  if (op_str == std::string("IS NULL")) {
    return kISNULL;
  }
  if (op_str == std::string("IS NOT NULL")) {
    return kISNOTNULL;
  }
  if (op_str == std::string("PG_UNNEST")) {
    return kUNNEST;
  }
  if (op_str == std::string("PG_ANY") || op_str == std::string("PG_ALL")) {
    throw std::runtime_error("Invalid use of " + op_str + " operator");
  }
  if (op_str == std::string("IN")) {
    return kIN;
  }
  return kFUNCTION;
}

Here is the caller graph for this function:

SQLTypes to_sql_type ( const std::string &  type_name )

inline

Definition at line 139 of file CalciteDeserializerUtils.h.

References kARRAY, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kEVAL_CONTEXT_TYPE, kFLOAT, kGEOGRAPHY, kGEOMETRY, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, and kTINYINT.

Referenced by Parser::column_from_json(), anonymous_namespace{RelAlgDag.cpp}::parse_literal(), and anonymous_namespace{RelAlgDag.cpp}::parse_type().

                                                        {
  if (type_name == std::string("BIGINT")) {
    return kBIGINT;
  }
  if (type_name == std::string("INTEGER")) {
    return kINT;
  }
  if (type_name == std::string("TINYINT")) {
    return kTINYINT;
  }
  if (type_name == std::string("SMALLINT")) {
    return kSMALLINT;
  }
  if (type_name == std::string("FLOAT")) {
    return kFLOAT;
  }
  if (type_name == std::string("REAL")) {
    return kFLOAT;
  }
  if (type_name == std::string("DOUBLE")) {
    return kDOUBLE;
  }
  if (type_name == std::string("DECIMAL")) {
    return kDECIMAL;
  }
  if (type_name == std::string("CHAR") || type_name == std::string("VARCHAR") ||
      type_name == std::string("SYMBOL")) {
    return kTEXT;
  }
  if (type_name == std::string("BOOLEAN")) {
    return kBOOLEAN;
  }
  if (type_name == std::string("TIMESTAMP")) {
    return kTIMESTAMP;
  }
  if (type_name == std::string("DATE")) {
    return kDATE;
  }
  if (type_name == std::string("TIME")) {
    return kTIME;
  }
  if (type_name == std::string("NULL")) {
    return kNULLT;
  }
  if (type_name == std::string("ARRAY")) {
    return kARRAY;
  }
  if (type_name == std::string("INTERVAL_DAY") ||
      type_name == std::string("INTERVAL_HOUR") ||
      type_name == std::string("INTERVAL_MINUTE") ||
      type_name == std::string("INTERVAL_SECOND")) {
    return kINTERVAL_DAY_TIME;
  }
  if (type_name == std::string("INTERVAL_MONTH") ||
      type_name == std::string("INTERVAL_YEAR")) {
    return kINTERVAL_YEAR_MONTH;
  }
  if (type_name == std::string("ANY")) {
    return kEVAL_CONTEXT_TYPE;
  }
  if (type_name == std::string("TEXT")) {
    return kTEXT;
  }
  if (type_name == std::string("POINT")) {
    return kPOINT;
  }
  if (type_name == std::string("MULTIPOINT")) {
    return kMULTIPOINT;
  }
  if (type_name == std::string("LINESTRING")) {
    return kLINESTRING;
  }
  if (type_name == std::string("MULTILINESTRING")) {
    return kMULTILINESTRING;
  }
  if (type_name == std::string("POLYGON")) {
    return kPOLYGON;
  }
  if (type_name == std::string("MULTIPOLYGON")) {
    return kMULTIPOLYGON;
  }
  if (type_name == std::string("GEOMETRY")) {
    return kGEOMETRY;
  }
  if (type_name == std::string("GEOGRAPHY")) {
    return kGEOGRAPHY;
  }

  throw std::runtime_error("Unsupported type: " + type_name);
}

Here is the caller graph for this function: