OmniSciDB  29e35f4d58
CalciteDeserializerUtils.h File Reference
#include "DateAdd.h"
#include "DateTruncate.h"
#include "../Shared/sqldefs.h"
#include "../Shared/sqltypes.h"
#include "Shared/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::Constantmake_fp_constant (const int64_t val, const SQLTypeInfo &ti)
 

Function Documentation

◆ get_agg_type()

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

Definition at line 26 of file CalciteDeserializerUtils.cpp.

References CHECK, g_bigint_count, Analyzer::Expr::get_type_info(), SQLTypeInfoCore< TYPE_FACET_PACK >::get_type_name(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_integer(), SQLTypeInfoCore< TYPE_FACET_PACK >::is_varlen(), kAPPROX_COUNT_DISTINCT, kAVG, kBIGINT, kCOUNT, kDOUBLE, kINT, kMAX, kMIN, kSAMPLE, kSINGLE_VALUE, and kSUM.

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

26  {
27  switch (agg_kind) {
28  case kCOUNT:
29  return SQLTypeInfo(g_bigint_count ? kBIGINT : kINT, false);
30  case kMIN:
31  case kMAX:
32  return arg_expr->get_type_info();
33  case kSUM:
34  return arg_expr->get_type_info().is_integer() ? SQLTypeInfo(kBIGINT, false)
35  : arg_expr->get_type_info();
36  case kAVG:
37  return SQLTypeInfo(kDOUBLE, false);
39  return SQLTypeInfo(kBIGINT, false);
40  case kSINGLE_VALUE:
41  if (arg_expr->get_type_info().is_varlen()) {
42  throw std::runtime_error("SINGLE_VALUE not supported on '" +
43  arg_expr->get_type_info().get_type_name() + "' input.");
44  }
45  case kSAMPLE:
46  return arg_expr->get_type_info();
47  default:
48  CHECK(false);
49  }
50  CHECK(false);
51  return SQLTypeInfo();
52 }
bool is_varlen() const
Definition: sqltypes.h:491
Definition: sqldefs.h:73
std::string get_type_name() const
Definition: sqltypes.h:429
bool is_integer() const
Definition: sqltypes.h:479
bool g_bigint_count
Definition: sqldefs.h:75
SQLTypeInfoCore< ArrayContextTypeSizer, ExecutorTypePackaging, DateTimeFacilities > SQLTypeInfo
Definition: sqltypes.h:852
Definition: sqldefs.h:76
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:78
#define CHECK(condition)
Definition: Logger.h:193
Definition: sqltypes.h:48
Definition: sqldefs.h:74
Definition: sqldefs.h:72
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_fp_constant()

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

Definition at line 177 of file CalciteDeserializerUtils.cpp.

References CHECK, Datum::doubleval, Datum::floatval, SQLTypeInfoCore< TYPE_FACET_PACK >::get_type(), kDOUBLE, and kFLOAT.

Referenced by to_sql_type(), RelAlgTranslator::translateLiteral(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateTypedLiteral().

178  {
179  Datum d;
180  switch (ti.get_type()) {
181  case kFLOAT:
182  d.floatval = val;
183  break;
184  case kDOUBLE:
185  d.doubleval = val;
186  break;
187  default:
188  CHECK(false);
189  }
190  return makeExpr<Analyzer::Constant>(ti, false, d);
191 }
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:326
float floatval
Definition: sqltypes.h:130
#define CHECK(condition)
Definition: Logger.h:193
double doubleval
Definition: sqltypes.h:131
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ to_agg_kind()

SQLAgg to_agg_kind ( const std::string &  agg_name)
inline

Definition at line 94 of file CalciteDeserializerUtils.h.

References kAPPROX_COUNT_DISTINCT, kAVG, kCOUNT, kMAX, kMIN, kSAMPLE, kSINGLE_VALUE, and kSUM.

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::parse_aggregate_expr(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateAggregate().

94  {
95  if (agg_name == std::string("COUNT")) {
96  return kCOUNT;
97  }
98  if (agg_name == std::string("MIN")) {
99  return kMIN;
100  }
101  if (agg_name == std::string("MAX")) {
102  return kMAX;
103  }
104  if (agg_name == std::string("SUM")) {
105  return kSUM;
106  }
107  if (agg_name == std::string("AVG")) {
108  return kAVG;
109  }
110  if (agg_name == std::string("APPROX_COUNT_DISTINCT")) {
111  return kAPPROX_COUNT_DISTINCT;
112  }
113  if (agg_name == std::string("SAMPLE") || agg_name == std::string("LAST_SAMPLE")) {
114  return kSAMPLE;
115  }
116  if (agg_name == std::string("SINGLE_VALUE")) {
117  return kSINGLE_VALUE;
118  }
119  throw std::runtime_error("Aggregate function " + agg_name + " not supported");
120 }
Definition: sqldefs.h:73
Definition: sqldefs.h:75
Definition: sqldefs.h:76
Definition: sqldefs.h:74
Definition: sqldefs.h:72
+ Here is the caller graph for this function:

◆ to_dateadd_field()

DateaddField to_dateadd_field ( const std::string &  )

Definition at line 95 of file CalciteDeserializerUtils.cpp.

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

Referenced by to_sql_type(), RelAlgTranslator::translateDateadd(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDateadd().

95  {
96  DateaddField fieldno;
97  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
98  boost::iequals(field, "yyyy") || boost::iequals(field, "sql_tsi_year")) {
99  fieldno = daYEAR;
100  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
101  boost::iequals(field, "q") || boost::iequals(field, "sql_tsi_quarter")) {
102  fieldno = daQUARTER;
103  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
104  boost::iequals(field, "m") || boost::iequals(field, "sql_tsi_month")) {
105  fieldno = daMONTH;
106  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
107  boost::iequals(field, "d") || boost::iequals(field, "sql_tsi_day")) {
108  fieldno = daDAY;
109  } else if (boost::iequals(field, "week") || boost::iequals(field, "ww") ||
110  boost::iequals(field, "w") || boost::iequals(field, "sql_tsi_week")) {
111  fieldno = daWEEK;
112  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh") ||
113  boost::iequals(field, "sql_tsi_hour")) {
114  fieldno = daHOUR;
115  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
116  boost::iequals(field, "n") || boost::iequals(field, "sql_tsi_minute")) {
117  fieldno = daMINUTE;
118  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
119  boost::iequals(field, "s") || boost::iequals(field, "sql_tsi_second")) {
120  fieldno = daSECOND;
121  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
122  fieldno = daMILLISECOND;
123  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us") ||
124  boost::iequals(field, "sql_tsi_microsecond") ||
125  boost::iequals(field, "frac_second")) {
126  fieldno = daMICROSECOND;
127  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns") ||
128  boost::iequals(field, "sql_tsi_frac_second")) {
129  fieldno = daNANOSECOND;
130  } else if (boost::iequals(field, "weekday") || boost::iequals(field, "dw")) {
131  fieldno = daWEEKDAY;
132  } else if (boost::iequals(field, "decade") || boost::iequals(field, "dc")) {
133  fieldno = daDECADE;
134  } else {
135  throw std::runtime_error("Unsupported field in DATEADD function: " + field);
136  }
137  return fieldno;
138 }
Definition: DateAdd.h:47
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31
Definition: DateAdd.h:43
DateaddField
Definition: DateAdd.h:42
Definition: DateAdd.h:56
Definition: DateAdd.h:46
+ Here is the caller graph for this function:

◆ to_datediff_field()

DatetruncField to_datediff_field ( const std::string &  )

Definition at line 140 of file CalciteDeserializerUtils.cpp.

References dtDAY, dtHOUR, dtMICROSECOND, dtMILLISECOND, dtMINUTE, dtMONTH, dtNANOSECOND, dtQUARTER, dtSECOND, dtWEEK, and dtYEAR.

Referenced by to_sql_type(), RelAlgTranslator::translateDatediff(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDatediff().

140  {
141  DatetruncField fieldno;
142  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
143  boost::iequals(field, "yyyy")) {
144  fieldno = dtYEAR;
145  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
146  boost::iequals(field, "q")) {
147  fieldno = dtQUARTER;
148  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
149  boost::iequals(field, "m")) {
150  fieldno = dtMONTH;
151  } else if (boost::iequals(field, "week") || boost::iequals(field, "ww") ||
152  boost::iequals(field, "w")) {
153  fieldno = dtWEEK;
154  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
155  boost::iequals(field, "d")) {
156  fieldno = dtDAY;
157  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh")) {
158  fieldno = dtHOUR;
159  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
160  boost::iequals(field, "n")) {
161  fieldno = dtMINUTE;
162  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
163  boost::iequals(field, "s")) {
164  fieldno = dtSECOND;
165  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
166  fieldno = dtMILLISECOND;
167  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us")) {
168  fieldno = dtMICROSECOND;
169  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns")) {
170  fieldno = dtNANOSECOND;
171  } else {
172  throw std::runtime_error("Unsupported field in DATEDIFF function: " + field);
173  }
174  return fieldno;
175 }
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31
DatetruncField
Definition: DateTruncate.h:42
+ Here is the caller graph for this function:

◆ to_datepart_field()

ExtractField to_datepart_field ( const std::string &  )

Definition at line 54 of file CalciteDeserializerUtils.cpp.

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

Referenced by to_sql_type(), RelAlgTranslator::translateDatepart(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateDatepart().

54  {
55  ExtractField fieldno;
56  if (boost::iequals(field, "year") || boost::iequals(field, "yy") ||
57  boost::iequals(field, "yyyy")) {
58  fieldno = kYEAR;
59  } else if (boost::iequals(field, "quarter") || boost::iequals(field, "qq") ||
60  boost::iequals(field, "q")) {
61  fieldno = kQUARTER;
62  } else if (boost::iequals(field, "month") || boost::iequals(field, "mm") ||
63  boost::iequals(field, "m")) {
64  fieldno = kMONTH;
65  } else if (boost::iequals(field, "dayofyear") || boost::iequals(field, "dy") ||
66  boost::iequals(field, "y")) {
67  fieldno = kDOY;
68  } else if (boost::iequals(field, "day") || boost::iequals(field, "dd") ||
69  boost::iequals(field, "d")) {
70  fieldno = kDAY;
71  } else if (boost::iequals(field, "hour") || boost::iequals(field, "hh")) {
72  fieldno = kHOUR;
73  } else if (boost::iequals(field, "minute") || boost::iequals(field, "mi") ||
74  boost::iequals(field, "n")) {
75  fieldno = kMINUTE;
76  } else if (boost::iequals(field, "second") || boost::iequals(field, "ss") ||
77  boost::iequals(field, "s")) {
78  fieldno = kSECOND;
79  } else if (boost::iequals(field, "millisecond") || boost::iequals(field, "ms")) {
80  fieldno = kMILLISECOND;
81  } else if (boost::iequals(field, "microsecond") || boost::iequals(field, "us")) {
82  fieldno = kMICROSECOND;
83  } else if (boost::iequals(field, "nanosecond") || boost::iequals(field, "ns")) {
84  fieldno = kNANOSECOND;
85  } else if (boost::iequals(field, "weekday") || boost::iequals(field, "dw")) {
86  fieldno = kISODOW;
87  } else if (boost::iequals(field, "quarterday") || boost::iequals(field, "dq")) {
88  fieldno = kQUARTERDAY;
89  } else {
90  throw std::runtime_error("Unsupported field in DATEPART function: " + field);
91  }
92  return fieldno;
93 }
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31
ExtractField
+ Here is the caller graph for this function:

◆ to_sql_op()

SQLOps to_sql_op ( const std::string &  op_str)
inline

Definition at line 27 of file CalciteDeserializerUtils.h.

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

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::parse_operator(), anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateOp(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateUnaryOp().

27  {
28  if (op_str == std::string(">")) {
29  return kGT;
30  }
31  if (op_str == std::string("IS NOT DISTINCT FROM")) {
32  return kBW_EQ;
33  }
34  if (op_str == std::string(">=")) {
35  return kGE;
36  }
37  if (op_str == std::string("<")) {
38  return kLT;
39  }
40  if (op_str == std::string("<=")) {
41  return kLE;
42  }
43  if (op_str == std::string("=")) {
44  return kEQ;
45  }
46  if (op_str == std::string("<>")) {
47  return kNE;
48  }
49  if (op_str == std::string("+")) {
50  return kPLUS;
51  }
52  if (op_str == std::string("-")) {
53  return kMINUS;
54  }
55  if (op_str == std::string("*")) {
56  return kMULTIPLY;
57  }
58  if (op_str == std::string("/")) {
59  return kDIVIDE;
60  }
61  if (op_str == "MOD") {
62  return kMODULO;
63  }
64  if (op_str == std::string("AND")) {
65  return kAND;
66  }
67  if (op_str == std::string("OR")) {
68  return kOR;
69  }
70  if (op_str == std::string("CAST")) {
71  return kCAST;
72  }
73  if (op_str == std::string("NOT")) {
74  return kNOT;
75  }
76  if (op_str == std::string("IS NULL")) {
77  return kISNULL;
78  }
79  if (op_str == std::string("IS NOT NULL")) {
80  return kISNOTNULL;
81  }
82  if (op_str == std::string("PG_UNNEST")) {
83  return kUNNEST;
84  }
85  if (op_str == std::string("PG_ANY") || op_str == std::string("PG_ALL")) {
86  throw std::runtime_error("Invalid use of " + op_str + " operator");
87  }
88  if (op_str == std::string("IN")) {
89  return kIN;
90  }
91  return kFUNCTION;
92 }
Definition: sqldefs.h:35
Definition: sqldefs.h:36
Definition: sqldefs.h:38
Definition: sqldefs.h:49
Definition: sqldefs.h:30
Definition: sqldefs.h:41
Definition: sqldefs.h:37
Definition: sqldefs.h:34
Definition: sqldefs.h:40
Definition: sqldefs.h:32
Definition: sqldefs.h:53
Definition: sqldefs.h:31
Definition: sqldefs.h:33
Definition: sqldefs.h:39
+ Here is the caller graph for this function:

◆ to_sql_type()

SQLTypes to_sql_type ( const std::string &  type_name)
inline

Definition at line 122 of file CalciteDeserializerUtils.h.

References get_agg_type(), kARRAY, kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kEVAL_CONTEXT_TYPE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, make_fp_constant(), to_dateadd_field(), to_datediff_field(), and to_datepart_field().

Referenced by anonymous_namespace{CalciteAdapter.cpp}::parse_literal(), anonymous_namespace{RelAlgDagBuilder.cpp}::parse_literal(), anonymous_namespace{RelAlgDagBuilder.cpp}::parse_type(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateUnaryOp().

122  {
123  if (type_name == std::string("BIGINT")) {
124  return kBIGINT;
125  }
126  if (type_name == std::string("INTEGER")) {
127  return kINT;
128  }
129  if (type_name == std::string("TINYINT")) {
130  return kTINYINT;
131  }
132  if (type_name == std::string("SMALLINT")) {
133  return kSMALLINT;
134  }
135  if (type_name == std::string("FLOAT")) {
136  return kFLOAT;
137  }
138  if (type_name == std::string("DOUBLE")) {
139  return kDOUBLE;
140  }
141  if (type_name == std::string("DECIMAL")) {
142  return kDECIMAL;
143  }
144  if (type_name == std::string("CHAR") || type_name == std::string("VARCHAR")) {
145  return kTEXT;
146  }
147  if (type_name == std::string("BOOLEAN")) {
148  return kBOOLEAN;
149  }
150  if (type_name == std::string("TIMESTAMP")) {
151  return kTIMESTAMP;
152  }
153  if (type_name == std::string("DATE")) {
154  return kDATE;
155  }
156  if (type_name == std::string("TIME")) {
157  return kTIME;
158  }
159  if (type_name == std::string("NULL")) {
160  return kNULLT;
161  }
162  if (type_name == std::string("ARRAY")) {
163  return kARRAY;
164  }
165  if (type_name == std::string("INTERVAL_DAY") ||
166  type_name == std::string("INTERVAL_HOUR") ||
167  type_name == std::string("INTERVAL_MINUTE") ||
168  type_name == std::string("INTERVAL_SECOND")) {
169  return kINTERVAL_DAY_TIME;
170  }
171  if (type_name == std::string("INTERVAL_MONTH") ||
172  type_name == std::string("INTERVAL_YEAR")) {
173  return kINTERVAL_YEAR_MONTH;
174  }
175  if (type_name == std::string("ANY")) {
176  return kEVAL_CONTEXT_TYPE;
177  }
178 
179  throw std::runtime_error("Unsupported type: " + type_name);
180 }
Definition: sqltypes.h:52
Definition: sqltypes.h:55
Definition: sqltypes.h:56
Definition: sqltypes.h:48
+ Here is the call graph for this function:
+ Here is the caller graph for this function: