OmniSciDB  72c90bc290
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
sqldefs.h File Reference

Common Enum definitions for SQL processing. More...

#include <sstream>
#include <string>
#include "Logger/Logger.h"
+ Include dependency graph for sqldefs.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define IS_COMPARISON(X)
 
#define IS_LOGIC(X)   ((X) == kAND || (X) == kOR)
 
#define IS_ARITHMETIC(X)   ((X) == kMINUS || (X) == kPLUS || (X) == kMULTIPLY || (X) == kDIVIDE || (X) == kMODULO)
 
#define COMMUTE_COMPARISON(X)   ((X) == kLT ? kGT : (X) == kLE ? kGE : (X) == kGT ? kLT : (X) == kGE ? kLE : (X))
 
#define IS_UNARY(X)
 
#define IS_EQUIVALENCE(X)   ((X) == kEQ || (X) == kBW_EQ || (X) == kBBOX_INTERSECT)
 

Enumerations

enum  SQLOps {
  kEQ = 0, kBW_EQ, kNE, kLT,
  kGT, kLE, kGE, kAND,
  kOR, kNOT, kMINUS, kPLUS,
  kMULTIPLY, kDIVIDE, kMODULO, kUMINUS,
  kISNULL, kISNOTNULL, kEXISTS, kCAST,
  kARRAY_AT, kUNNEST, kFUNCTION, kIN,
  kBBOX_INTERSECT, kENCODE_TEXT, kINVALID_OP
}
 
enum  SQLQualifier { kONE, kANY, kALL }
 
enum  SQLAgg {
  kAVG, kMIN, kMAX, kSUM,
  kCOUNT, kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kSAMPLE,
  kSINGLE_VALUE, kMODE, kCOUNT_IF, kSUM_IF,
  kINVALID_AGG
}
 
enum  SqlStringOpKind {
  SqlStringOpKind::LOWER = 1, SqlStringOpKind::UPPER, SqlStringOpKind::INITCAP, SqlStringOpKind::REVERSE,
  SqlStringOpKind::REPEAT, SqlStringOpKind::CONCAT, SqlStringOpKind::RCONCAT, SqlStringOpKind::LPAD,
  SqlStringOpKind::RPAD, SqlStringOpKind::TRIM, SqlStringOpKind::LTRIM, SqlStringOpKind::RTRIM,
  SqlStringOpKind::SUBSTRING, SqlStringOpKind::OVERLAY, SqlStringOpKind::REPLACE, SqlStringOpKind::SPLIT_PART,
  SqlStringOpKind::REGEXP_REPLACE, SqlStringOpKind::REGEXP_SUBSTR, SqlStringOpKind::JSON_VALUE, SqlStringOpKind::BASE64_ENCODE,
  SqlStringOpKind::BASE64_DECODE, SqlStringOpKind::TRY_STRING_CAST, SqlStringOpKind::POSITION, SqlStringOpKind::JAROWINKLER_SIMILARITY,
  SqlStringOpKind::LEVENSHTEIN_DISTANCE, SqlStringOpKind::INVALID
}
 
enum  SqlWindowFunctionKind {
  SqlWindowFunctionKind::MIN = 1, SqlWindowFunctionKind::MAX, SqlWindowFunctionKind::AVG, SqlWindowFunctionKind::SUM,
  SqlWindowFunctionKind::COUNT, SqlWindowFunctionKind::ROW_NUMBER, SqlWindowFunctionKind::RANK, SqlWindowFunctionKind::DENSE_RANK,
  SqlWindowFunctionKind::PERCENT_RANK, SqlWindowFunctionKind::CUME_DIST, SqlWindowFunctionKind::NTILE, SqlWindowFunctionKind::LAG,
  SqlWindowFunctionKind::LAG_IN_FRAME, SqlWindowFunctionKind::LEAD, SqlWindowFunctionKind::LEAD_IN_FRAME, SqlWindowFunctionKind::FIRST_VALUE,
  SqlWindowFunctionKind::FIRST_VALUE_IN_FRAME, SqlWindowFunctionKind::LAST_VALUE, SqlWindowFunctionKind::LAST_VALUE_IN_FRAME, SqlWindowFunctionKind::NTH_VALUE,
  SqlWindowFunctionKind::NTH_VALUE_IN_FRAME, SqlWindowFunctionKind::FORWARD_FILL, SqlWindowFunctionKind::BACKWARD_FILL, SqlWindowFunctionKind::COUNT_IF,
  SqlWindowFunctionKind::SUM_IF, SqlWindowFunctionKind::SUM_INTERNAL, SqlWindowFunctionKind::CONDITIONAL_CHANGE_EVENT, SqlWindowFunctionKind::INVALID
}
 
enum  SqlWindowFrameBoundType {
  SqlWindowFrameBoundType::UNBOUNDED_PRECEDING = 1, SqlWindowFrameBoundType::EXPR_PRECEDING, SqlWindowFrameBoundType::CURRENT_ROW, SqlWindowFrameBoundType::EXPR_FOLLOWING,
  SqlWindowFrameBoundType::UNBOUNDED_FOLLOWING, SqlWindowFrameBoundType::UNKNOWN
}
 
enum  SQLStmtType {
  kSELECT, kUPDATE, kINSERT, kDELETE,
  kCREATE_TABLE
}
 
enum  StorageOption { StorageOption::kDISK = 0, StorageOption::kGPU = 1, StorageOption::kCPU = 2 }
 
enum  ViewRefreshOption { kMANUAL = 0, kAUTO = 1, kIMMEDIATE = 2 }
 
enum  JoinType {
  JoinType::INNER, JoinType::LEFT, JoinType::SEMI, JoinType::ANTI,
  JoinType::WINDOW_FUNCTION, JoinType::WINDOW_FUNCTION_FRAMING, JoinType::INVALID
}
 

Functions

std::string toString (const JoinType &join_type)
 
std::string toString (const SQLQualifier &qualifier)
 
std::string toString (const SQLAgg &kind)
 
SQLAgg get_non_conditional_agg_type (SQLAgg const agg_type)
 
std::string toString (const SQLOps &op)
 
std::ostream & operator<< (std::ostream &os, const SqlStringOpKind kind)
 
SqlStringOpKind name_to_string_op_kind (const std::string &func_name)
 
bool string_op_returns_string (const SqlStringOpKind kind)
 
std::string toString (const SqlWindowFunctionKind &kind)
 
std::string toString (const SqlWindowFrameBoundType &kind)
 

Detailed Description

Common Enum definitions for SQL processing.

Definition in file sqldefs.h.

Macro Definition Documentation

#define COMMUTE_COMPARISON (   X)    ((X) == kLT ? kGT : (X) == kLE ? kGE : (X) == kGT ? kLT : (X) == kGE ? kLE : (X))

Definition at line 64 of file sqldefs.h.

Referenced by Analyzer::BinOper::normalize_simple_predicate().

#define IS_ARITHMETIC (   X)    ((X) == kMINUS || (X) == kPLUS || (X) == kMULTIPLY || (X) == kDIVIDE || (X) == kMODULO)
#define IS_UNARY (   X)
Value:

Definition at line 66 of file sqldefs.h.

Enumeration Type Documentation

enum JoinType
strong
Enumerator
INNER 
LEFT 
SEMI 
ANTI 
WINDOW_FUNCTION 
WINDOW_FUNCTION_FRAMING 
INVALID 

Definition at line 174 of file sqldefs.h.

enum SQLAgg
Enumerator
kAVG 
kMIN 
kMAX 
kSUM 
kCOUNT 
kAPPROX_COUNT_DISTINCT 
kAPPROX_QUANTILE 
kSAMPLE 
kSINGLE_VALUE 
kMODE 
kCOUNT_IF 
kSUM_IF 
kINVALID_AGG 

Definition at line 73 of file sqldefs.h.

73  {
74  kAVG,
75  kMIN,
76  kMAX,
77  kSUM,
78  kCOUNT,
81  kSAMPLE,
83  kMODE,
84  kCOUNT_IF,
85  kSUM_IF,
87 };
Definition: sqldefs.h:75
Definition: sqldefs.h:77
Definition: sqldefs.h:78
Definition: sqldefs.h:76
Definition: sqldefs.h:74
Definition: sqldefs.h:83
enum SQLOps
Enumerator
kEQ 
kBW_EQ 
kNE 
kLT 
kGT 
kLE 
kGE 
kAND 
kOR 
kNOT 
kMINUS 
kPLUS 
kMULTIPLY 
kDIVIDE 
kMODULO 
kUMINUS 
kISNULL 
kISNOTNULL 
kEXISTS 
kCAST 
kARRAY_AT 
kUNNEST 
kFUNCTION 
kIN 
kBBOX_INTERSECT 
kENCODE_TEXT 
kINVALID_OP 

Definition at line 28 of file sqldefs.h.

28  {
29  kEQ = 0,
30  kBW_EQ,
31  kNE,
32  kLT,
33  kGT,
34  kLE,
35  kGE,
36  kAND,
37  kOR,
38  kNOT,
39  kMINUS,
40  kPLUS,
41  kMULTIPLY,
42  kDIVIDE,
43  kMODULO,
44  kUMINUS,
45  kISNULL,
46  kISNOTNULL,
47  kEXISTS,
48  kCAST,
49  kARRAY_AT,
50  kUNNEST,
51  kFUNCTION,
52  kIN,
56 };
Definition: sqldefs.h:34
Definition: sqldefs.h:35
Definition: sqldefs.h:37
Definition: sqldefs.h:48
Definition: sqldefs.h:29
Definition: sqldefs.h:40
Definition: sqldefs.h:36
Definition: sqldefs.h:33
Definition: sqldefs.h:39
Definition: sqldefs.h:31
Definition: sqldefs.h:52
Definition: sqldefs.h:30
Definition: sqldefs.h:32
Definition: sqldefs.h:38
Enumerator
kONE 
kANY 
kALL 

Definition at line 71 of file sqldefs.h.

71 { kONE, kANY, kALL };
Definition: sqldefs.h:71
Definition: sqldefs.h:71
Definition: sqldefs.h:71
Enumerator
kSELECT 
kUPDATE 
kINSERT 
kDELETE 
kCREATE_TABLE 

Definition at line 166 of file sqldefs.h.

enum SqlStringOpKind
strong
Enumerator
LOWER 
UPPER 
INITCAP 
REVERSE 
REPEAT 
CONCAT 
RCONCAT 
LPAD 
RPAD 
TRIM 
LTRIM 
RTRIM 
SUBSTRING 
OVERLAY 
REPLACE 
SPLIT_PART 
REGEXP_REPLACE 
REGEXP_SUBSTR 
JSON_VALUE 
BASE64_ENCODE 
BASE64_DECODE 
TRY_STRING_CAST 
POSITION 
JAROWINKLER_SIMILARITY 
LEVENSHTEIN_DISTANCE 
INVALID 

Definition at line 89 of file sqldefs.h.

enum SqlWindowFunctionKind
strong
Enumerator
MIN 
MAX 
AVG 
SUM 
COUNT 
ROW_NUMBER 
RANK 
DENSE_RANK 
PERCENT_RANK 
CUME_DIST 
NTILE 
LAG 
LAG_IN_FRAME 
LEAD 
LEAD_IN_FRAME 
FIRST_VALUE 
FIRST_VALUE_IN_FRAME 
LAST_VALUE 
LAST_VALUE_IN_FRAME 
NTH_VALUE 
NTH_VALUE_IN_FRAME 
FORWARD_FILL 
BACKWARD_FILL 
COUNT_IF 
SUM_IF 
SUM_INTERNAL 
CONDITIONAL_CHANGE_EVENT 
INVALID 

Definition at line 122 of file sqldefs.h.

122  {
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 };
enum StorageOption
strong
Enumerator
kDISK 
kGPU 
kCPU 

Definition at line 170 of file sqldefs.h.

Enumerator
kMANUAL 
kAUTO 
kIMMEDIATE 

Definition at line 172 of file sqldefs.h.

172 { kMANUAL = 0, kAUTO = 1, kIMMEDIATE = 2 };
Definition: sqldefs.h:172

Function Documentation

SQLAgg get_non_conditional_agg_type ( SQLAgg const  agg_type)
inline

Definition at line 256 of file sqldefs.h.

References kCOUNT, kCOUNT_IF, kSUM, and kSUM_IF.

Referenced by anonymous_namespace{ResultSetReductionJIT.cpp}::emit_aggregate_one_nullable_value().

256  {
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 }
Definition: sqldefs.h:77
Definition: sqldefs.h:78

+ Here is the caller graph for this function:

SqlStringOpKind name_to_string_op_kind ( const std::string &  func_name)
inline

Definition at line 388 of file sqldefs.h.

References BASE64_DECODE, BASE64_ENCODE, CONCAT, logger::FATAL, INITCAP, INVALID, JAROWINKLER_SIMILARITY, JSON_VALUE, LEVENSHTEIN_DISTANCE, LOG, LOWER, LPAD, LTRIM, OVERLAY, POSITION, REGEXP_REPLACE, REGEXP_SUBSTR, REPEAT, REPLACE, REVERSE, RPAD, RTRIM, SPLIT_PART, SUBSTRING, TRIM, TRY_STRING_CAST, and UPPER.

Referenced by RelAlgTranslator::translateStringOper().

388  {
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 }
#define LOG(tag)
Definition: Logger.h:285

+ Here is the caller graph for this function:

std::ostream& operator<< ( std::ostream &  os,
const SqlStringOpKind  kind 
)
inline

Definition at line 328 of file sqldefs.h.

References BASE64_DECODE, BASE64_ENCODE, CONCAT, logger::FATAL, INITCAP, INVALID, JAROWINKLER_SIMILARITY, JSON_VALUE, LEVENSHTEIN_DISTANCE, LOG, LOWER, LPAD, LTRIM, OVERLAY, POSITION, RCONCAT, REGEXP_REPLACE, REGEXP_SUBSTR, REPEAT, REPLACE, REVERSE, RPAD, RTRIM, SPLIT_PART, SUBSTRING, TRIM, TRY_STRING_CAST, and UPPER.

328  {
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 }
#define LOG(tag)
Definition: Logger.h:285
bool string_op_returns_string ( const SqlStringOpKind  kind)
inline

Definition at line 468 of file sqldefs.h.

References POSITION, and TRY_STRING_CAST.

Referenced by TextEncodingCastCountVisitor::visitStringOper().

468  {
469  switch (kind) {
472  return false;
473  default:
474  return true;
475  }
476 }

+ Here is the caller graph for this function:

std::string toString ( const JoinType join_type)
inline

Definition at line 190 of file sqldefs.h.

References ANTI, INNER, LEFT, SEMI, WINDOW_FUNCTION, and WINDOW_FUNCTION_FRAMING.

190  {
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 }
std::string toString ( const SQLQualifier qualifier)
inline

Definition at line 209 of file sqldefs.h.

References logger::FATAL, kALL, kANY, kONE, and LOG.

209  {
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 }
Definition: sqldefs.h:71
#define LOG(tag)
Definition: Logger.h:285
Definition: sqldefs.h:71
Definition: sqldefs.h:71
std::string toString ( const SQLAgg kind)
inline

Definition at line 222 of file sqldefs.h.

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

222  {
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 }
#define UNREACHABLE()
Definition: Logger.h:338
Definition: sqldefs.h:75
Definition: sqldefs.h:77
Definition: sqldefs.h:78
Definition: sqldefs.h:76
Definition: sqldefs.h:74
Definition: sqldefs.h:83
std::string toString ( const SQLOps op)
inline

Definition at line 267 of file sqldefs.h.

References logger::FATAL, kAND, kARRAY_AT, kBBOX_INTERSECT, kBW_EQ, kCAST, kDIVIDE, kENCODE_TEXT, kEQ, kEXISTS, kFUNCTION, kGE, kGT, kIN, kINVALID_OP, kISNOTNULL, kISNULL, kLE, kLT, kMINUS, kMODULO, kMULTIPLY, kNE, kNOT, kOR, kPLUS, kUMINUS, kUNNEST, and LOG.

267  {
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 }
#define LOG(tag)
Definition: Logger.h:285
Definition: sqldefs.h:34
Definition: sqldefs.h:35
Definition: sqldefs.h:37
Definition: sqldefs.h:48
Definition: sqldefs.h:29
Definition: sqldefs.h:40
Definition: sqldefs.h:36
Definition: sqldefs.h:33
Definition: sqldefs.h:39
Definition: sqldefs.h:31
Definition: sqldefs.h:52
Definition: sqldefs.h:30
Definition: sqldefs.h:32
Definition: sqldefs.h:38
std::string toString ( const SqlWindowFunctionKind kind)
inline

Definition at line 478 of file sqldefs.h.

References AVG, BACKWARD_FILL, CONDITIONAL_CHANGE_EVENT, COUNT, COUNT_IF, CUME_DIST, DENSE_RANK, logger::FATAL, FIRST_VALUE, FIRST_VALUE_IN_FRAME, FORWARD_FILL, INVALID, LAG, LAG_IN_FRAME, LAST_VALUE, LAST_VALUE_IN_FRAME, LEAD, LEAD_IN_FRAME, LOG, MAX, MIN, NTH_VALUE, NTH_VALUE_IN_FRAME, NTILE, PERCENT_RANK, RANK, ROW_NUMBER, SUM, SUM_IF, and SUM_INTERNAL.

478  {
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 }
#define LOG(tag)
Definition: Logger.h:285
std::string toString ( const SqlWindowFrameBoundType kind)
inline

Definition at line 541 of file sqldefs.h.

References CURRENT_ROW, EXPR_FOLLOWING, EXPR_PRECEDING, logger::FATAL, LOG, UNBOUNDED_FOLLOWING, UNBOUNDED_PRECEDING, and UNKNOWN.

541  {
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 }
#define LOG(tag)
Definition: Logger.h:285