sqldefs.h File Reference

Common Enum definitions for SQL processing. More...

#include <cstdio>
#include <ostream>
#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::REGEXP_COUNT, SqlStringOpKind::JSON_VALUE,   SqlStringOpKind::BASE64_ENCODE, SqlStringOpKind::BASE64_DECODE, SqlStringOpKind::URL_ENCODE, SqlStringOpKind::URL_DECODE,   SqlStringOpKind::TRY_STRING_CAST, SqlStringOpKind::POSITION, SqlStringOpKind::JAROWINKLER_SIMILARITY, SqlStringOpKind::LEVENSHTEIN_DISTANCE,   SqlStringOpKind::HASH, SqlStringOpKind::INVALID }
enum	SqlWindowFunctionKind {   SqlWindowFunctionKind::MIN = 0, 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::UNKNOWN }
enum	SqlWindowFrameBoundType {   SqlWindowFrameBoundType::UNBOUNDED_PRECEDING = 0, 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
constexpr char const *	toString (SqlWindowFunctionKind const kind)
std::ostream &	operator<< (std::ostream &os, SqlWindowFunctionKind const kind)
constexpr char const *	toString (SqlWindowFrameBoundType const kind)
std::ostream &	operator<< (std::ostream &os, SqlWindowFrameBoundType const kind)
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)

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 67 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)

Definition at line 65 of file sqldefs.h.

Referenced by Analyzer::BinOper::analyze_type_info(), CodeGenerator::codegen(), CodeGenerator::codegenArith(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldOper().

#define IS_COMPARISON

(

X

)

Value:

((X) == kEQ || (X) == kBW_EQ || (X) == kBBOX_INTERSECT || (X) == kNE || (X) == kLT || \
   (X) == kGT || (X) == kLE || (X) == kGE)

Definition at line 61 of file sqldefs.h.

Referenced by Analyzer::BinOper::analyze_type_info(), anonymous_namespace{CompareIR.cpp}::check_array_comp_cond(), CodeGenerator::codegen(), CodeGenerator::codegenCmp(), anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldOper(), Parser::OperExpr::normalize(), Analyzer::BinOper::normalize_simple_predicate(), RelAlgTranslator::translateOper(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::visitBinOper().

#define IS_EQUIVALENCE

(

X

)

((X) == kEQ || (X) == kBW_EQ || (X) == kBBOX_INTERSECT)

Definition at line 72 of file sqldefs.h.

Referenced by Executor::buildCurrentLevelHashTable(), anonymous_namespace{EquiJoinCondition.cpp}::can_combine_with(), anonymous_namespace{CompareIR.cpp}::check_array_comp_cond(), CodeGenerator::codegenCmp(), anonymous_namespace{FromTableReordering.cpp}::get_join_qual_cost(), PerfectJoinHashTable::getInstance(), CodeGenerator::hashJoinLhs(), anonymous_namespace{CompareIR.cpp}::make_eq(), CodeGenerator::needCastForHashJoinLhs(), and anonymous_namespace{QueryPlanDagExtractor.cpp}::IsEquivBinOp::operator()().

#define IS_LOGIC

(

X

)

((X) == kAND || (X) == kOR)

Definition at line 64 of file sqldefs.h.

Referenced by Analyzer::BinOper::analyze_type_info(), CodeGenerator::codegen(), CodeGenerator::codegenLogical(), and anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor::foldOper().

#define IS_UNARY

(

X

)

Value:

((X) == kNOT || (X) == kUMINUS || (X) == kISNULL || (X) == kEXISTS || (X) == kCAST || \
   (X) == kENCODE_TEXT)

Definition at line 69 of file sqldefs.h.

Enumeration Type Documentation

enum JoinType

strong

Enumerator
INNER
LEFT
SEMI
ANTI
WINDOW_FUNCTION
WINDOW_FUNCTION_FRAMING
INVALID

Definition at line 238 of file sqldefs.h.

                    {
  INNER,
  LEFT,
  SEMI,
  ANTI,
  WINDOW_FUNCTION,
  WINDOW_FUNCTION_FRAMING,
  INVALID
};

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 76 of file sqldefs.h.

            {
  kAVG,
  kMIN,
  kMAX,
  kSUM,
  kCOUNT,
  kAPPROX_COUNT_DISTINCT,
  kAPPROX_QUANTILE,
  kSAMPLE,
  kSINGLE_VALUE,
  kMODE,
  kCOUNT_IF,
  kSUM_IF,
  kINVALID_AGG
};

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 31 of file sqldefs.h.

            {
  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

Enumerator
kONE
kANY
kALL

Definition at line 74 of file sqldefs.h.

{ kONE, kANY, kALL };

enum SQLStmtType

Enumerator
kSELECT
kUPDATE
kINSERT
kDELETE
kCREATE_TABLE

Definition at line 230 of file sqldefs.h.

{ kSELECT, kUPDATE, kINSERT, kDELETE, kCREATE_TABLE };

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
REGEXP_COUNT
JSON_VALUE
BASE64_ENCODE
BASE64_DECODE
URL_ENCODE
URL_DECODE
TRY_STRING_CAST
POSITION
JAROWINKLER_SIMILARITY
LEVENSHTEIN_DISTANCE
HASH
INVALID

Definition at line 92 of file sqldefs.h.

                           {
  /* Unary */
  LOWER = 1,
  UPPER,
  INITCAP,
  REVERSE,
  /* Binary */
  REPEAT,
  CONCAT,
  RCONCAT,
  /* Ternary */
  LPAD,
  RPAD,
  TRIM,
  LTRIM,
  RTRIM,
  SUBSTRING,
  OVERLAY,
  REPLACE,
  SPLIT_PART,
  /* 6 args */
  REGEXP_REPLACE,
  REGEXP_SUBSTR,
  REGEXP_COUNT,
  JSON_VALUE,
  BASE64_ENCODE,
  BASE64_DECODE,
  URL_ENCODE,
  URL_DECODE,
  TRY_STRING_CAST,         // string-to-numeric
  POSITION,                // string-to-numeric
  JAROWINKLER_SIMILARITY,  // string-to-numeric
  LEVENSHTEIN_DISTANCE,    // string-to-numeric
  HASH,                    // string-to-numeric
  INVALID
};

enum SqlWindowFrameBoundType

strong

Enumerator
UNBOUNDED_PRECEDING
EXPR_PRECEDING
CURRENT_ROW
EXPR_FOLLOWING
UNBOUNDED_FOLLOWING
UNKNOWN

Definition at line 202 of file sqldefs.h.

                                   {
  UNBOUNDED_PRECEDING = 0,
  EXPR_PRECEDING,
  CURRENT_ROW,
  EXPR_FOLLOWING,
  UNBOUNDED_FOLLOWING,
  UNKNOWN
};

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
UNKNOWN

Definition at line 129 of file sqldefs.h.

                                 {
  MIN = 0,
  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,  // For deserialization from Calcite only. Gets rewritten to a regular
                 // SUM.
  CONDITIONAL_CHANGE_EVENT,
  UNKNOWN,
};

enum StorageOption

strong

Enumerator
kDISK
kGPU
kCPU

Definition at line 234 of file sqldefs.h.

{ kDISK = 0, kGPU = 1, kCPU = 2 };

enum ViewRefreshOption

Enumerator
kMANUAL
kAUTO
kIMMEDIATE

Definition at line 236 of file sqldefs.h.

{ kMANUAL = 0, kAUTO = 1, kIMMEDIATE = 2 };

Function Documentation

SQLAgg get_non_conditional_agg_type ( SQLAgg const  agg_type )

inline

Definition at line 320 of file sqldefs.h.

References kCOUNT, kCOUNT_IF, kSUM, and kSUM_IF.

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

                                                                  {
  switch (agg_type) {
    case kCOUNT_IF:
      return kCOUNT;
    case kSUM_IF:
      return kSUM;
    default:
      return agg_type;
  }
}

Here is the caller graph for this function:

SqlStringOpKind name_to_string_op_kind ( const std::string &  func_name )

inline

Definition at line 460 of file sqldefs.h.

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

Referenced by RelAlgTranslator::translateStringOper().

                                                                          {
  if (func_name == "LOWER") {
    return SqlStringOpKind::LOWER;
  }
  if (func_name == "UPPER") {
    return SqlStringOpKind::UPPER;
  }
  if (func_name == "INITCAP") {
    return SqlStringOpKind::INITCAP;
  }
  if (func_name == "REVERSE") {
    return SqlStringOpKind::REVERSE;
  }
  if (func_name == "REPEAT") {
    return SqlStringOpKind::REPEAT;
  }
  if (func_name == "||") {
    return SqlStringOpKind::CONCAT;
  }
  if (func_name == "LPAD") {
    return SqlStringOpKind::LPAD;
  }
  if (func_name == "RPAD") {
    return SqlStringOpKind::RPAD;
  }
  if (func_name == "TRIM") {
    return SqlStringOpKind::TRIM;
  }
  if (func_name == "LTRIM") {
    return SqlStringOpKind::LTRIM;
  }
  if (func_name == "RTRIM") {
    return SqlStringOpKind::RTRIM;
  }
  if (func_name == "SUBSTRING") {
    return SqlStringOpKind::SUBSTRING;
  }
  if (func_name == "OVERLAY") {
    return SqlStringOpKind::OVERLAY;
  }
  if (func_name == "REPLACE") {
    return SqlStringOpKind::REPLACE;
  }
  if (func_name == "SPLIT_PART") {
    return SqlStringOpKind::SPLIT_PART;
  }
  if (func_name == "REGEXP_REPLACE") {
    return SqlStringOpKind::REGEXP_REPLACE;
  }
  if (func_name == "REGEXP_SUBSTR") {
    return SqlStringOpKind::REGEXP_SUBSTR;
  }
  if (func_name == "REGEXP_MATCH") {
    return SqlStringOpKind::REGEXP_SUBSTR;
  }
  if (func_name == "REGEXP_COUNT") {
    return SqlStringOpKind::REGEXP_COUNT;
  }
  if (func_name == "JSON_VALUE") {
    return SqlStringOpKind::JSON_VALUE;
  }
  if (func_name == "BASE64_ENCODE") {
    return SqlStringOpKind::BASE64_ENCODE;
  }
  if (func_name == "BASE64_DECODE") {
    return SqlStringOpKind::BASE64_DECODE;
  }
  if (func_name == "URL_ENCODE") {
    return SqlStringOpKind::URL_ENCODE;
  }
  if (func_name == "URL_DECODE") {
    return SqlStringOpKind::URL_DECODE;
  }
  if (func_name == "TRY_CAST") {
    return SqlStringOpKind::TRY_STRING_CAST;
  }
  if (func_name == "POSITION") {
    return SqlStringOpKind::POSITION;
  }
  if (func_name == "JAROWINKLER_SIMILARITY") {
    return SqlStringOpKind::JAROWINKLER_SIMILARITY;
  }
  if (func_name == "LEVENSHTEIN_DISTANCE") {
    return SqlStringOpKind::LEVENSHTEIN_DISTANCE;
  }
  if (func_name == "HASH") {
    return SqlStringOpKind::HASH;
  }
  LOG(FATAL) << "Invalid string function " << func_name << ".";
  return SqlStringOpKind::INVALID;
}

Here is the caller graph for this function:

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

inline

Definition at line 197 of file sqldefs.h.

References toString().

                                                                                {
  return os << toString(kind);
}

Here is the call graph for this function:

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

inline

Definition at line 225 of file sqldefs.h.

References toString().

                                                                                  {
  return os << toString(kind);
}

Here is the call graph for this function:

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

inline

Definition at line 392 of file sqldefs.h.

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

                                                                          {
  switch (kind) {
    case SqlStringOpKind::LOWER:
      return os << "LOWER";
    case SqlStringOpKind::UPPER:
      return os << "UPPER";
    case SqlStringOpKind::INITCAP:
      return os << "INITCAP";
    case SqlStringOpKind::REVERSE:
      return os << "REVERSE";
    case SqlStringOpKind::REPEAT:
      return os << "REPEAT";
    case SqlStringOpKind::CONCAT:
      return os << "CONCAT";
    case SqlStringOpKind::RCONCAT:
      return os << "RCONCAT";
    case SqlStringOpKind::LPAD:
      return os << "LPAD";
    case SqlStringOpKind::RPAD:
      return os << "RPAD";
    case SqlStringOpKind::TRIM:
      return os << "TRIM";
    case SqlStringOpKind::LTRIM:
      return os << "LTRIM";
    case SqlStringOpKind::RTRIM:
      return os << "RTRIM";
    case SqlStringOpKind::SUBSTRING:
      return os << "SUBSTRING";
    case SqlStringOpKind::OVERLAY:
      return os << "OVERLAY";
    case SqlStringOpKind::REPLACE:
      return os << "REPLACE";
    case SqlStringOpKind::SPLIT_PART:
      return os << "SPLIT_PART";
    case SqlStringOpKind::REGEXP_REPLACE:
      return os << "REGEXP_REPLACE";
    case SqlStringOpKind::REGEXP_SUBSTR:
      return os << "REGEXP_SUBSTR";
    case SqlStringOpKind::REGEXP_COUNT:
      return os << "REGEXP_COUNT";
    case SqlStringOpKind::JSON_VALUE:
      return os << "JSON_VALUE";
    case SqlStringOpKind::BASE64_ENCODE:
      return os << "BASE64_ENCODE";
    case SqlStringOpKind::BASE64_DECODE:
      return os << "BASE64_DECODE";
    case SqlStringOpKind::URL_ENCODE:
      return os << "URL_ENCODE";
    case SqlStringOpKind::URL_DECODE:
      return os << "URL_DECODE";
    case SqlStringOpKind::TRY_STRING_CAST:
      return os << "TRY_STRING_CAST";
    case SqlStringOpKind::POSITION:
      return os << "POSITION";
    case SqlStringOpKind::JAROWINKLER_SIMILARITY:
      return os << "JAROWINKLER_SIMILARITY";
    case SqlStringOpKind::LEVENSHTEIN_DISTANCE:
      return os << "LEVENSHTEIN_DISTANCE";
    case SqlStringOpKind::HASH:
      return os << "HASH";
    case SqlStringOpKind::INVALID:
      return os << "INVALID";
  }
  LOG(FATAL) << "Invalid string operation";
  // Make compiler happy
  return os << "INVALID";
}

bool string_op_returns_string ( const SqlStringOpKind  kind )

inline

Definition at line 552 of file sqldefs.h.

References HASH, JAROWINKLER_SIMILARITY, LEVENSHTEIN_DISTANCE, POSITION, REGEXP_COUNT, and TRY_STRING_CAST.

Referenced by TextEncodingCastCountVisitor::visitStringOper().

                                                                 {
  switch (kind) {
    case SqlStringOpKind::TRY_STRING_CAST:
    case SqlStringOpKind::POSITION:
    case SqlStringOpKind::JAROWINKLER_SIMILARITY:
    case SqlStringOpKind::LEVENSHTEIN_DISTANCE:
    case SqlStringOpKind::REGEXP_COUNT:
    case SqlStringOpKind::HASH:
      return false;
    default:
      return true;
  }
}

Here is the caller graph for this function:

constexpr char const* toString

(

SqlWindowFunctionKind const

kind

)

Definition at line 161 of file sqldefs.h.

References UNKNOWN.

                                                                 {
  constexpr char const* strings[]{"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",
                                  "UNKNOWN"};
  constexpr size_t nstrings = ((sizeof strings) / (sizeof *strings));
  constexpr size_t max_str_idx = nstrings - 1;
  static_assert(max_str_idx == size_t(SqlWindowFunctionKind::UNKNOWN));
  return strings[size_t(kind)];
}

constexpr char const* toString

(

SqlWindowFrameBoundType const

kind

)

Definition at line 211 of file sqldefs.h.

References UNKNOWN.

                                                                   {
  constexpr char const* strings[]{"UNBOUNDED_PRECEDING",
                                  "EXPR_PRECEDING",
                                  "CURRENT_ROW",
                                  "EXPR_FOLLOWING",
                                  "UNBOUNDED_FOLLOWING",
                                  "UNKNOWN"};
  constexpr size_t nstrings = ((sizeof strings) / (sizeof *strings));
  constexpr size_t max_str_idx = nstrings - 1;
  static_assert(max_str_idx == size_t(SqlWindowFrameBoundType::UNKNOWN));
  return strings[size_t(kind)];
}

std::string toString ( const JoinType &  join_type )

inline

Definition at line 254 of file sqldefs.h.

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

                                                     {
  switch (join_type) {
    case JoinType::INNER:
      return "INNER";
    case JoinType::LEFT:
      return "LEFT";
    case JoinType::SEMI:
      return "SEMI";
    case JoinType::ANTI:
      return "ANTI";
    case JoinType::WINDOW_FUNCTION:
      return "WINDOW_FUNCTION";
    case JoinType::WINDOW_FUNCTION_FRAMING:
      return "WINDOW_FUNCTION_FRAMING";
    default:
      return "INVALID";
  }
}

std::string toString ( const SQLQualifier &  qualifier )

inline

Definition at line 273 of file sqldefs.h.

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

                                                         {
  switch (qualifier) {
    case kONE:
      return "ONE";
    case kANY:
      return "ANY";
    case kALL:
      return "ALL";
  }
  LOG(FATAL) << "Invalid SQLQualifier: " << qualifier;
  return "";
}

std::string toString ( const SQLAgg &  kind )

inline

Definition at line 286 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.

                                              {
  switch (kind) {
    case kAVG:
      return "AVG";
    case kMIN:
      return "MIN";
    case kMAX:
      return "MAX";
    case kSUM:
      return "SUM";
    case kCOUNT:
      return "COUNT";
    case kAPPROX_COUNT_DISTINCT:
      return "APPROX_COUNT_DISTINCT";
    case kAPPROX_QUANTILE:
      return "APPROX_PERCENTILE";
    case kSAMPLE:
      return "SAMPLE";
    case kSINGLE_VALUE:
      return "SINGLE_VALUE";
    case kMODE:
      return "MODE";
    case kCOUNT_IF:
      return "COUNT_IF";
    case kSUM_IF:
      return "SUM_IF";
    case kINVALID_AGG:
      return "INVALID";
    default:
      UNREACHABLE() << "Invalid aggregate kind: " << kind;
      return {};
  }
}

std::string toString ( const SQLOps &  op )

inline

Definition at line 331 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.

                                            {
  switch (op) {
    case kEQ:
      return "EQ";
    case kBW_EQ:
      return "BW_EQ";
    case kNE:
      return "NE";
    case kLT:
      return "LT";
    case kGT:
      return "GT";
    case kLE:
      return "LE";
    case kGE:
      return "GE";
    case kAND:
      return "AND";
    case kOR:
      return "OR";
    case kNOT:
      return "NOT";
    case kMINUS:
      return "MINUS";
    case kPLUS:
      return "PLUS";
    case kMULTIPLY:
      return "MULTIPLY";
    case kDIVIDE:
      return "DIVIDE";
    case kMODULO:
      return "MODULO";
    case kUMINUS:
      return "UMINUS";
    case kISNULL:
      return "ISNULL";
    case kISNOTNULL:
      return "ISNOTNULL";
    case kEXISTS:
      return "EXISTS";
    case kCAST:
      return "CAST";
    case kARRAY_AT:
      return "ARRAY_AT";
    case kUNNEST:
      return "UNNEST";
    case kFUNCTION:
      return "FUNCTION";
    case kIN:
      return "IN";
    case kBBOX_INTERSECT:
      return "BOUNDING_BOX_INTERSECT";
    case kENCODE_TEXT:
      return "ENCODE_TEXT";
    case kINVALID_OP:
      return "INVALID_OP";
  }
  LOG(FATAL) << "Invalid operation kind: " << op;
  return "";
}