OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
sqldefs.h
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
23 #ifndef SQLDEFS_H
24 #define SQLDEFS_H
25 
26 // must not change the order without keeping the array in OperExpr::to_string
27 // in sync.
28 enum SQLOps {
29  kEQ = 0,
31  kNE,
32  kLT,
33  kGT,
34  kLE,
35  kGE,
37  kOR,
52  kIN,
56 };
57 
58 #define IS_COMPARISON(X) \
59  ((X) == kEQ || (X) == kBW_EQ || (X) == kBBOX_INTERSECT || (X) == kNE || (X) == kLT || \
60  (X) == kGT || (X) == kLE || (X) == kGE)
61 #define IS_LOGIC(X) ((X) == kAND || (X) == kOR)
62 #define IS_ARITHMETIC(X) \
63  ((X) == kMINUS || (X) == kPLUS || (X) == kMULTIPLY || (X) == kDIVIDE || (X) == kMODULO)
64 #define COMMUTE_COMPARISON(X) \
65  ((X) == kLT ? kGT : (X) == kLE ? kGE : (X) == kGT ? kLT : (X) == kGE ? kLE : (X))
66 #define IS_UNARY(X) \
67  ((X) == kNOT || (X) == kUMINUS || (X) == kISNULL || (X) == kEXISTS || (X) == kCAST || \
68  (X) == kENCODE_TEXT)
69 #define IS_EQUIVALENCE(X) ((X) == kEQ || (X) == kBW_EQ || (X) == kBBOX_INTERSECT)
70 
72 
73 enum SQLAgg {
87 };
88 
89 enum class SqlStringOpKind {
90  /* Unary */
91  LOWER = 1,
92  UPPER,
93  INITCAP,
94  REVERSE,
95  /* Binary */
96  REPEAT,
97  CONCAT,
98  RCONCAT,
99  /* Ternary */
100  LPAD,
101  RPAD,
102  TRIM,
103  LTRIM,
104  RTRIM,
105  SUBSTRING,
106  OVERLAY,
107  REPLACE,
108  SPLIT_PART,
109  /* 6 args */
112  JSON_VALUE,
115  TRY_STRING_CAST, // string-to-numeric
116  POSITION, // string-to-numeric
117  JAROWINKLER_SIMILARITY, // string-to-numeric
118  LEVENSHTEIN_DISTANCE, // string-to-numeric
119  INVALID
120 };
121 
123  // set MIN's enum val as one, and we use window function kind's enum vals
124  // to classify a behavior of our runtime code for window framing
125  // i.e., aggregate_##value_type##_values functions
126  MIN = 1,
127  MAX,
128  AVG,
129  SUM,
130  COUNT,
131  ROW_NUMBER,
132  RANK,
133  DENSE_RANK,
134  PERCENT_RANK,
135  CUME_DIST,
136  NTILE,
137  LAG,
138  LAG_IN_FRAME,
139  LEAD,
141  FIRST_VALUE,
143  LAST_VALUE,
145  NTH_VALUE,
147  FORWARD_FILL,
149  COUNT_IF,
150  SUM_IF,
151  SUM_INTERNAL, // For deserialization from Calcite only. Gets rewritten to a regular
152  // SUM.
154  INVALID
155 };
156 
160  CURRENT_ROW,
163  UNKNOWN
164 };
165 
167 
168 // StorageOption::kCPU and ::kGPU conflict with libtorch's c10::DeviceType::kCPU
169 // Keep it as enum class rather than plain enum
170 enum class StorageOption { kDISK = 0, kGPU = 1, kCPU = 2 };
171 
172 enum ViewRefreshOption { kMANUAL = 0, kAUTO = 1, kIMMEDIATE = 2 };
173 
174 enum class JoinType {
175  INNER,
176  LEFT,
177  SEMI,
178  ANTI,
181  INVALID
182 };
183 
184 #if !(defined(__CUDACC__) || defined(NO_BOOST))
185 
186 #include <sstream>
187 #include <string>
188 #include "Logger/Logger.h"
189 
190 inline std::string toString(const JoinType& join_type) {
191  switch (join_type) {
192  case JoinType::INNER:
193  return "INNER";
194  case JoinType::LEFT:
195  return "LEFT";
196  case JoinType::SEMI:
197  return "SEMI";
198  case JoinType::ANTI:
199  return "ANTI";
201  return "WINDOW_FUNCTION";
203  return "WINDOW_FUNCTION_FRAMING";
204  default:
205  return "INVALID";
206  }
207 }
208 
209 inline std::string toString(const SQLQualifier& qualifier) {
210  switch (qualifier) {
211  case kONE:
212  return "ONE";
213  case kANY:
214  return "ANY";
215  case kALL:
216  return "ALL";
217  }
218  LOG(FATAL) << "Invalid SQLQualifier: " << qualifier;
219  return "";
220 }
221 
222 inline std::string toString(const SQLAgg& kind) {
223  switch (kind) {
224  case kAVG:
225  return "AVG";
226  case kMIN:
227  return "MIN";
228  case kMAX:
229  return "MAX";
230  case kSUM:
231  return "SUM";
232  case kCOUNT:
233  return "COUNT";
235  return "APPROX_COUNT_DISTINCT";
236  case kAPPROX_QUANTILE:
237  return "APPROX_PERCENTILE";
238  case kSAMPLE:
239  return "SAMPLE";
240  case kSINGLE_VALUE:
241  return "SINGLE_VALUE";
242  case kMODE:
243  return "MODE";
244  case kCOUNT_IF:
245  return "COUNT_IF";
246  case kSUM_IF:
247  return "SUM_IF";
248  case kINVALID_AGG:
249  return "INVALID";
250  default:
251  UNREACHABLE() << "Invalid aggregate kind: " << kind;
252  return {};
253  }
254 }
255 
257  switch (agg_type) {
258  case kCOUNT_IF:
259  return kCOUNT;
260  case kSUM_IF:
261  return kSUM;
262  default:
263  return agg_type;
264  }
265 }
266 
267 inline std::string toString(const SQLOps& op) {
268  switch (op) {
269  case kEQ:
270  return "EQ";
271  case kBW_EQ:
272  return "BW_EQ";
273  case kNE:
274  return "NE";
275  case kLT:
276  return "LT";
277  case kGT:
278  return "GT";
279  case kLE:
280  return "LE";
281  case kGE:
282  return "GE";
283  case kAND:
284  return "AND";
285  case kOR:
286  return "OR";
287  case kNOT:
288  return "NOT";
289  case kMINUS:
290  return "MINUS";
291  case kPLUS:
292  return "PLUS";
293  case kMULTIPLY:
294  return "MULTIPLY";
295  case kDIVIDE:
296  return "DIVIDE";
297  case kMODULO:
298  return "MODULO";
299  case kUMINUS:
300  return "UMINUS";
301  case kISNULL:
302  return "ISNULL";
303  case kISNOTNULL:
304  return "ISNOTNULL";
305  case kEXISTS:
306  return "EXISTS";
307  case kCAST:
308  return "CAST";
309  case kARRAY_AT:
310  return "ARRAY_AT";
311  case kUNNEST:
312  return "UNNEST";
313  case kFUNCTION:
314  return "FUNCTION";
315  case kIN:
316  return "IN";
317  case kBBOX_INTERSECT:
318  return "BOUNDING_BOX_INTERSECT";
319  case kENCODE_TEXT:
320  return "ENCODE_TEXT";
321  case kINVALID_OP:
322  return "INVALID_OP";
323  }
324  LOG(FATAL) << "Invalid operation kind: " << op;
325  return "";
326 }
327 
328 inline std::ostream& operator<<(std::ostream& os, const SqlStringOpKind kind) {
329  switch (kind) {
331  return os << "LOWER";
333  return os << "UPPER";
335  return os << "INITCAP";
337  return os << "REVERSE";
339  return os << "REPEAT";
341  return os << "CONCAT";
343  return os << "RCONCAT";
345  return os << "LPAD";
347  return os << "RPAD";
349  return os << "TRIM";
351  return os << "LTRIM";
353  return os << "RTRIM";
355  return os << "SUBSTRING";
357  return os << "OVERLAY";
359  return os << "REPLACE";
361  return os << "SPLIT_PART";
363  return os << "REGEXP_REPLACE";
365  return os << "REGEXP_SUBSTR";
367  return os << "JSON_VALUE";
369  return os << "BASE64_ENCODE";
371  return os << "BASE64_DECODE";
373  return os << "TRY_STRING_CAST";
375  return os << "POSITION";
377  return os << "JAROWINKLER_SIMILARITY";
379  return os << "LEVENSHTEIN_DISTANCE";
381  return os << "INVALID";
382  }
383  LOG(FATAL) << "Invalid string operation";
384  // Make compiler happy
385  return os << "INVALID";
386 }
387 
388 inline SqlStringOpKind name_to_string_op_kind(const std::string& func_name) {
389  if (func_name == "LOWER") {
390  return SqlStringOpKind::LOWER;
391  }
392  if (func_name == "UPPER") {
393  return SqlStringOpKind::UPPER;
394  }
395  if (func_name == "INITCAP") {
397  }
398  if (func_name == "REVERSE") {
400  }
401  if (func_name == "REPEAT") {
403  }
404  if (func_name == "||") {
406  }
407  if (func_name == "LPAD") {
408  return SqlStringOpKind::LPAD;
409  }
410  if (func_name == "RPAD") {
411  return SqlStringOpKind::RPAD;
412  }
413  if (func_name == "TRIM") {
414  return SqlStringOpKind::TRIM;
415  }
416  if (func_name == "LTRIM") {
417  return SqlStringOpKind::LTRIM;
418  }
419  if (func_name == "RTRIM") {
420  return SqlStringOpKind::RTRIM;
421  }
422  if (func_name == "SUBSTRING") {
424  }
425  if (func_name == "OVERLAY") {
427  }
428  if (func_name == "REPLACE") {
430  }
431  if (func_name == "SPLIT_PART") {
433  }
434  if (func_name == "REGEXP_REPLACE") {
436  }
437  if (func_name == "REGEXP_SUBSTR") {
439  }
440  if (func_name == "REGEXP_MATCH") {
442  }
443  if (func_name == "JSON_VALUE") {
445  }
446  if (func_name == "BASE64_ENCODE") {
448  }
449  if (func_name == "BASE64_DECODE") {
451  }
452  if (func_name == "TRY_CAST") {
454  }
455  if (func_name == "POSITION") {
457  }
458  if (func_name == "JAROWINKLER_SIMILARITY") {
460  }
461  if (func_name == "LEVENSHTEIN_DISTANCE") {
463  }
464  LOG(FATAL) << "Invalid string function " << func_name << ".";
466 }
467 
468 inline bool string_op_returns_string(const SqlStringOpKind kind) {
469  switch (kind) {
472  return false;
473  default:
474  return true;
475  }
476 }
477 
478 inline std::string toString(const SqlWindowFunctionKind& kind) {
479  switch (kind) {
481  return "ROW_NUMBER";
483  return "RANK";
485  return "DENSE_RANK";
487  return "PERCENT_RANK";
489  return "CUME_DIST";
491  return "NTILE";
493  return "LAG";
495  return "LEAD";
497  return "FIRST_VALUE";
499  return "FIRST_VALUE_IN_FRAME";
501  return "LAST_VALUE";
503  return "LAST_VALUE_IN_FRAME";
505  return "NTH_VALUE";
507  return "NTH_VALUE_IN_FRAME";
509  return "AVG";
511  return "MIN";
513  return "MAX";
515  return "SUM";
517  return "COUNT";
519  return "SUM_INTERNAL";
521  return "LEAD_IN_FRAME";
523  return "LAG_IN_FRAME";
525  return "COUNT_IF";
527  return "SUM_IF";
529  return "FORWARD_FILL";
531  return "BACKWARD_FILL";
533  return "CONDITIONAL_CHANGE_EVENT";
535  return "INVALID";
536  }
537  LOG(FATAL) << "Invalid window function kind.";
538  return "";
539 }
540 
541 inline std::string toString(const SqlWindowFrameBoundType& kind) {
542  switch (kind) {
544  return "UNBOUNDED_PRECEDING";
546  return "EXPR_PRECEDING";
548  return "CURRENT_ROW";
550  return "EXPR_FOLLOWING";
552  return "UNBOUNDED_FOLLOWING";
554  return "UNKNOWN";
555  }
556  LOG(FATAL) << "Invalid window function bound type.";
557  return "";
558 }
559 
560 #endif // #if !(defined(__CUDACC__) || defined(NO_BOOST))
561 
562 #endif // SQLDEFS_H
Definition: sqldefs.h:71
SqlWindowFrameBoundType
Definition: sqldefs.h:157
SQLAgg
Definition: sqldefs.h:73
ViewRefreshOption
Definition: sqldefs.h:172
SqlStringOpKind name_to_string_op_kind(const std::string &func_name)
Definition: sqldefs.h:388
JoinType
Definition: sqldefs.h:174
SQLQualifier
Definition: sqldefs.h:71
#define LOG(tag)
Definition: Logger.h:285
std::ostream & operator<<(std::ostream &os, const SessionInfo &session_info)
Definition: SessionInfo.cpp:57
SQLOps
Definition: sqldefs.h:28
Definition: sqldefs.h:34
Definition: sqldefs.h:35
Definition: sqldefs.h:37
#define UNREACHABLE()
Definition: Logger.h:338
SqlStringOpKind
Definition: sqldefs.h:89
Definition: sqldefs.h:48
Definition: sqldefs.h:29
Definition: sqldefs.h:40
std::string toString(const QueryDescriptionType &type)
Definition: Types.h:64
Definition: sqldefs.h:75
Definition: sqldefs.h:36
Definition: sqldefs.h:77
Definition: sqldefs.h:71
StorageOption
Definition: sqldefs.h:170
SQLStmtType
Definition: sqldefs.h:166
Definition: sqldefs.h:33
Definition: sqldefs.h:39
bool string_op_returns_string(const SqlStringOpKind kind)
Definition: sqldefs.h:468
Definition: sqldefs.h:71
Definition: sqldefs.h:31
Definition: sqldefs.h:78
Definition: sqldefs.h:172
SqlWindowFunctionKind
Definition: sqldefs.h:122
Definition: sqldefs.h:52
Definition: sqldefs.h:30
Definition: sqldefs.h:32
Definition: sqldefs.h:76
Definition: sqldefs.h:74
Definition: sqldefs.h:38
Definition: sqldefs.h:83
SQLAgg get_non_conditional_agg_type(SQLAgg const agg_type)
Definition: sqldefs.h:256