OmniSciDB  c1a53651b2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ParserNode.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 PARSER_NODE_H_
24 #define PARSER_NODE_H_
25 
26 #include <cstdint>
27 #include <cstring>
28 #include <list>
29 #include <string>
30 
31 #include <boost/algorithm/string/predicate.hpp>
32 #include <boost/process/search_path.hpp>
33 
34 #include "Analyzer/Analyzer.h"
35 #include "Catalog/Catalog.h"
38 #include "Shared/sqldefs.h"
39 #include "Shared/sqltypes.h"
42 #include "Utils/DdlUtils.h"
43 
44 #include <ImportExport/Importer.h>
46 
47 #include <functional>
48 
49 namespace query_state {
50 class QueryState;
51 class QueryStateProxy;
52 } // namespace query_state
54 
55 namespace Parser {
56 
57 /*
58  * @type Node
59  * @brief root super class for all nodes in a pre-Analyzer
60  * parse tree.
61  */
62 class Node {
63  public:
64  virtual ~Node() {}
65 };
66 
67 /*
68  * @type SQLType
69  * @brief class that captures type, predication and scale.
70  */
71 class SQLType : public Node, public ddl_utils::SqlType {
72  public:
73  explicit SQLType(SQLTypes t) : ddl_utils::SqlType(t, -1, 0, false, -1) {}
74  SQLType(SQLTypes t, int p1) : ddl_utils::SqlType(t, p1, 0, false, -1) {}
75  SQLType(SQLTypes t, int p1, int p2, bool a) : ddl_utils::SqlType(t, p1, p2, a, -1) {}
76  SQLType(SQLTypes t, int p1, int p2, bool a, int array_size)
77  : ddl_utils::SqlType(t, p1, p2, a, array_size) {}
78  SQLType(SQLTypes t, bool a, int array_size)
79  : ddl_utils::SqlType(t, -1, 0, a, array_size) {}
80 };
81 
82 /*
83  * @type Expr
84  * @brief root super class for all expression nodes
85  */
86 class Expr : public Node {
87  public:
89  /*
90  * @brief Performs semantic analysis on the expression node
91  * @param catalog The catalog object for the current database
92  * @return An Analyzer::Expr object for the expression post semantic analysis
93  */
94  virtual std::shared_ptr<Analyzer::Expr> analyze(
95  const Catalog_Namespace::Catalog& catalog,
96  Analyzer::Query& query,
97  TlistRefType allow_tlist_ref = TLIST_NONE) const = 0;
98  virtual std::string to_string() const = 0;
99 };
100 
101 /*
102  * @type Literal
103  * @brief root super class for all literals
104  */
105 class Literal : public Expr {
106  public:
107  std::shared_ptr<Analyzer::Expr> analyze(
108  const Catalog_Namespace::Catalog& catalog,
109  Analyzer::Query& query,
110  TlistRefType allow_tlist_ref = TLIST_NONE) const override = 0;
111  std::string to_string() const override = 0;
112 };
113 
114 /*
115  * @type NullLiteral
116  * @brief the Literal NULL
117  */
118 class NullLiteral : public Literal {
119  public:
121  std::shared_ptr<Analyzer::Expr> analyze(
122  const Catalog_Namespace::Catalog& catalog,
123  Analyzer::Query& query,
124  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
125  std::string to_string() const override { return "NULL"; }
126 };
127 
128 /*
129  * @type StringLiteral
130  * @brief the literal for string constants
131  */
132 class StringLiteral : public Literal {
133  public:
134  explicit StringLiteral(std::string* s) : stringval_(s) {}
135  const std::string* get_stringval() const { return stringval_.get(); }
136  std::shared_ptr<Analyzer::Expr> analyze(
137  const Catalog_Namespace::Catalog& catalog,
138  Analyzer::Query& query,
139  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
140  static std::shared_ptr<Analyzer::Expr> analyzeValue(const std::string& stringval,
141  const bool is_null);
142  std::string to_string() const override { return "'" + *stringval_ + "'"; }
143 
144  private:
145  std::unique_ptr<std::string> stringval_;
146 };
147 
148 /*
149  * @type IntLiteral
150  * @brief the literal for integer constants
151  */
152 class IntLiteral : public Literal {
153  public:
154  explicit IntLiteral(int64_t i) : intval_(i) {}
155  int64_t get_intval() const { return intval_; }
156  std::shared_ptr<Analyzer::Expr> analyze(
157  const Catalog_Namespace::Catalog& catalog,
158  Analyzer::Query& query,
159  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
160  static std::shared_ptr<Analyzer::Expr> analyzeValue(const int64_t intval);
161  std::string to_string() const override {
162  return boost::lexical_cast<std::string>(intval_);
163  }
164 
165  private:
166  int64_t intval_;
167 };
168 
169 /*
170  * @type FixedPtLiteral
171  * @brief the literal for DECIMAL and NUMERIC
172  */
173 class FixedPtLiteral : public Literal {
174  public:
175  explicit FixedPtLiteral(std::string* n) : fixedptval_(n) {}
176  const std::string* get_fixedptval() const { return fixedptval_.get(); }
177  std::shared_ptr<Analyzer::Expr> analyze(
178  const Catalog_Namespace::Catalog& catalog,
179  Analyzer::Query& query,
180  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
181  static std::shared_ptr<Analyzer::Expr> analyzeValue(const int64_t numericval,
182  const int scale,
183  const int precision);
184  std::string to_string() const override { return *fixedptval_; }
185 
186  private:
187  std::unique_ptr<std::string> fixedptval_;
188 };
189 
190 /*
191  * @type FloatLiteral
192  * @brief the literal for FLOAT or REAL
193  */
194 class FloatLiteral : public Literal {
195  public:
196  explicit FloatLiteral(float f) : floatval_(f) {}
197  float get_floatval() const { return floatval_; }
198  std::shared_ptr<Analyzer::Expr> analyze(
199  const Catalog_Namespace::Catalog& catalog,
200  Analyzer::Query& query,
201  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
202  std::string to_string() const override {
203  return boost::lexical_cast<std::string>(floatval_);
204  }
205 
206  private:
207  float floatval_;
208 };
209 
210 /*
211  * @type DoubleLiteral
212  * @brief the literal for DOUBLE PRECISION
213  */
214 class DoubleLiteral : public Literal {
215  public:
216  explicit DoubleLiteral(double d) : doubleval_(d) {}
217  double get_doubleval() const { return doubleval_; }
218  std::shared_ptr<Analyzer::Expr> analyze(
219  const Catalog_Namespace::Catalog& catalog,
220  Analyzer::Query& query,
221  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
222  std::string to_string() const override {
223  return boost::lexical_cast<std::string>(doubleval_);
224  }
225 
226  private:
227  double doubleval_;
228 };
229 
230 /*
231  * @type TimestampLiteral
232  * @brief the literal for Timestamp
233  */
234 class TimestampLiteral : public Literal {
235  public:
236  explicit TimestampLiteral() { time(reinterpret_cast<time_t*>(&timestampval_)); }
237  std::shared_ptr<Analyzer::Expr> analyze(
238  const Catalog_Namespace::Catalog& catalog,
239  Analyzer::Query& query,
240  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
241  static std::shared_ptr<Analyzer::Expr> get(const int64_t);
242  std::string to_string() const override {
243  // TODO: Should we convert to a datum and use the datum toString converters to pretty
244  // print?
245  return boost::lexical_cast<std::string>(timestampval_);
246  }
247 
248  private:
249  int64_t timestampval_;
250 };
251 
252 /*
253  * @type UserLiteral
254  * @brief the literal for USER
255  */
256 class UserLiteral : public Literal {
257  public:
259  std::shared_ptr<Analyzer::Expr> analyze(
260  const Catalog_Namespace::Catalog& catalog,
261  Analyzer::Query& query,
262  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
263  static std::shared_ptr<Analyzer::Expr> get(const std::string&);
264  std::string to_string() const override { return "USER"; }
265 };
266 
267 /*
268  * @type ArrayLiteral
269  * @brief the literal for arrays
270  */
271 class ArrayLiteral : public Literal {
272  public:
274  ArrayLiteral(std::list<Expr*>* v) {
275  CHECK(v);
276  for (const auto e : *v) {
277  value_list_.emplace_back(e);
278  }
279  delete v;
280  }
281  const std::list<std::unique_ptr<Expr>>& get_value_list() const { return value_list_; }
282  std::shared_ptr<Analyzer::Expr> analyze(
283  const Catalog_Namespace::Catalog& catalog,
284  Analyzer::Query& query,
285  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
286  std::string to_string() const override;
287 
288  private:
289  std::list<std::unique_ptr<Expr>> value_list_;
290 };
291 
292 /*
293  * @type OperExpr
294  * @brief all operator expressions
295  */
296 class OperExpr : public Expr {
297  public:
299  : optype_(t), opqualifier_(kONE), left_(l), right_(r) {}
301  : optype_(t), opqualifier_(q), left_(l), right_(r) {}
302  SQLOps get_optype() const { return optype_; }
303  const Expr* get_left() const { return left_.get(); }
304  const Expr* get_right() const { return right_.get(); }
305  std::shared_ptr<Analyzer::Expr> analyze(
306  const Catalog_Namespace::Catalog& catalog,
307  Analyzer::Query& query,
308  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
309  static std::shared_ptr<Analyzer::Expr> normalize(
310  const SQLOps optype,
311  const SQLQualifier qual,
312  std::shared_ptr<Analyzer::Expr> left_expr,
313  std::shared_ptr<Analyzer::Expr> right_expr,
314  const Executor* executor = nullptr);
315  std::string to_string() const override;
316 
317  private:
320  std::unique_ptr<Expr> left_;
321  std::unique_ptr<Expr> right_;
322 };
323 
324 // forward reference of QuerySpec
325 class QuerySpec;
326 
327 /*
328  * @type SubqueryExpr
329  * @brief expression for subquery
330  */
331 class SubqueryExpr : public Expr {
332  public:
333  explicit SubqueryExpr(QuerySpec* q) : query_(q) {}
334  const QuerySpec* get_query() const { return query_.get(); }
335  std::shared_ptr<Analyzer::Expr> analyze(
336  const Catalog_Namespace::Catalog& catalog,
337  Analyzer::Query& query,
338  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
339  std::string to_string() const override;
340 
341  private:
342  std::unique_ptr<QuerySpec> query_;
343 };
344 
345 class IsNullExpr : public Expr {
346  public:
347  IsNullExpr(bool n, Expr* a) : is_not_(n), arg_(a) {}
348  bool get_is_not() const { return is_not_; }
349  std::shared_ptr<Analyzer::Expr> analyze(
350  const Catalog_Namespace::Catalog& catalog,
351  Analyzer::Query& query,
352  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
353  std::string to_string() const override;
354 
355  private:
356  bool is_not_;
357  std::unique_ptr<Expr> arg_;
358 };
359 
360 /*
361  * @type InExpr
362  * @brief expression for the IS NULL predicate
363  */
364 class InExpr : public Expr {
365  public:
366  InExpr(bool n, Expr* a) : is_not_(n), arg_(a) {}
367  bool get_is_not() const { return is_not_; }
368  const Expr* get_arg() const { return arg_.get(); }
369  std::shared_ptr<Analyzer::Expr> analyze(
370  const Catalog_Namespace::Catalog& catalog,
371  Analyzer::Query& query,
372  TlistRefType allow_tlist_ref = TLIST_NONE) const override = 0;
373  std::string to_string() const override;
374 
375  protected:
376  bool is_not_;
377  std::unique_ptr<Expr> arg_;
378 };
379 
380 /*
381  * @type InSubquery
382  * @brief expression for the IN (subquery) predicate
383  */
384 class InSubquery : public InExpr {
385  public:
386  InSubquery(bool n, Expr* a, SubqueryExpr* q) : InExpr(n, a), subquery_(q) {}
387  const SubqueryExpr* get_subquery() const { return subquery_.get(); }
388  std::shared_ptr<Analyzer::Expr> analyze(
389  const Catalog_Namespace::Catalog& catalog,
390  Analyzer::Query& query,
391  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
392  std::string to_string() const override;
393 
394  private:
395  std::unique_ptr<SubqueryExpr> subquery_;
396 };
397 
398 /*
399  * @type InValues
400  * @brief expression for IN (val1, val2, ...)
401  */
402 class InValues : public InExpr {
403  public:
404  InValues(bool n, Expr* a, std::list<Expr*>* v) : InExpr(n, a) {
405  CHECK(v);
406  for (const auto e : *v) {
407  value_list_.emplace_back(e);
408  }
409  delete v;
410  }
411  const std::list<std::unique_ptr<Expr>>& get_value_list() const { return value_list_; }
412  std::shared_ptr<Analyzer::Expr> analyze(
413  const Catalog_Namespace::Catalog& catalog,
414  Analyzer::Query& query,
415  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
416  std::string to_string() const override;
417 
418  private:
419  std::list<std::unique_ptr<Expr>> value_list_;
420 };
421 
422 /*
423  * @type BetweenExpr
424  * @brief expression for BETWEEN lower AND upper
425  */
426 class BetweenExpr : public Expr {
427  public:
428  BetweenExpr(bool n, Expr* a, Expr* l, Expr* u)
429  : is_not_(n), arg_(a), lower_(l), upper_(u) {}
430  bool get_is_not() const { return is_not_; }
431  const Expr* get_arg() const { return arg_.get(); }
432  const Expr* get_lower() const { return lower_.get(); }
433  const Expr* get_upper() const { return upper_.get(); }
434  std::shared_ptr<Analyzer::Expr> analyze(
435  const Catalog_Namespace::Catalog& catalog,
436  Analyzer::Query& query,
437  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
438  std::string to_string() const override;
439 
440  private:
441  bool is_not_;
442  std::unique_ptr<Expr> arg_;
443  std::unique_ptr<Expr> lower_;
444  std::unique_ptr<Expr> upper_;
445 };
446 
447 /*
448  * @type CharLengthExpr
449  * @brief expression to get length of string
450  */
451 
452 class CharLengthExpr : public Expr {
453  public:
455  const Expr* get_arg() const { return arg_.get(); }
457  std::shared_ptr<Analyzer::Expr> analyze(
458  const Catalog_Namespace::Catalog& catalog,
459  Analyzer::Query& query,
460  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
461  std::string to_string() const override;
462 
463  private:
464  std::unique_ptr<Expr> arg_;
466 };
467 
468 /*
469  * @type CardinalityExpr
470  * @brief expression to get cardinality of an array
471  */
472 
473 class CardinalityExpr : public Expr {
474  public:
476  const Expr* get_arg() const { return arg_.get(); }
477  std::shared_ptr<Analyzer::Expr> analyze(
478  const Catalog_Namespace::Catalog& catalog,
479  Analyzer::Query& query,
480  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
481  std::string to_string() const override;
482 
483  private:
484  std::unique_ptr<Expr> arg_;
485 };
486 
487 /*
488  * @type LikeExpr
489  * @brief expression for the LIKE predicate
490  */
491 class LikeExpr : public Expr {
492  public:
493  LikeExpr(bool n, bool i, Expr* a, Expr* l, Expr* e)
494  : is_not_(n), is_ilike_(i), arg_(a), like_string_(l), escape_string_(e) {}
495  bool get_is_not() const { return is_not_; }
496  const Expr* get_arg() const { return arg_.get(); }
497  const Expr* get_like_string() const { return like_string_.get(); }
498  const Expr* get_escape_string() const { return escape_string_.get(); }
499  std::shared_ptr<Analyzer::Expr> analyze(
500  const Catalog_Namespace::Catalog& catalog,
501  Analyzer::Query& query,
502  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
503  static std::shared_ptr<Analyzer::Expr> get(std::shared_ptr<Analyzer::Expr> arg_expr,
504  std::shared_ptr<Analyzer::Expr> like_expr,
505  std::shared_ptr<Analyzer::Expr> escape_expr,
506  const bool is_ilike,
507  const bool is_not);
508  std::string to_string() const override;
509 
510  private:
511  bool is_not_;
512  bool is_ilike_;
513  std::unique_ptr<Expr> arg_;
514  std::unique_ptr<Expr> like_string_;
515  std::unique_ptr<Expr> escape_string_;
516 
517  static void check_like_expr(const std::string& like_str, char escape_char);
518  static bool test_is_simple_expr(const std::string& like_str, char escape_char);
519  static void erase_cntl_chars(std::string& like_str, char escape_char);
520 };
521 
522 /*
523  * @type RegexpExpr
524  * @brief expression for REGEXP
525  */
526 class RegexpExpr : public Expr {
527  public:
528  RegexpExpr(bool n, Expr* a, Expr* p, Expr* e)
529  : is_not_(n), arg_(a), pattern_string_(p), escape_string_(e) {}
530  bool get_is_not() const { return is_not_; }
531  const Expr* get_arg() const { return arg_.get(); }
532  const Expr* get_pattern_string() const { return pattern_string_.get(); }
533  const Expr* get_escape_string() const { return escape_string_.get(); }
534  std::shared_ptr<Analyzer::Expr> analyze(
535  const Catalog_Namespace::Catalog& catalog,
536  Analyzer::Query& query,
537  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
538  static std::shared_ptr<Analyzer::Expr> get(std::shared_ptr<Analyzer::Expr> arg_expr,
539  std::shared_ptr<Analyzer::Expr> pattern_expr,
540  std::shared_ptr<Analyzer::Expr> escape_expr,
541  const bool is_not);
542  std::string to_string() const override;
543 
544  private:
545  bool is_not_;
546  std::unique_ptr<Expr> arg_;
547  std::unique_ptr<Expr> pattern_string_;
548  std::unique_ptr<Expr> escape_string_;
549 
550  static void check_pattern_expr(const std::string& pattern_str, char escape_char);
551  static bool translate_to_like_pattern(std::string& pattern_str, char escape_char);
552 };
553 
554 class WidthBucketExpr : public Expr {
555  public:
558  const Expr* get_target_value() const { return target_value_.get(); }
559  const Expr* get_lower_bound() const { return lower_bound_.get(); }
560  const Expr* get_upper_bound() const { return upper_bound_.get(); }
561  const Expr* get_partition_count() const { return partition_count_.get(); }
562  std::shared_ptr<Analyzer::Expr> analyze(
563  const Catalog_Namespace::Catalog& catalog,
564  Analyzer::Query& query,
565  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
566  static std::shared_ptr<Analyzer::Expr> get(
567  std::shared_ptr<Analyzer::Expr> target_value,
568  std::shared_ptr<Analyzer::Expr> lower_bound,
569  std::shared_ptr<Analyzer::Expr> upper_bound,
570  std::shared_ptr<Analyzer::Expr> partition_count);
571  std::string to_string() const override;
572 
573  private:
574  std::unique_ptr<Expr> target_value_;
575  std::unique_ptr<Expr> lower_bound_;
576  std::unique_ptr<Expr> upper_bound_;
577  std::unique_ptr<Expr> partition_count_;
578 };
579 
580 /*
581  * @type LikelihoodExpr
582  * @brief expression for LIKELY, UNLIKELY
583  */
584 class LikelihoodExpr : public Expr {
585  public:
586  LikelihoodExpr(bool n, Expr* a, float l) : is_not_(n), arg_(a), likelihood_(l) {}
587  bool get_is_not() const { return is_not_; }
588  const Expr* get_arg() const { return arg_.get(); }
589  float get_likelihood() const { return likelihood_; }
590  std::shared_ptr<Analyzer::Expr> analyze(
591  const Catalog_Namespace::Catalog& catalog,
592  Analyzer::Query& query,
593  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
594  static std::shared_ptr<Analyzer::Expr> get(std::shared_ptr<Analyzer::Expr> arg_expr,
595  float likelihood,
596  const bool is_not);
597  std::string to_string() const override;
598 
599  private:
600  bool is_not_;
601  std::unique_ptr<Expr> arg_;
602  float likelihood_;
603 };
604 
605 /*
606  * @type ExistsExpr
607  * @brief expression for EXISTS (subquery)
608  */
609 class ExistsExpr : public Expr {
610  public:
611  explicit ExistsExpr(QuerySpec* q) : query_(q) {}
612  const QuerySpec* get_query() const { return query_.get(); }
613  std::shared_ptr<Analyzer::Expr> analyze(
614  const Catalog_Namespace::Catalog& catalog,
615  Analyzer::Query& query,
616  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
617  std::string to_string() const override;
618 
619  private:
620  std::unique_ptr<QuerySpec> query_;
621 };
622 
623 /*
624  * @type ColumnRef
625  * @brief expression for a column reference
626  */
627 class ColumnRef : public Expr {
628  public:
629  explicit ColumnRef(std::string* n1) : table_(nullptr), column_(n1) {}
630  ColumnRef(std::string* n1, std::string* n2) : table_(n1), column_(n2) {}
631  const std::string* get_table() const { return table_.get(); }
632  const std::string* get_column() const { return column_.get(); }
633  std::shared_ptr<Analyzer::Expr> analyze(
634  const Catalog_Namespace::Catalog& catalog,
635  Analyzer::Query& query,
636  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
637  std::string to_string() const override;
638 
639  private:
640  std::unique_ptr<std::string> table_;
641  std::unique_ptr<std::string> column_; // can be nullptr in the t.* case
642 };
643 
644 /*
645  * @type FunctionRef
646  * @brief expression for a function call
647  */
648 class FunctionRef : public Expr {
649  public:
650  explicit FunctionRef(std::string* n) : name_(n), distinct_(false), arg_(nullptr) {}
651  FunctionRef(std::string* n, Expr* a) : name_(n), distinct_(false), arg_(a) {}
652  FunctionRef(std::string* n, bool d, Expr* a) : name_(n), distinct_(d), arg_(a) {}
653  const std::string* get_name() const { return name_.get(); }
654  bool get_distinct() const { return distinct_; }
655  Expr* get_arg() const { return arg_.get(); }
656  std::shared_ptr<Analyzer::Expr> analyze(
657  const Catalog_Namespace::Catalog& catalog,
658  Analyzer::Query& query,
659  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
660  std::string to_string() const override;
661 
662  private:
663  std::unique_ptr<std::string> name_;
664  bool distinct_; // only true for COUNT(DISTINCT x)
665  std::unique_ptr<Expr> arg_; // for COUNT, nullptr means '*'
666 };
667 
668 class CastExpr : public Expr {
669  public:
671  std::shared_ptr<Analyzer::Expr> analyze(
672  const Catalog_Namespace::Catalog& catalog,
673  Analyzer::Query& query,
674  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
675  std::string to_string() const override {
676  return "CAST(" + arg_->to_string() + " AS " + target_type_->to_string() + ")";
677  }
678 
679  private:
680  std::unique_ptr<Expr> arg_;
681  std::unique_ptr<SQLType> target_type_;
682 };
683 
684 class ExprPair : public Node {
685  public:
686  ExprPair(Expr* e1, Expr* e2) : expr1_(e1), expr2_(e2) {}
687  const Expr* get_expr1() const { return expr1_.get(); }
688  const Expr* get_expr2() const { return expr2_.get(); }
689 
690  private:
691  std::unique_ptr<Expr> expr1_;
692  std::unique_ptr<Expr> expr2_;
693 };
694 
695 class CaseExpr : public Expr {
696  public:
697  CaseExpr(std::list<ExprPair*>* w, Expr* e) : else_expr_(e) {
698  CHECK(w);
699  for (const auto e : *w) {
700  when_then_list_.emplace_back(e);
701  }
702  delete w;
703  }
704  std::shared_ptr<Analyzer::Expr> analyze(
705  const Catalog_Namespace::Catalog& catalog,
706  Analyzer::Query& query,
707  TlistRefType allow_tlist_ref = TLIST_NONE) const override;
708  static std::shared_ptr<Analyzer::Expr> normalize(
709  const std::list<
710  std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>&,
711  const std::shared_ptr<Analyzer::Expr>,
712  const Executor* executor = nullptr);
713  std::string to_string() const override;
714 
715  private:
716  std::list<std::unique_ptr<ExprPair>> when_then_list_;
717  std::unique_ptr<Expr> else_expr_;
718 };
719 
720 /*
721  * @type TableRef
722  * @brief table reference in FROM clause
723  */
724 class TableRef : public Node {
725  public:
726  explicit TableRef(std::string* t) : table_name_(t), range_var_(nullptr) {}
727  TableRef(std::string* t, std::string* r) : table_name_(t), range_var_(r) {}
728  const std::string* get_table_name() const { return table_name_.get(); }
729  const std::string* get_range_var() const { return range_var_.get(); }
730  std::string to_string() const;
731 
732  private:
733  std::unique_ptr<std::string> table_name_;
734  std::unique_ptr<std::string> range_var_;
735 };
736 
737 /*
738  * @type Stmt
739  * @brief root super class for all SQL statements
740  */
741 class Stmt : public Node {
742  // intentionally empty
743 };
744 
745 /*
746  * @type DMLStmt
747  * @brief DML Statements
748  */
749 class DMLStmt : public Stmt {
750  public:
751  virtual void analyze(const Catalog_Namespace::Catalog& catalog,
752  Analyzer::Query& query) const = 0;
753 };
754 
755 /*
756  * @type DDLStmt
757  * @brief DDL Statements
758  */
759 class ColumnDef;
760 class DDLStmt : public Stmt {
761  public:
762  virtual void execute(const Catalog_Namespace::SessionInfo& session,
763  bool read_only_mode) = 0;
764  void setColumnDescriptor(ColumnDescriptor& cd, const ColumnDef* coldef);
765 };
766 
767 /*
768  * @type TableElement
769  * @brief elements in table definition
770  */
771 class TableElement : public Node {
772  // intentionally empty
773 };
774 
775 /*
776  * @type ColumnConstraintDef
777  * @brief integrity constraint on a column
778  */
779 class ColumnConstraintDef : public Node {
780  public:
781  ColumnConstraintDef(bool n, bool u, bool p, Literal* d)
782  : notnull_(n), unique_(u), is_primarykey_(p), defaultval_(d) {}
785  ColumnConstraintDef(std::string* t, std::string* c)
786  : notnull_(false)
787  , unique_(false)
789  , foreign_table_(t)
790  , foreign_column_(c) {}
791  bool get_notnull() const { return notnull_; }
792  bool get_unique() const { return unique_; }
793  bool get_is_primarykey() const { return is_primarykey_; }
794  const Literal* get_defaultval() const { return defaultval_.get(); }
795  const Expr* get_check_condition() const { return check_condition_.get(); }
796  const std::string* get_foreign_table() const { return foreign_table_.get(); }
797  const std::string* get_foreign_column() const { return foreign_column_.get(); }
798 
799  private:
800  bool notnull_;
801  bool unique_;
803  std::unique_ptr<Literal> defaultval_;
804  std::unique_ptr<Expr> check_condition_;
805  std::unique_ptr<std::string> foreign_table_;
806  std::unique_ptr<std::string> foreign_column_;
807 };
808 
809 /*
810  * @type CompressDef
811  * @brief Node for compression scheme definition
812  */
813 class CompressDef : public Node, public ddl_utils::Encoding {
814  public:
815  CompressDef(std::string* n, int p) : ddl_utils::Encoding(n, p) {}
816 };
817 
818 /*
819  * @type ColumnDef
820  * @brief Column definition
821  */
822 class ColumnDef : public TableElement {
823  public:
824  ColumnDef(std::string* c, SQLType* t, CompressDef* cp, ColumnConstraintDef* cc)
826  const std::string* get_column_name() const { return column_name_.get(); }
827  SQLType* get_column_type() const { return column_type_.get(); }
828  const CompressDef* get_compression() const { return compression_.get(); }
830  return column_constraint_.get();
831  }
832 
833  private:
834  std::unique_ptr<std::string> column_name_;
835  std::unique_ptr<SQLType> column_type_;
836  std::unique_ptr<CompressDef> compression_;
837  std::unique_ptr<ColumnConstraintDef> column_constraint_;
838 };
839 
840 /*
841  * @type TableConstraintDef
842  * @brief integrity constraint for table
843  */
845  // intentionally empty
846 };
847 
848 /*
849  * @type UniqueDef
850  * @brief uniqueness constraint
851  */
853  public:
854  UniqueDef(bool p, std::list<std::string*>* cl) : is_primarykey_(p) {
855  CHECK(cl);
856  for (const auto s : *cl) {
857  column_list_.emplace_back(s);
858  }
859  delete cl;
860  }
861  bool get_is_primarykey() const { return is_primarykey_; }
862  const std::list<std::unique_ptr<std::string>>& get_column_list() const {
863  return column_list_;
864  }
865 
866  private:
868  std::list<std::unique_ptr<std::string>> column_list_;
869 };
870 
871 /*
872  * @type ForeignKeyDef
873  * @brief foreign key constraint
874  */
876  public:
877  ForeignKeyDef(std::list<std::string*>* cl, std::string* t, std::list<std::string*>* fcl)
878  : foreign_table_(t) {
879  CHECK(cl);
880  for (const auto s : *cl) {
881  column_list_.emplace_back(s);
882  }
883  delete cl;
884  if (fcl) {
885  for (const auto s : *fcl) {
886  foreign_column_list_.emplace_back(s);
887  }
888  }
889  delete fcl;
890  }
891  const std::list<std::unique_ptr<std::string>>& get_column_list() const {
892  return column_list_;
893  }
894  const std::string* get_foreign_table() const { return foreign_table_.get(); }
895  const std::list<std::unique_ptr<std::string>>& get_foreign_column_list() const {
896  return foreign_column_list_;
897  }
898 
899  private:
900  std::list<std::unique_ptr<std::string>> column_list_;
901  std::unique_ptr<std::string> foreign_table_;
902  std::list<std::unique_ptr<std::string>> foreign_column_list_;
903 };
904 
905 /*
906  * @type CheckDef
907  * @brief Check constraint
908  */
909 class CheckDef : public TableConstraintDef {
910  public:
912  const Expr* get_check_condition() const { return check_condition_.get(); }
913 
914  private:
915  std::unique_ptr<Expr> check_condition_;
916 };
917 
918 /*
919  * @type SharedDictionaryDef
920  * @brief Shared dictionary hint. The underlying string dictionary will be shared with the
921  * referenced column.
922  */
924  public:
925  SharedDictionaryDef(const std::string& column,
926  const std::string& foreign_table,
927  const std::string foreign_column)
928  : column_(column), foreign_table_(foreign_table), foreign_column_(foreign_column) {}
929 
930  const std::string& get_column() const { return column_; }
931 
932  const std::string& get_foreign_table() const { return foreign_table_; }
933 
934  const std::string& get_foreign_column() const { return foreign_column_; }
935 
936  private:
937  const std::string column_;
938  const std::string foreign_table_;
939  const std::string foreign_column_;
940 };
941 
942 /*
943  * @type ShardKeyDef
944  * @brief Shard key for a table, mainly useful for distributed joins.
945  */
947  public:
948  ShardKeyDef(const std::string& column) : column_(column) {}
949 
950  const std::string& get_column() const { return column_; }
951 
952  private:
953  const std::string column_;
954 };
955 
956 /*
957  * @type NameValueAssign
958  * @brief Assignment of a string value to a named attribute
959  */
960 class NameValueAssign : public Node {
961  public:
962  NameValueAssign(std::string* n, Literal* v) : name_(n), value_(v) {}
963  const std::string* get_name() const { return name_.get(); }
964  const Literal* get_value() const { return value_.get(); }
965 
966  private:
967  std::unique_ptr<std::string> name_;
968  std::unique_ptr<Literal> value_;
969 };
970 
971 /*
972  * @type CreateTableBaseStmt
973  */
974 class CreateTableBaseStmt : public DDLStmt {
975  public:
976  virtual const std::string* get_table() const = 0;
977  virtual const std::list<std::unique_ptr<TableElement>>& get_table_element_list()
978  const = 0;
979 };
980 
981 /*
982  * @type CreateTableStmt
983  * @brief CREATE TABLE statement
984  */
986  public:
987  CreateTableStmt(std::string* tab,
988  const std::string* storage,
989  std::list<TableElement*>* table_elems,
990  bool is_temporary,
991  bool if_not_exists,
992  std::list<NameValueAssign*>* s)
993  : table_(tab), is_temporary_(is_temporary), if_not_exists_(if_not_exists) {
994  CHECK(table_elems);
995  for (const auto e : *table_elems) {
996  table_element_list_.emplace_back(e);
997  }
998  delete table_elems;
999  if (s) {
1000  for (const auto e : *s) {
1001  storage_options_.emplace_back(e);
1002  }
1003  delete s;
1004  }
1005  }
1006 
1007  CreateTableStmt(const rapidjson::Value& payload);
1008 
1009  const std::string* get_table() const override { return table_.get(); }
1010  const std::list<std::unique_ptr<TableElement>>& get_table_element_list()
1011  const override {
1012  return table_element_list_;
1013  }
1014 
1015  void execute(const Catalog_Namespace::SessionInfo& session,
1016  bool read_only_mode) override;
1017  void executeDryRun(const Catalog_Namespace::SessionInfo& session,
1018  TableDescriptor& td,
1019  std::list<ColumnDescriptor>& columns,
1020  std::vector<SharedDictionaryDef>& shared_dict_defs);
1021 
1022  private:
1023  std::unique_ptr<std::string> table_;
1024  std::list<std::unique_ptr<TableElement>> table_element_list_;
1027  std::list<std::unique_ptr<NameValueAssign>> storage_options_;
1028 };
1029 
1031  public:
1032  ~QueryConnector() = default;
1033  virtual size_t getOuterFragmentCount(QueryStateProxy,
1034  std::string& sql_query_string) = 0;
1035  virtual std::vector<AggregatedResult> query(QueryStateProxy,
1036  std::string& sql_query_string,
1037  std::vector<size_t> outer_frag_indices,
1038  bool allow_interrupt) = 0;
1039 };
1040 
1043  public:
1044  size_t getOuterFragmentCount(QueryStateProxy, std::string& sql_query_string) override;
1045 
1047  std::string& sql_query_string,
1048  std::vector<size_t> outer_frag_indices,
1049  bool validate_only,
1050  bool allow_interrupt);
1051  std::vector<AggregatedResult> query(QueryStateProxy,
1052  std::string& sql_query_string,
1053  std::vector<size_t> outer_frag_indices,
1054  bool allow_interrupt) override;
1055  std::list<ColumnDescriptor> getColumnDescriptors(AggregatedResult& result,
1056  bool for_create);
1057  size_t leafCount() override { return LocalInsertConnector::leafCount(); }
1059  const Catalog_Namespace::SessionInfo& parent_session_info,
1060  const size_t leaf_idx,
1061  const Fragmenter_Namespace::InsertChunks& insert_chunks) override {
1062  return LocalInsertConnector::insertChunksToLeaf(
1063  parent_session_info, leaf_idx, insert_chunks);
1064  }
1065  void insertDataToLeaf(const Catalog_Namespace::SessionInfo& parent_session_info,
1066  const size_t leaf_idx,
1067  Fragmenter_Namespace::InsertData& insert_data) override {
1068  return LocalInsertConnector::insertDataToLeaf(
1069  parent_session_info, leaf_idx, insert_data);
1070  }
1071  void checkpoint(const Catalog_Namespace::SessionInfo& parent_session_info,
1072  int tableId) override {
1073  return LocalInsertConnector::checkpoint(parent_session_info, tableId);
1074  }
1075  void rollback(const Catalog_Namespace::SessionInfo& parent_session_info,
1076  int tableId) override {
1077  return LocalInsertConnector::rollback(parent_session_info, tableId);
1078  }
1079 };
1080 
1081 /*
1082  * @type CreateDataframeStmt
1083  * @brief CREATE DATAFRAME statement
1084  */
1086  public:
1087  CreateDataframeStmt(std::string* tab,
1088  std::list<TableElement*>* table_elems,
1089  std::string* filename,
1090  std::list<NameValueAssign*>* s)
1091  : table_(tab), filename_(filename) {
1092  CHECK(table_elems);
1093  for (const auto e : *table_elems) {
1094  table_element_list_.emplace_back(e);
1095  }
1096  delete table_elems;
1097  if (s) {
1098  for (const auto e : *s) {
1099  storage_options_.emplace_back(e);
1100  }
1101  delete s;
1102  }
1103  }
1104  CreateDataframeStmt(const rapidjson::Value& payload);
1105 
1106  const std::string* get_table() const override { return table_.get(); }
1107  const std::list<std::unique_ptr<TableElement>>& get_table_element_list()
1108  const override {
1109  return table_element_list_;
1110  }
1111 
1112  void execute(const Catalog_Namespace::SessionInfo& session,
1113  bool read_only_mode) override;
1114 
1115  private:
1116  std::unique_ptr<std::string> table_;
1117  std::list<std::unique_ptr<TableElement>> table_element_list_;
1118  std::unique_ptr<std::string> filename_;
1119  std::list<std::unique_ptr<NameValueAssign>> storage_options_;
1120 };
1121 
1122 /*
1123  * @type InsertIntoTableAsSelectStmt
1124  * @brief INSERT INTO TABLE SELECT statement
1125  */
1127  public:
1128  // ITAS constructor
1129  InsertIntoTableAsSelectStmt(const rapidjson::Value& payload);
1130  InsertIntoTableAsSelectStmt(const std::string* table_name,
1131  const std::string* select_query,
1132  std::list<std::string*>* c)
1133  : table_name_(*table_name), select_query_(*select_query) {
1134  if (c) {
1135  for (auto e : *c) {
1136  column_list_.emplace_back(e);
1137  }
1138  delete c;
1139  }
1140 
1141  delete table_name;
1142  delete select_query;
1143  }
1144 
1146  const TableDescriptor* td,
1147  bool validate_table,
1148  bool for_CTAS = false);
1149  void execute(const Catalog_Namespace::SessionInfo& session,
1150  bool read_only_mode) override;
1151 
1152  std::string& get_table() { return table_name_; }
1153 
1154  std::string& get_select_query() { return select_query_; }
1155 
1156  std::unique_ptr<QueryConnector> leafs_connector_;
1157 
1158  protected:
1159  std::vector<std::unique_ptr<std::string>> column_list_;
1160  std::string table_name_;
1161  std::string select_query_;
1162 };
1163 
1164 /*
1165  * @type CreateTableAsSelectStmt
1166  * @brief CREATE TABLE AS SELECT statement
1167  */
1169  public:
1170  CreateTableAsSelectStmt(const rapidjson::Value& payload);
1171  CreateTableAsSelectStmt(const std::string* table_name,
1172  const std::string* select_query,
1173  const bool is_temporary,
1174  const bool if_not_exists,
1175  std::list<NameValueAssign*>* s)
1176  : InsertIntoTableAsSelectStmt(table_name, select_query, nullptr)
1177  , is_temporary_(is_temporary)
1178  , if_not_exists_(if_not_exists) {
1179  if (s) {
1180  for (const auto& e : *s) {
1181  storage_options_.emplace_back(e);
1182  }
1183  delete s;
1184  }
1185  }
1186 
1187  void execute(const Catalog_Namespace::SessionInfo& session,
1188  bool read_only_mode) override;
1189 
1190  private:
1193  std::list<std::unique_ptr<NameValueAssign>> storage_options_;
1194 };
1195 
1196 /*
1197  * @type AlterTableStmt
1198  * @brief ALTER TABLE statement
1199  *
1200  * AlterTableStmt is more a composite Stmt in that it relies upon several other Stmts to
1201  * handle the execution.
1202  */
1203 
1204 class AlterTableStmt : public DDLStmt {
1205  public:
1206  static std::unique_ptr<Parser::DDLStmt> delegate(const rapidjson::Value& payload);
1207 
1208  const std::string* get_table() const { return table_.get(); }
1209 
1210  void execute(const Catalog_Namespace::SessionInfo& session,
1211  bool read_only_mode) override;
1212 
1213  private:
1214  std::unique_ptr<std::string> table_;
1215  const rapidjson::Value payload_;
1216 };
1217 
1218 /*
1219  * @type DropTableStmt
1220  * @brief DROP TABLE statement
1221  */
1222 class DropTableStmt : public DDLStmt {
1223  public:
1224  DropTableStmt(std::string* tab, bool i) : table_(tab), if_exists_(i) {}
1225  DropTableStmt(const rapidjson::Value& payload);
1226 
1227  const std::string* get_table() const { return table_.get(); }
1228  void execute(const Catalog_Namespace::SessionInfo& session,
1229  bool read_only_mode) override;
1230 
1231  private:
1232  std::unique_ptr<std::string> table_;
1234 };
1235 
1236 /*
1237  * @type TruncateTableStmt
1238  * @brief TRUNCATE TABLE statement
1239  */
1240 class TruncateTableStmt : public DDLStmt {
1241  public:
1242  TruncateTableStmt(std::string* tab) : table_(tab) {}
1243  TruncateTableStmt(const rapidjson::Value& payload);
1244  const std::string* get_table() const { return table_.get(); }
1245  void execute(const Catalog_Namespace::SessionInfo& session,
1246  bool read_only_mode) override;
1247 
1248  private:
1249  std::unique_ptr<std::string> table_;
1250 };
1251 
1252 class OptimizeTableStmt : public DDLStmt {
1253  public:
1254  OptimizeTableStmt(std::string* table, std::list<NameValueAssign*>* o) : table_(table) {
1255  if (!table_) {
1256  throw std::runtime_error("Table name is required for OPTIMIZE command.");
1257  }
1258  if (o) {
1259  for (const auto e : *o) {
1260  options_.emplace_back(e);
1261  }
1262  delete o;
1263  }
1264  }
1265  OptimizeTableStmt(const rapidjson::Value& payload);
1266 
1267  const std::string getTableName() const { return *(table_.get()); }
1268 
1270  for (const auto& e : options_) {
1271  if (boost::iequals(*(e->get_name()), "VACUUM")) {
1272  return true;
1273  }
1274  }
1275  return false;
1276  }
1277 
1278  void execute(const Catalog_Namespace::SessionInfo& session,
1279  bool read_only_mode) override;
1280 
1281  private:
1282  std::unique_ptr<std::string> table_;
1283  std::list<std::unique_ptr<NameValueAssign>> options_;
1284 };
1285 
1286 class ValidateStmt : public DDLStmt {
1287  public:
1288  ValidateStmt(std::string* type, std::list<NameValueAssign*>* with_opts);
1289  ValidateStmt(const rapidjson::Value& payload);
1290 
1291  bool isRepairTypeRemove() const { return isRepairTypeRemove_; }
1292 
1293  const std::string getType() const { return *(type_.get()); }
1294 
1296  bool read_only_mode) override {
1297  UNREACHABLE();
1298  }
1299 
1300  private:
1301  std::unique_ptr<std::string> type_;
1302  bool isRepairTypeRemove_ = false;
1303 };
1304 
1305 class RenameDBStmt : public DDLStmt {
1306  public:
1307  RenameDBStmt(const rapidjson::Value& payload);
1308 
1309  RenameDBStmt(std::string* database_name, std::string* new_database_name)
1310  : database_name_(database_name), new_database_name_(new_database_name) {}
1311 
1312  auto const& getPreviousDatabaseName() { return database_name_; }
1313  auto const& getNewDatabaseName() { return new_database_name_; }
1314  void execute(const Catalog_Namespace::SessionInfo& session,
1315  bool read_only_mode) override;
1316 
1317  private:
1318  std::unique_ptr<std::string> database_name_;
1319  std::unique_ptr<std::string> new_database_name_;
1320 };
1321 
1322 class RenameUserStmt : public DDLStmt {
1323  public:
1324  RenameUserStmt(const rapidjson::Value& payload);
1325  RenameUserStmt(std::string* username, std::string* new_username)
1326  : username_(username), new_username_(new_username) {}
1327  auto const& getOldUserName() { return username_; }
1328  auto const& getNewUserName() { return new_username_; }
1329  void execute(const Catalog_Namespace::SessionInfo& session,
1330  bool read_only_mode) override;
1331 
1332  private:
1333  std::unique_ptr<std::string> username_;
1334  std::unique_ptr<std::string> new_username_;
1335 };
1336 
1337 class RenameTableStmt : public DDLStmt {
1338  public:
1339  using TableNamePair =
1340  std::pair<std::unique_ptr<std::string>, std::unique_ptr<std::string>>;
1341 
1342  // when created via ddl
1343  RenameTableStmt(const rapidjson::Value& payload);
1344 
1345  // to rename a single table
1346  RenameTableStmt(std::string* tab_name, std::string* new_tab_name);
1347 
1348  // to rename multiple tables
1349  RenameTableStmt(std::list<std::pair<std::string, std::string>> tableNames);
1350 
1351  void execute(const Catalog_Namespace::SessionInfo& session,
1352  bool read_only_mode) override;
1353 
1354  private:
1355  std::list<TableNamePair> tablesToRename_;
1356 };
1357 
1358 class RenameColumnStmt : public DDLStmt {
1359  public:
1360  RenameColumnStmt(std::string* tab, std::string* col, std::string* new_col_name)
1361  : table_(tab), column_(col), new_column_name_(new_col_name) {}
1362  void execute(const Catalog_Namespace::SessionInfo& session,
1363  bool read_only_mode) override;
1364 
1365  private:
1366  std::unique_ptr<std::string> table_;
1367  std::unique_ptr<std::string> column_;
1368  std::unique_ptr<std::string> new_column_name_;
1369 };
1370 
1371 class AddColumnStmt : public DDLStmt {
1372  public:
1373  AddColumnStmt(std::string* tab, ColumnDef* coldef) : table_(tab), coldef_(coldef) {}
1374  AddColumnStmt(std::string* tab, std::list<ColumnDef*>* coldefs) : table_(tab) {
1375  for (const auto coldef : *coldefs) {
1376  this->coldefs_.emplace_back(coldef);
1377  }
1378  delete coldefs;
1379  }
1380  void execute(const Catalog_Namespace::SessionInfo& session,
1381  bool read_only_mode) override;
1383  const TableDescriptor* td);
1384  const std::string* get_table() const { return table_.get(); }
1385 
1386  private:
1387  std::unique_ptr<std::string> table_;
1388  std::unique_ptr<ColumnDef> coldef_;
1389  std::list<std::unique_ptr<ColumnDef>> coldefs_;
1390 };
1391 
1392 class DropColumnStmt : public DDLStmt {
1393  public:
1394  DropColumnStmt(std::string* tab, std::list<std::string*>* cols) : table_(tab) {
1395  for (const auto col : *cols) {
1396  this->columns_.emplace_back(col);
1397  }
1398  delete cols;
1399  }
1400  void execute(const Catalog_Namespace::SessionInfo& session,
1401  bool read_only_mode) override;
1402  const std::string* get_table() const { return table_.get(); }
1403 
1404  private:
1405  std::unique_ptr<std::string> table_;
1406  std::list<std::unique_ptr<std::string>> columns_;
1407 };
1408 
1410  public:
1411  AlterTableParamStmt(std::string* tab, NameValueAssign* p) : table_(tab), param_(p) {}
1412  void execute(const Catalog_Namespace::SessionInfo& session,
1413  bool read_only_mode) override;
1414 
1415  private:
1416  std::unique_ptr<std::string> table_;
1417  std::unique_ptr<NameValueAssign> param_;
1418 };
1419 
1420 /*
1421  * @type DumpTableStmt
1422  * @brief DUMP TABLE table TO archive_file_path
1423  */
1425  public:
1426  DumpRestoreTableStmtBase(const rapidjson::Value& payload, const bool is_restore);
1427 
1428  enum class CompressionType { kGZIP, kLZ4, kNONE };
1429 
1430  // default compression type, based upon available executables
1431  CompressionType defaultCompression(bool is_restore);
1432 
1433  // validate inputted compression string, check for executable
1434  CompressionType validateCompression(const std::string& compression,
1435  const bool is_restore);
1436 
1437  // construct tar option string for compression setting
1438  std::string tarCompressionStr(CompressionType compression, const bool is_restore);
1439 
1440  const std::string* getTable() const { return table_.get(); }
1441  const std::string* getPath() const { return path_.get(); }
1442  const CompressionType getCompression() const { return compression_; }
1443 
1444  protected:
1445  std::unique_ptr<std::string> table_;
1446  std::unique_ptr<std::string> path_; // dump TO file path
1449 };
1450 
1452  public:
1453  DumpTableStmt(const rapidjson::Value& payload);
1454  void execute(const Catalog_Namespace::SessionInfo& session,
1455  bool read_only_mode) override;
1456 };
1457 
1458 /*
1459  * @type RestoreTableStmt
1460  * @brief RESTORE TABLE table FROM archive_file_path
1461  */
1463  public:
1464  RestoreTableStmt(const rapidjson::Value& payload);
1465  void execute(const Catalog_Namespace::SessionInfo& session,
1466  bool read_only_mode) override;
1467 };
1468 
1469 /*
1470  * @type CopyTableStmt
1471  * @brief COPY ... FROM ...
1472  */
1473 class CopyTableStmt : public DDLStmt {
1474  public:
1475  CopyTableStmt(std::string* t, std::string* f, std::list<NameValueAssign*>* o);
1476  CopyTableStmt(const rapidjson::Value& payload);
1477 
1478  void execute(const Catalog_Namespace::SessionInfo& session,
1479  bool read_only_mode) override;
1480  void execute(const Catalog_Namespace::SessionInfo& session,
1481  bool read_only_mode,
1482  const std::function<std::unique_ptr<import_export::AbstractImporter>(
1484  const TableDescriptor*,
1485  const std::string&,
1486  const import_export::CopyParams&)>& importer_factory);
1487  std::unique_ptr<std::string> return_message;
1488 
1489  std::string& get_table() const {
1490  CHECK(table_);
1491  return *table_;
1492  }
1493 
1494  bool get_success() const { return success_; }
1495 
1497 
1498  void get_deferred_copy_from_payload(std::string& table,
1499  std::string& file_name,
1500  import_export::CopyParams& copy_params,
1501  std::string& partitions) {
1502  table = *table_;
1503  file_name = deferred_copy_from_file_name_;
1504  copy_params = deferred_copy_from_copy_params_;
1505  partitions = deferred_copy_from_partitions_;
1506  was_deferred_copy_from_ = false;
1507  }
1508 
1509  private:
1510  std::unique_ptr<std::string> table_;
1511  std::unique_ptr<std::string> copy_from_source_pattern_;
1512  bool success_;
1513  std::list<std::unique_ptr<NameValueAssign>> options_;
1514 
1519 };
1520 
1521 /*
1522  * @type CreateRoleStmt
1523  * @brief CREATE ROLE statement
1524  */
1525 class CreateRoleStmt : public DDLStmt {
1526  public:
1527  CreateRoleStmt(std::string* r) : role_(r) {}
1528  CreateRoleStmt(const rapidjson::Value& payload);
1529  const std::string& get_role() const { return *role_; }
1530  void execute(const Catalog_Namespace::SessionInfo& session,
1531  bool read_only_mode) override;
1532 
1533  private:
1534  std::unique_ptr<std::string> role_;
1535 };
1536 
1537 /*
1538  * @type DropRoleStmt
1539  * @brief DROP ROLE statement
1540  */
1541 class DropRoleStmt : public DDLStmt {
1542  public:
1543  DropRoleStmt(std::string* r, bool e) : role_(r), if_exists_(e) {}
1544  DropRoleStmt(const rapidjson::Value& payload);
1545  const std::string& get_role() const { return *role_; }
1546  void execute(const Catalog_Namespace::SessionInfo& session,
1547  bool read_only_mode) override;
1548 
1549  private:
1550  std::unique_ptr<std::string> role_;
1552 };
1553 
1554 inline void parser_slistval_to_vector(std::list<std::string*>* l,
1555  std::vector<std::string>& v) {
1556  CHECK(l);
1557  for (auto str : *l) {
1558  v.push_back(*str);
1559  delete str;
1560  }
1561  delete l;
1562 }
1563 
1564 /*
1565  * @type GrantPrivilegesStmt
1566  * @brief GRANT PRIVILEGES statement
1567  */
1569  public:
1570  GrantPrivilegesStmt(std::list<std::string*>* p,
1571  std::string* t,
1572  std::string* o,
1573  std::list<std::string*>* g)
1574  : type_(t), target_(o) {
1577  }
1578  GrantPrivilegesStmt(const rapidjson::Value& payload);
1579 
1580  const std::vector<std::string>& get_privs() const { return privileges_; }
1581  const std::string& get_object_type() const { return *type_; }
1582  const std::string& get_object() const { return *target_; }
1583  const std::vector<std::string>& get_grantees() const { return grantees_; }
1584  void execute(const Catalog_Namespace::SessionInfo& session,
1585  bool read_only_mode) override;
1586 
1587  private:
1588  std::vector<std::string> privileges_;
1589  std::unique_ptr<std::string> type_;
1590  std::unique_ptr<std::string> target_;
1591  std::vector<std::string> grantees_;
1592 };
1593 
1594 /*
1595  * @type RevokePrivilegesStmt
1596  * @brief REVOKE PRIVILEGES statement
1597  */
1599  public:
1600  RevokePrivilegesStmt(std::list<std::string*>* p,
1601  std::string* t,
1602  std::string* o,
1603  std::list<std::string*>* g)
1604  : type_(t), target_(o) {
1607  }
1608  RevokePrivilegesStmt(const rapidjson::Value& payload);
1609 
1610  const std::vector<std::string>& get_privs() const { return privileges_; }
1611  const std::string& get_object_type() const { return *type_; }
1612  const std::string& get_object() const { return *target_; }
1613  const std::vector<std::string>& get_grantees() const { return grantees_; }
1614  void execute(const Catalog_Namespace::SessionInfo& session,
1615  bool read_only_mode) override;
1616 
1617  private:
1618  std::vector<std::string> privileges_;
1619  std::unique_ptr<std::string> type_;
1620  std::unique_ptr<std::string> target_;
1621  std::vector<std::string> grantees_;
1622 };
1623 
1624 /*
1625  * @type ShowPrivilegesStmt
1626  * @brief SHOW PRIVILEGES statement
1627  */
1628 class ShowPrivilegesStmt : public DDLStmt {
1629  public:
1630  ShowPrivilegesStmt(std::string* t, std::string* o, std::string* r)
1631  : object_type_(t), object_(o), role_(r) {}
1632  const std::string& get_object_type() const { return *object_type_; }
1633  const std::string& get_object() const { return *object_; }
1634  const std::string& get_role() const { return *role_; }
1635  void execute(const Catalog_Namespace::SessionInfo& session,
1636  bool read_only_mode) override;
1637 
1638  private:
1639  std::unique_ptr<std::string> object_type_;
1640  std::unique_ptr<std::string> object_;
1641  std::unique_ptr<std::string> role_;
1642 };
1643 
1644 /*
1645  * @type GrantRoleStmt
1646  * @brief GRANT ROLE statement
1647  */
1648 class GrantRoleStmt : public DDLStmt {
1649  public:
1650  GrantRoleStmt(std::list<std::string*>* r, std::list<std::string*>* g) {
1653  }
1654  GrantRoleStmt(const rapidjson::Value& payload);
1655 
1656  const std::vector<std::string>& get_roles() const { return roles_; }
1657  const std::vector<std::string>& get_grantees() const { return grantees_; }
1658  void execute(const Catalog_Namespace::SessionInfo& session,
1659  bool read_only_mode) override;
1660 
1661  private:
1662  std::vector<std::string> roles_;
1663  std::vector<std::string> grantees_;
1664 };
1665 
1666 /*
1667  * @type RevokeRoleStmt
1668  * @brief REVOKE ROLE statement
1669  */
1670 class RevokeRoleStmt : public DDLStmt {
1671  public:
1672  RevokeRoleStmt(std::list<std::string*>* r, std::list<std::string*>* g) {
1675  }
1676  RevokeRoleStmt(const rapidjson::Value& payload);
1677 
1678  const std::vector<std::string>& get_roles() const { return roles_; }
1679  const std::vector<std::string>& get_grantees() const { return grantees_; }
1680  void execute(const Catalog_Namespace::SessionInfo& session,
1681  bool read_only_mode) override;
1682 
1683  private:
1684  std::vector<std::string> roles_;
1685  std::vector<std::string> grantees_;
1686 };
1687 
1688 /*
1689  * @type QueryExpr
1690  * @brief query expression
1691  */
1692 class QueryExpr : public Node {
1693  public:
1694  virtual void analyze(const Catalog_Namespace::Catalog& catalog,
1695  Analyzer::Query& query) const = 0;
1696 };
1697 
1698 /*
1699  * @type UnionQuery
1700  * @brief UNION or UNION ALL queries
1701  */
1702 class UnionQuery : public QueryExpr {
1703  public:
1704  UnionQuery(bool u, QueryExpr* l, QueryExpr* r) : is_unionall_(u), left_(l), right_(r) {}
1705  bool get_is_unionall() const { return is_unionall_; }
1706  const QueryExpr* get_left() const { return left_.get(); }
1707  const QueryExpr* get_right() const { return right_.get(); }
1708  void analyze(const Catalog_Namespace::Catalog& catalog,
1709  Analyzer::Query& query) const override;
1710 
1711  private:
1713  std::unique_ptr<QueryExpr> left_;
1714  std::unique_ptr<QueryExpr> right_;
1715 };
1716 
1717 class SelectEntry : public Node {
1718  public:
1719  SelectEntry(Expr* e, std::string* r) : select_expr_(e), alias_(r) {}
1720  const Expr* get_select_expr() const { return select_expr_.get(); }
1721  const std::string* get_alias() const { return alias_.get(); }
1722  std::string to_string() const;
1723 
1724  private:
1725  std::unique_ptr<Expr> select_expr_;
1726  std::unique_ptr<std::string> alias_;
1727 };
1728 
1729 /*
1730  * @type QuerySpec
1731  * @brief a simple query
1732  */
1733 class QuerySpec : public QueryExpr {
1734  public:
1735  QuerySpec(bool d,
1736  std::list<SelectEntry*>* s,
1737  std::list<TableRef*>* f,
1738  Expr* w,
1739  std::list<Expr*>* g,
1740  Expr* h)
1742  if (s) {
1743  for (const auto e : *s) {
1744  select_clause_.emplace_back(e);
1745  }
1746  delete s;
1747  }
1748  CHECK(f);
1749  for (const auto e : *f) {
1750  from_clause_.emplace_back(e);
1751  }
1752  delete f;
1753  if (g) {
1754  for (const auto e : *g) {
1755  groupby_clause_.emplace_back(e);
1756  }
1757  delete g;
1758  }
1759  }
1760  bool get_is_distinct() const { return is_distinct_; }
1761  const std::list<std::unique_ptr<SelectEntry>>& get_select_clause() const {
1762  return select_clause_;
1763  }
1764  const std::list<std::unique_ptr<TableRef>>& get_from_clause() const {
1765  return from_clause_;
1766  }
1767  const Expr* get_where_clause() const { return where_clause_.get(); }
1768  const std::list<std::unique_ptr<Expr>>& get_groupby_clause() const {
1769  return groupby_clause_;
1770  }
1771  const Expr* get_having_clause() const { return having_clause_.get(); }
1772  void analyze(const Catalog_Namespace::Catalog& catalog,
1773  Analyzer::Query& query) const override;
1774  std::string to_string() const;
1775 
1776  private:
1778  std::list<std::unique_ptr<SelectEntry>> select_clause_; /* nullptr means SELECT * */
1779  std::list<std::unique_ptr<TableRef>> from_clause_;
1780  std::unique_ptr<Expr> where_clause_;
1781  std::list<std::unique_ptr<Expr>> groupby_clause_;
1782  std::unique_ptr<Expr> having_clause_;
1783  void analyze_from_clause(const Catalog_Namespace::Catalog& catalog,
1784  Analyzer::Query& query) const;
1786  Analyzer::Query& query) const;
1788  Analyzer::Query& query) const;
1789  void analyze_group_by(const Catalog_Namespace::Catalog& catalog,
1790  Analyzer::Query& query) const;
1792  Analyzer::Query& query) const;
1793 };
1794 
1795 /*
1796  * @type OrderSpec
1797  * @brief order spec for a column in ORDER BY clause
1798  */
1799 class OrderSpec : public Node {
1800  public:
1801  OrderSpec(int n, ColumnRef* c, bool d, bool f)
1802  : colno_(n), column_(c), is_desc_(d), nulls_first_(f) {}
1803  int get_colno() const { return colno_; }
1804  const ColumnRef* get_column() const { return column_.get(); }
1805  bool get_is_desc() const { return is_desc_; }
1806  bool get_nulls_first() const { return nulls_first_; }
1807 
1808  private:
1809  int colno_; /* 0 means use column name */
1810  std::unique_ptr<ColumnRef> column_;
1811  bool is_desc_;
1813 };
1814 
1815 /*
1816  * @type SelectStmt
1817  * @brief SELECT statement
1818  */
1819 class SelectStmt : public DMLStmt {
1820  public:
1821  SelectStmt(QueryExpr* q, std::list<OrderSpec*>* o, int64_t l, int64_t f)
1822  : query_expr_(q), limit_(l), offset_(f) {
1823  if (o) {
1824  for (const auto e : *o) {
1825  orderby_clause_.emplace_back(e);
1826  }
1827  delete o;
1828  }
1829  }
1830  const QueryExpr* get_query_expr() const { return query_expr_.get(); }
1831  const std::list<std::unique_ptr<OrderSpec>>& get_orderby_clause() const {
1832  return orderby_clause_;
1833  }
1834  void analyze(const Catalog_Namespace::Catalog& catalog,
1835  Analyzer::Query& query) const override;
1836 
1837  private:
1838  std::unique_ptr<QueryExpr> query_expr_;
1839  std::list<std::unique_ptr<OrderSpec>> orderby_clause_;
1840  int64_t limit_;
1841  int64_t offset_;
1842 };
1843 
1844 /*
1845  * @type ExportQueryStmt
1846  * @brief COPY ( query ) TO file ...
1847  */
1848 class ExportQueryStmt : public DDLStmt {
1849  public:
1850  ExportQueryStmt(std::string* q, std::string* p, std::list<NameValueAssign*>* o)
1851  : select_stmt_(q), file_path_(p) {
1852  if (o) {
1853  for (const auto e : *o) {
1854  options_.emplace_back(e);
1855  }
1856  delete o;
1857  }
1858  }
1859  ExportQueryStmt(const rapidjson::Value& payload);
1860  void execute(const Catalog_Namespace::SessionInfo& session,
1861  bool read_only_mode) override;
1862  const std::string get_select_stmt() const { return *select_stmt_; }
1863 
1864  std::unique_ptr<QueryConnector> leafs_connector_;
1865 
1866  private:
1867  std::unique_ptr<std::string> select_stmt_;
1868  std::unique_ptr<std::string> file_path_;
1869  std::list<std::unique_ptr<NameValueAssign>> options_;
1870 
1871  void parseOptions(import_export::CopyParams& copy_params,
1872  // @TODO(se) move rest to CopyParams when we have a Thrift endpoint
1874  std::string& layer_name,
1877 };
1878 
1879 /*
1880  * @type CreateViewStmt
1881  * @brief CREATE VIEW statement
1882  */
1883 class CreateViewStmt : public DDLStmt {
1884  public:
1885  CreateViewStmt(const std::string& view_name,
1886  const std::string& select_query,
1887  const bool if_not_exists)
1888  : view_name_(view_name)
1889  , select_query_(select_query)
1890  , if_not_exists_(if_not_exists) {}
1891 
1892  CreateViewStmt(const rapidjson::Value& payload);
1893 
1894  const std::string& get_view_name() const { return view_name_; }
1895  const std::string& get_select_query() const { return select_query_; }
1896  void execute(const Catalog_Namespace::SessionInfo& session,
1897  bool read_only_mode) override;
1898 
1899  private:
1900  std::string view_name_;
1901  std::string select_query_;
1903 };
1904 
1905 /*
1906  * @type DropViewStmt
1907  * @brief DROP VIEW statement
1908  */
1909 class DropViewStmt : public DDLStmt {
1910  public:
1911  DropViewStmt(std::string* v, bool i) : view_name_(v), if_exists_(i) {}
1912  DropViewStmt(const rapidjson::Value& payload);
1913 
1914  const std::string* get_view_name() const { return view_name_.get(); }
1915  void execute(const Catalog_Namespace::SessionInfo& session,
1916  bool read_only_mode) override;
1917 
1918  private:
1919  std::unique_ptr<std::string> view_name_;
1921 };
1922 
1923 /*
1924  * @type CreateDBStmt
1925  * @brief CREATE DATABASE statement
1926  */
1927 class CreateDBStmt : public DDLStmt {
1928  public:
1929  CreateDBStmt(const rapidjson::Value& payload);
1930 
1931  CreateDBStmt(std::string* n, std::list<NameValueAssign*>* l, const bool if_not_exists)
1932  : db_name_(n), if_not_exists_(if_not_exists) {
1933  if (l) {
1934  for (const auto e : *l) {
1935  options_.emplace_back(e);
1936  }
1937  delete l;
1938  }
1939  }
1940  void execute(const Catalog_Namespace::SessionInfo& session,
1941  bool read_only_mode) override;
1942 
1943  private:
1944  std::unique_ptr<std::string> db_name_;
1945  std::list<std::unique_ptr<NameValueAssign>> options_;
1947 };
1948 
1949 /*
1950  * @type DropDBStmt
1951  * @brief DROP DATABASE statement
1952  */
1953 class DropDBStmt : public DDLStmt {
1954  public:
1955  DropDBStmt(const rapidjson::Value& payload);
1956 
1957  explicit DropDBStmt(std::string* n, bool i) : db_name_(n), if_exists_(i) {}
1958  auto const& getDatabaseName() { return db_name_; }
1959  void execute(const Catalog_Namespace::SessionInfo& session,
1960  bool read_only_mode) override;
1961 
1962  private:
1963  std::unique_ptr<std::string> db_name_;
1965 };
1966 
1967 /*
1968  * @type CreateUserStmt
1969  * @brief CREATE USER statement
1970  */
1971 class CreateUserStmt : public DDLStmt {
1972  public:
1973  CreateUserStmt(const rapidjson::Value& payload);
1974  CreateUserStmt(std::string* n, std::list<NameValueAssign*>* l) : user_name_(n) {
1975  if (l) {
1976  for (const auto e : *l) {
1977  options_.emplace_back(e);
1978  }
1979  delete l;
1980  }
1981  }
1982  void execute(const Catalog_Namespace::SessionInfo& session,
1983  bool read_only_mode) override;
1984 
1985  private:
1986  std::unique_ptr<std::string> user_name_;
1987  std::list<std::unique_ptr<NameValueAssign>> options_;
1988 };
1989 
1990 /*
1991  * @type AlterUserStmt
1992  * @brief ALTER USER statement
1993  */
1994 class AlterUserStmt : public DDLStmt {
1995  public:
1996  AlterUserStmt(const rapidjson::Value& payload);
1997  AlterUserStmt(std::string* n, std::list<NameValueAssign*>* l) : user_name_(n) {
1998  if (l) {
1999  for (const auto e : *l) {
2000  options_.emplace_back(e);
2001  }
2002  delete l;
2003  }
2004  }
2005  void execute(const Catalog_Namespace::SessionInfo& session,
2006  bool read_only_mode) override;
2007 
2008  private:
2009  std::unique_ptr<std::string> user_name_;
2010  std::list<std::unique_ptr<NameValueAssign>> options_;
2011 };
2012 
2013 /*
2014  * @type DropUserStmt
2015  * @brief DROP USER statement
2016  */
2017 class DropUserStmt : public DDLStmt {
2018  public:
2019  DropUserStmt(const rapidjson::Value& payload);
2020  DropUserStmt(std::string* n, bool e) : user_name_(n), if_exists_(e) {}
2021  auto const& getUserName() { return user_name_; }
2022  void execute(const Catalog_Namespace::SessionInfo& session,
2023  bool read_only_mode) override;
2024 
2025  private:
2026  std::unique_ptr<std::string> user_name_;
2028 };
2029 
2030 /*
2031  * @type InsertStmt
2032  * @brief super class for INSERT statements
2033  */
2034 class InsertStmt : public DMLStmt {
2035  public:
2036  InsertStmt(std::string* t, std::list<std::string*>* c) : table_(t) {
2037  if (c) {
2038  for (const auto e : *c) {
2039  column_list_.emplace_back(e);
2040  }
2041  delete c;
2042  }
2043  }
2044  const std::string* get_table() const { return table_.get(); }
2045  const std::list<std::unique_ptr<std::string>>& get_column_list() const {
2046  return column_list_;
2047  }
2048  void analyze(const Catalog_Namespace::Catalog& catalog,
2049  Analyzer::Query& query) const override = 0;
2050 
2051  protected:
2052  std::unique_ptr<std::string> table_;
2053  std::list<std::unique_ptr<std::string>> column_list_;
2054 };
2055 
2056 class ValuesList : public Node {
2057  public:
2058  ValuesList() = default;
2059  ValuesList(std::list<Expr*>* values) {
2060  CHECK(values);
2061  for (const auto v : *values) {
2062  value_list.emplace_back(v);
2063  }
2064  delete values;
2065  }
2066 
2067  void push_back(Expr* value) { value_list.emplace_back(value); }
2068 
2069  const std::list<std::unique_ptr<Expr>>& get_value_list() const { return value_list; }
2070 
2071  private:
2072  std::list<std::unique_ptr<Expr>> value_list;
2073 };
2074 
2075 /*
2076  * @type InsertValuesStmt
2077  * @brief INSERT INTO ... VALUES ...
2078  */
2080  public:
2081  InsertValuesStmt(const rapidjson::Value& payload);
2082  InsertValuesStmt(std::string* t, std::list<std::string*>* c, std::list<Expr*>* v)
2083  : InsertStmt(t, c) {
2084  UNREACHABLE() << "Legacy inserts should not be called anymore";
2085  }
2086 
2087  const std::vector<std::unique_ptr<ValuesList>>& get_value_lists() const {
2088  return values_lists_;
2089  }
2090 
2091  void analyze(const Catalog_Namespace::Catalog& catalog,
2092  Analyzer::Query& query) const override;
2093 
2094  void execute(const Catalog_Namespace::SessionInfo& session, bool read_only_mode);
2095 
2096  std::unique_ptr<Fragmenter_Namespace::InsertDataLoader::InsertConnector>
2098 
2099  private:
2100  std::vector<std::unique_ptr<ValuesList>> values_lists_;
2101 };
2102 
2103 /*
2104  * @type Assignment
2105  * @brief assignment in UPDATE statement
2106  */
2107 class Assignment : public Node {
2108  public:
2109  Assignment(std::string* c, Expr* a) : column_(c), assignment_(a) {}
2110  const std::string* get_column() const { return column_.get(); }
2111  const Expr* get_assignment() const { return assignment_.get(); }
2112 
2113  private:
2114  std::unique_ptr<std::string> column_;
2115  std::unique_ptr<Expr> assignment_;
2116 };
2117 
2118 /*
2119  * @type UpdateStmt
2120  * @brief UPDATE statement
2121  */
2122 class UpdateStmt : public DMLStmt {
2123  public:
2124  UpdateStmt(std::string* t, std::list<Assignment*>* a, Expr* w)
2125  : table_(t), where_clause_(w) {
2126  CHECK(a);
2127  for (const auto e : *a) {
2128  assignment_list_.emplace_back(e);
2129  }
2130  delete a;
2131  }
2132  const std::string* get_table() const { return table_.get(); }
2133  const std::list<std::unique_ptr<Assignment>>& get_assignment_list() const {
2134  return assignment_list_;
2135  }
2136  const Expr* get_where_clause() const { return where_clause_.get(); }
2137  void analyze(const Catalog_Namespace::Catalog& catalog,
2138  Analyzer::Query& query) const override;
2139 
2140  private:
2141  std::unique_ptr<std::string> table_;
2142  std::list<std::unique_ptr<Assignment>> assignment_list_;
2143  std::unique_ptr<Expr> where_clause_;
2144 };
2145 
2146 /*
2147  * @type DeleteStmt
2148  * @brief DELETE statement
2149  */
2150 class DeleteStmt : public DMLStmt {
2151  public:
2152  DeleteStmt(std::string* t, Expr* w) : table_(t), where_clause_(w) {}
2153  const std::string* get_table() const { return table_.get(); }
2154  const Expr* get_where_clause() const { return where_clause_.get(); }
2155  void analyze(const Catalog_Namespace::Catalog& catalog,
2156  Analyzer::Query& query) const override;
2157 
2158  private:
2159  std::unique_ptr<std::string> table_;
2160  std::unique_ptr<Expr> where_clause_;
2161 };
2162 
2163 template <typename LITERAL_TYPE>
2165 
2166 template <>
2168  template <typename T>
2169  decltype(auto) operator()(T t) {
2170  const std::string property_name(boost::to_upper_copy<std::string>(*t->get_name()));
2171  if (!dynamic_cast<const IntLiteral*>(t->get_value())) {
2172  throw std::runtime_error(property_name + " must be an integer literal.");
2173  }
2174  const auto val = static_cast<const IntLiteral*>(t->get_value())->get_intval();
2175  if (val <= 0) {
2176  throw std::runtime_error(property_name + " must be a positive number.");
2177  }
2178  return val;
2179  }
2180 };
2181 
2183  template <typename T>
2184  decltype(auto) operator()(T t) {
2185  const std::string property_name(boost::to_upper_copy<std::string>(*t->get_name()));
2186  if (!dynamic_cast<const IntLiteral*>(t->get_value())) {
2187  throw std::runtime_error(property_name + " must be an integer literal.");
2188  }
2189  const auto val = static_cast<const IntLiteral*>(t->get_value())->get_intval();
2190  if (val < 0) {
2191  throw std::runtime_error(property_name + " must be greater than or equal to 0.");
2192  }
2193  return val;
2194  }
2195 };
2196 
2197 template <>
2199  template <typename T>
2200  decltype(auto) operator()(T t) {
2201  const auto val = static_cast<const StringLiteral*>(t->get_value())->get_stringval();
2202  CHECK(val);
2203  const auto val_upper = boost::to_upper_copy<std::string>(*val);
2204  return val_upper;
2205  }
2206 };
2207 
2209  template <typename T>
2210  decltype(auto) operator()(T t) {
2211  const auto val = static_cast<const StringLiteral*>(t->get_value())->get_stringval();
2212  CHECK(val);
2213  return *val;
2214  }
2215 };
2216 
2223 std::unique_ptr<Parser::Stmt> create_stmt_for_query(
2224  const std::string& queryStr,
2225  const Catalog_Namespace::SessionInfo& session_info);
2226 
2227 std::unique_ptr<Parser::Stmt> create_stmt_for_json(const std::string& query_json);
2228 
2230  const std::string& query_json,
2231  std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr,
2232  bool read_only_mode);
2233 
2234 } // namespace Parser
2235 
2236 #endif // PARSERNODE_H_
DEVICE auto upper_bound(ARGS &&...args)
Definition: gpu_enabled.h:123
std::unique_ptr< Expr > expr2_
Definition: ParserNode.h:692
virtual void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const =0
const ColumnConstraintDef * get_column_constraint() const
Definition: ParserNode.h:829
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
virtual void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const =0
Defines data structures for the semantic analysis phase of query processing.
OperExpr(SQLOps t, SQLQualifier q, Expr *l, Expr *r)
Definition: ParserNode.h:300
ExistsExpr(QuerySpec *q)
Definition: ParserNode.h:611
const std::string foreign_column_
Definition: ParserNode.h:939
std::string & get_table() const
Definition: ParserNode.h:1489
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:129
QuerySpec(bool d, std::list< SelectEntry * > *s, std::list< TableRef * > *f, Expr *w, std::list< Expr * > *g, Expr *h)
Definition: ParserNode.h:1735
ValidateStmt(std::string *type, std::list< NameValueAssign * > *with_opts)
std::unique_ptr< SubqueryExpr > subquery_
Definition: ParserNode.h:395
std::unique_ptr< std::string > username_
Definition: ParserNode.h:1333
static std::shared_ptr< Analyzer::Expr > normalize(const std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr >>> &, const std::shared_ptr< Analyzer::Expr >, const Executor *executor=nullptr)
std::vector< std::string > privileges_
Definition: ParserNode.h:1588
const Literal * get_value() const
Definition: ParserNode.h:964
LikelihoodExpr(bool n, Expr *a, float l)
Definition: ParserNode.h:586
CreateDBStmt(const rapidjson::Value &payload)
const std::string & get_column() const
Definition: ParserNode.h:950
const std::string * get_table() const
Definition: ParserNode.h:2153
const Expr * get_arg() const
Definition: ParserNode.h:588
std::unique_ptr< std::string > foreign_table_
Definition: ParserNode.h:805
IntLiteral(int64_t i)
Definition: ParserNode.h:154
bool get_is_desc() const
Definition: ParserNode.h:1805
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:500
std::unique_ptr< Expr > where_clause_
Definition: ParserNode.h:2160
RevokePrivilegesStmt(std::list< std::string * > *p, std::string *t, std::string *o, std::list< std::string * > *g)
Definition: ParserNode.h:1600
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
void get_deferred_copy_from_payload(std::string &table, std::string &file_name, import_export::CopyParams &copy_params, std::string &partitions)
Definition: ParserNode.h:1498
GrantPrivilegesStmt(std::list< std::string * > *p, std::string *t, std::string *o, std::list< std::string * > *g)
Definition: ParserNode.h:1570
std::unique_ptr< Expr > right_
Definition: ParserNode.h:321
ExportQueryStmt(std::string *q, std::string *p, std::list< NameValueAssign * > *o)
Definition: ParserNode.h:1850
ValuesList()=default
std::unique_ptr< QueryConnector > leafs_connector_
Definition: ParserNode.h:1864
const std::string * get_table() const
Definition: ParserNode.h:1208
std::unique_ptr< std::string > stringval_
Definition: ParserNode.h:145
std::string to_string() const override
std::unique_ptr< std::string > new_database_name_
Definition: ParserNode.h:1319
std::unique_ptr< std::string > view_name_
Definition: ParserNode.h:1919
SQLType * get_column_type() const
Definition: ParserNode.h:827
float get_likelihood() const
Definition: ParserNode.h:589
const std::string * get_table() const override
Definition: ParserNode.h:1009
std::list< std::unique_ptr< NameValueAssign > > storage_options_
Definition: ParserNode.h:1119
void setColumnDescriptor(ColumnDescriptor &cd, const ColumnDef *coldef)
const std::string * get_table() const
Definition: ParserNode.h:2044
std::unique_ptr< std::string > db_name_
Definition: ParserNode.h:1963
class for a per-database catalog. also includes metadata for the current database and the current use...
Definition: Catalog.h:132
std::unique_ptr< Expr > assignment_
Definition: ParserNode.h:2115
std::unique_ptr< std::string > target_
Definition: ParserNode.h:1590
const std::string * get_table() const
Definition: ParserNode.h:631
const std::string * get_column() const
Definition: ParserNode.h:2110
std::unique_ptr< std::string > user_name_
Definition: ParserNode.h:2009
SQLTypes
Definition: sqltypes.h:55
std::unique_ptr< Expr > check_condition_
Definition: ParserNode.h:915
void executeDryRun(const Catalog_Namespace::SessionInfo &session, TableDescriptor &td, std::list< ColumnDescriptor > &columns, std::vector< SharedDictionaryDef > &shared_dict_defs)
std::unique_ptr< Expr > having_clause_
Definition: ParserNode.h:1782
const Expr * get_arg() const
Definition: ParserNode.h:431
SqlType(SQLTypes type, int param1, int param2, bool is_array, int array_size)
Definition: DdlUtils.cpp:38
void parseOptions(import_export::CopyParams &copy_params, import_export::QueryExporter::FileType &file_type, std::string &layer_name, import_export::QueryExporter::FileCompression &file_compression, import_export::QueryExporter::ArrayNullHandling &array_null_handling)
std::unique_ptr< std::string > copy_from_source_pattern_
Definition: ParserNode.h:1511
CreateTableStmt(std::string *tab, const std::string *storage, std::list< TableElement * > *table_elems, bool is_temporary, bool if_not_exists, std::list< NameValueAssign * > *s)
Definition: ParserNode.h:987
RenameUserStmt(const rapidjson::Value &payload)
std::unique_ptr< Expr > select_expr_
Definition: ParserNode.h:1725
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::list< std::unique_ptr< Expr > > groupby_clause_
Definition: ParserNode.h:1781
virtual const std::list< std::unique_ptr< TableElement > > & get_table_element_list() const =0
const std::list< std::unique_ptr< TableElement > > & get_table_element_list() const override
Definition: ParserNode.h:1107
std::list< std::unique_ptr< TableElement > > table_element_list_
Definition: ParserNode.h:1024
CastExpr(Expr *a, SQLType *t)
Definition: ParserNode.h:670
float get_floatval() const
Definition: ParserNode.h:197
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:2010
DropViewStmt(std::string *v, bool i)
Definition: ParserNode.h:1911
size_t getOuterFragmentCount(QueryStateProxy, std::string &sql_query_string) override
std::unique_ptr< std::string > table_
Definition: ParserNode.h:640
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:357
std::unique_ptr< Expr > lower_
Definition: ParserNode.h:443
FixedPtLiteral(std::string *n)
Definition: ParserNode.h:175
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:601
SQLType(SQLTypes t, int p1)
Definition: ParserNode.h:74
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1282
const std::string getType() const
Definition: ParserNode.h:1293
std::unique_ptr< std::string > fixedptval_
Definition: ParserNode.h:187
SQLQualifier
Definition: sqldefs.h:71
const std::string & get_role() const
Definition: ParserNode.h:1545
static std::shared_ptr< Analyzer::Expr > analyzeValue(const int64_t intval)
Definition: ParserNode.cpp:162
const Expr * get_pattern_string() const
Definition: ParserNode.h:532
const std::string column_
Definition: ParserNode.h:937
std::string to_string() const
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1249
std::unique_ptr< std::string > return_message
Definition: ParserNode.h:1487
RenameDBStmt(const rapidjson::Value &payload)
StringLiteral(std::string *s)
Definition: ParserNode.h:134
const Expr * get_select_expr() const
Definition: ParserNode.h:1720
DoubleLiteral(double d)
Definition: ParserNode.h:216
std::list< std::unique_ptr< Expr > > value_list_
Definition: ParserNode.h:419
SQLOps
Definition: sqldefs.h:28
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
const std::string getTableName() const
Definition: ParserNode.h:1267
DropUserStmt(std::string *n, bool e)
Definition: ParserNode.h:2020
std::vector< std::string > grantees_
Definition: ParserNode.h:1685
InsertStmt(std::string *t, std::list< std::string * > *c)
Definition: ParserNode.h:2036
std::string to_string() const override
void populateData(QueryStateProxy, const TableDescriptor *td, bool validate_table, bool for_CTAS=false)
std::string to_string() const override
Definition: ParserNode.h:675
std::string to_string() const override
std::unique_ptr< Expr > left_
Definition: ParserNode.h:320
InsertValuesStmt(std::string *t, std::list< std::string * > *c, std::list< Expr * > *v)
Definition: ParserNode.h:2082
std::unique_ptr< Expr > target_value_
Definition: ParserNode.h:574
const Expr * get_check_condition() const
Definition: ParserNode.h:795
UpdateStmt(std::string *t, std::list< Assignment * > *a, Expr *w)
Definition: ParserNode.h:2124
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:243
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
static std::shared_ptr< Analyzer::Expr > normalize(const SQLOps optype, const SQLQualifier qual, std::shared_ptr< Analyzer::Expr > left_expr, std::shared_ptr< Analyzer::Expr > right_expr, const Executor *executor=nullptr)
Definition: ParserNode.cpp:372
const Expr * get_target_value() const
Definition: ParserNode.h:558
std::unique_ptr< Expr > upper_bound_
Definition: ParserNode.h:576
const std::string * get_table() const
Definition: ParserNode.h:1227
std::string to_string() const override
Definition: ParserNode.h:184
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:1987
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:680
bool get_is_not() const
Definition: ParserNode.h:495
#define UNREACHABLE()
Definition: Logger.h:337
const std::list< std::unique_ptr< OrderSpec > > & get_orderby_clause() const
Definition: ParserNode.h:1831
AddColumnStmt(std::string *tab, std::list< ColumnDef * > *coldefs)
Definition: ParserNode.h:1374
std::unique_ptr< std::string > table_
Definition: ParserNode.h:2159
std::string to_string() const override=0
std::unique_ptr< std::string > column_name_
Definition: ParserNode.h:834
const std::list< std::unique_ptr< std::string > > & get_foreign_column_list() const
Definition: ParserNode.h:895
std::unique_ptr< std::string > new_username_
Definition: ParserNode.h:1334
DropColumnStmt(std::string *tab, std::list< std::string * > *cols)
Definition: ParserNode.h:1394
std::unique_ptr< std::string > file_path_
Definition: ParserNode.h:1868
const std::string & get_foreign_table() const
Definition: ParserNode.h:932
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:216
std::string tarCompressionStr(CompressionType compression, const bool is_restore)
SQLOps get_optype() const
Definition: ParserNode.h:302
Expr * get_arg() const
Definition: ParserNode.h:655
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:229
std::string deferred_copy_from_partitions_
Definition: ParserNode.h:1518
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override=0
std::string to_string() const override
void parser_slistval_to_vector(std::list< std::string * > *l, std::vector< std::string > &v)
Definition: ParserNode.h:1554
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
Definition: ParserNode.h:1295
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:207
OptimizeTableStmt(std::string *table, std::list< NameValueAssign * > *o)
Definition: ParserNode.h:1254
const Literal * get_defaultval() const
Definition: ParserNode.h:794
std::unique_ptr< std::string > column_
Definition: ParserNode.h:1367
std::string to_string() const
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override=0
const Expr * get_arg() const
Definition: ParserNode.h:531
std::unique_ptr< QuerySpec > query_
Definition: ParserNode.h:620
Constants for Builtin SQL Types supported by HEAVY.AI.
CaseExpr(std::list< ExprPair * > *w, Expr *e)
Definition: ParserNode.h:697
ShardKeyDef(const std::string &column)
Definition: ParserNode.h:948
CreateDBStmt(std::string *n, std::list< NameValueAssign * > *l, const bool if_not_exists)
Definition: ParserNode.h:1931
std::unique_ptr< std::string > user_name_
Definition: ParserNode.h:1986
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1116
static void check_pattern_expr(const std::string &pattern_str, char escape_char)
Definition: ParserNode.cpp:741
std::unique_ptr< SQLType > column_type_
Definition: ParserNode.h:835
std::list< std::unique_ptr< Assignment > > assignment_list_
Definition: ParserNode.h:2142
const Expr * get_where_clause() const
Definition: ParserNode.h:2136
const std::vector< std::string > & get_roles() const
Definition: ParserNode.h:1656
std::string to_string() const override
void rollback(const Catalog_Namespace::SessionInfo &parent_session_info, int tableId) override
Definition: ParserNode.h:1075
bool get_is_unionall() const
Definition: ParserNode.h:1705
std::unique_ptr< std::string > table_
Definition: ParserNode.h:2141
SQLType(SQLTypes t, int p1, int p2, bool a)
Definition: ParserNode.h:75
AlterTableParamStmt(std::string *tab, NameValueAssign *p)
Definition: ParserNode.h:1411
const std::string & get_column() const
Definition: ParserNode.h:930
TableRef(std::string *t, std::string *r)
Definition: ParserNode.h:727
std::unique_ptr< SQLType > target_type_
Definition: ParserNode.h:681
const std::string * get_table() const
Definition: ParserNode.h:2132
const Expr * get_arg() const
Definition: ParserNode.h:476
AggregatedResult query(QueryStateProxy, std::string &sql_query_string, std::vector< size_t > outer_frag_indices, bool validate_only, bool allow_interrupt)
DropDBStmt(std::string *n, bool i)
Definition: ParserNode.h:1957
const Expr * get_arg() const
Definition: ParserNode.h:496
SQLType(SQLTypes t, bool a, int array_size)
Definition: ParserNode.h:78
std::unique_ptr< Expr > else_expr_
Definition: ParserNode.h:717
std::list< std::unique_ptr< Expr > > value_list_
Definition: ParserNode.h:289
static bool translate_to_like_pattern(std::string &pattern_str, char escape_char)
Definition: ParserNode.cpp:747
const std::list< std::unique_ptr< Expr > > & get_value_list() const
Definition: ParserNode.h:411
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1214
ColumnConstraintDef(bool n, bool u, bool p, Literal *d)
Definition: ParserNode.h:781
bool get_is_not() const
Definition: ParserNode.h:367
ColumnRef(std::string *n1, std::string *n2)
Definition: ParserNode.h:630
SelectStmt(QueryExpr *q, std::list< OrderSpec * > *o, int64_t l, int64_t f)
Definition: ParserNode.h:1821
constexpr double f
Definition: Utm.h:31
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
SQLType(SQLTypes t)
Definition: ParserNode.h:73
bool was_deferred_copy_from() const
Definition: ParserNode.h:1496
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1416
TableArchiverS3Options s3_options_
Definition: ParserNode.h:1448
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:513
std::unique_ptr< std::string > table_
Definition: ParserNode.h:2052
std::unique_ptr< std::string > name_
Definition: ParserNode.h:663
const std::string & get_object_type() const
Definition: ParserNode.h:1581
CompressionType defaultCompression(bool is_restore)
const Expr * get_escape_string() const
Definition: ParserNode.h:498
std::unique_ptr< CompressDef > compression_
Definition: ParserNode.h:836
const Expr * get_lower_bound() const
Definition: ParserNode.h:559
IsNullExpr(bool n, Expr *a)
Definition: ParserNode.h:347
const std::string & get_object() const
Definition: ParserNode.h:1633
auto const & getPreviousDatabaseName()
Definition: ParserNode.h:1312
std::unique_ptr< Expr > escape_string_
Definition: ParserNode.h:515
constexpr double a
Definition: Utm.h:32
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode)
void analyze_having_clause(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::unique_ptr< std::string > database_name_
Definition: ParserNode.h:1318
std::string to_string() const override
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const Expr * get_like_string() const
Definition: ParserNode.h:497
const std::string get_select_stmt() const
Definition: ParserNode.h:1862
const std::vector< std::string > & get_grantees() const
Definition: ParserNode.h:1613
std::unique_ptr< Expr > expr1_
Definition: ParserNode.h:691
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const Expr * get_arg() const
Definition: ParserNode.h:368
std::list< std::unique_ptr< std::string > > columns_
Definition: ParserNode.h:1406
std::string to_string() const override
Definition: ParserNode.h:142
This file contains the class specification and related data structures for Catalog.
std::vector< std::string > roles_
Definition: ParserNode.h:1684
const std::string & get_role() const
Definition: ParserNode.h:1634
bool get_calc_encoded_length() const
Definition: ParserNode.h:456
DumpTableStmt(const rapidjson::Value &payload)
const SubqueryExpr * get_subquery() const
Definition: ParserNode.h:387
const std::list< std::unique_ptr< SelectEntry > > & get_select_clause() const
Definition: ParserNode.h:1761
const std::string * getPath() const
Definition: ParserNode.h:1441
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1387
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:136
std::string to_string() const override
Definition: ParserNode.h:264
const std::string * getTable() const
Definition: ParserNode.h:1440
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
InSubquery(bool n, Expr *a, SubqueryExpr *q)
Definition: ParserNode.h:386
CreateRoleStmt(std::string *r)
Definition: ParserNode.h:1527
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::string * get_table_name() const
Definition: ParserNode.h:728
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
bool get_success() const
Definition: ParserNode.h:1494
const ColumnRef * get_column() const
Definition: ParserNode.h:1804
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:1945
const Expr * get_right() const
Definition: ParserNode.h:304
const std::string * get_stringval() const
Definition: ParserNode.h:135
std::unique_ptr< std::string > select_stmt_
Definition: ParserNode.h:1867
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:882
std::unique_ptr< QueryConnector > leafs_connector_
Definition: ParserNode.h:1156
CONSTEXPR DEVICE bool is_null(const T &value)
Definition: ParserNode.h:1717
std::string to_string() const override
Definition: ParserNode.h:242
ExprPair(Expr *e1, Expr *e2)
Definition: ParserNode.h:686
const std::string * get_fixedptval() const
Definition: ParserNode.h:176
std::vector< std::string > roles_
Definition: ParserNode.h:1662
const std::string & get_role() const
Definition: ParserNode.h:1529
std::vector< std::string > grantees_
Definition: ParserNode.h:1591
std::list< std::unique_ptr< NameValueAssign > > storage_options_
Definition: ParserNode.h:1193
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
bool get_is_not() const
Definition: ParserNode.h:530
ForeignKeyDef(std::list< std::string * > *cl, std::string *t, std::list< std::string * > *fcl)
Definition: ParserNode.h:877
const std::vector< std::string > & get_grantees() const
Definition: ParserNode.h:1679
std::list< std::unique_ptr< ColumnDef > > coldefs_
Definition: ParserNode.h:1389
std::unique_ptr< std::string > type_
Definition: ParserNode.h:1301
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:155
std::unique_ptr< Parser::Stmt > create_stmt_for_json(const std::string &query_json)
std::list< TableNamePair > tablesToRename_
Definition: ParserNode.h:1355
const std::list< std::unique_ptr< std::string > > & get_column_list() const
Definition: ParserNode.h:2045
const std::list< std::unique_ptr< Expr > > & get_value_list() const
Definition: ParserNode.h:281
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
void checkpoint(const Catalog_Namespace::SessionInfo &parent_session_info, int tableId) override
Definition: ParserNode.h:1071
SharedDictionaryDef(const std::string &column, const std::string &foreign_table, const std::string foreign_column)
Definition: ParserNode.h:925
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const Expr * get_upper_bound() const
Definition: ParserNode.h:560
std::unique_ptr< std::string > role_
Definition: ParserNode.h:1534
const Expr * get_check_condition() const
Definition: ParserNode.h:912
RestoreTableStmt(const rapidjson::Value &payload)
const QueryExpr * get_left() const
Definition: ParserNode.h:1706
virtual const std::string * get_table() const =0
const std::string & get_foreign_column() const
Definition: ParserNode.h:934
std::unique_ptr< std::string > type_
Definition: ParserNode.h:1619
void analyze_where_clause(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::string * get_table() const
Definition: ParserNode.h:1244
auto const & getUserName()
Definition: ParserNode.h:2021
int64_t get_intval() const
Definition: ParserNode.h:155
const Expr * get_upper() const
Definition: ParserNode.h:433
std::unique_ptr< ColumnRef > column_
Definition: ParserNode.h:1810
std::string deferred_copy_from_file_name_
Definition: ParserNode.h:1516
const std::list< std::unique_ptr< std::string > > & get_column_list() const
Definition: ParserNode.h:862
const Expr * get_where_clause() const
Definition: ParserNode.h:2154
const std::list< std::unique_ptr< Expr > > & get_value_list() const
Definition: ParserNode.h:2069
ColumnDef(std::string *c, SQLType *t, CompressDef *cp, ColumnConstraintDef *cc)
Definition: ParserNode.h:824
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::string select_query_
Definition: ParserNode.h:1901
RevokeRoleStmt(std::list< std::string * > *r, std::list< std::string * > *g)
Definition: ParserNode.h:1672
std::unique_ptr< ColumnConstraintDef > column_constraint_
Definition: ParserNode.h:837
const std::string * get_column_name() const
Definition: ParserNode.h:826
const std::string & get_select_query() const
Definition: ParserNode.h:1895
DropRoleStmt(std::string *r, bool e)
Definition: ParserNode.h:1543
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const Expr * get_having_clause() const
Definition: ParserNode.h:1771
std::string to_string() const override
FunctionRef(std::string *n, Expr *a)
Definition: ParserNode.h:651
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:665
std::unique_ptr< NameValueAssign > param_
Definition: ParserNode.h:1417
RenameTableStmt(const rapidjson::Value &payload)
CreateTableAsSelectStmt(const std::string *table_name, const std::string *select_query, const bool is_temporary, const bool if_not_exists, std::list< NameValueAssign * > *s)
Definition: ParserNode.h:1171
specifies the content in-memory of a row in the column metadata table
const Expr * get_where_clause() const
Definition: ParserNode.h:1767
const std::string * get_alias() const
Definition: ParserNode.h:1721
CheckDef(Expr *c)
Definition: ParserNode.h:911
std::unique_ptr< std::string > object_
Definition: ParserNode.h:1640
BetweenExpr(bool n, Expr *a, Expr *l, Expr *u)
Definition: ParserNode.h:428
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1232
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:1283
std::string to_string() const override
Definition: ParserNode.h:202
const std::vector< std::string > & get_roles() const
Definition: ParserNode.h:1678
const std::string foreign_table_
Definition: ParserNode.h:938
std::unique_ptr< Fragmenter_Namespace::InsertDataLoader::InsertConnector > leafs_connector_
Definition: ParserNode.h:2097
std::list< std::unique_ptr< TableRef > > from_clause_
Definition: ParserNode.h:1779
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1445
std::unique_ptr< std::string > new_column_name_
Definition: ParserNode.h:1368
std::unique_ptr< Expr > pattern_string_
Definition: ParserNode.h:547
static void erase_cntl_chars(std::string &like_str, char escape_char)
Definition: ParserNode.cpp:664
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::unique_ptr< Expr > where_clause_
Definition: ParserNode.h:1780
std::vector< std::string > grantees_
Definition: ParserNode.h:1621
std::unique_ptr< std::string > path_
Definition: ParserNode.h:1446
const std::string * get_name() const
Definition: ParserNode.h:653
std::string to_string() const
AddColumnStmt(std::string *tab, ColumnDef *coldef)
Definition: ParserNode.h:1373
bool get_is_primarykey() const
Definition: ParserNode.h:861
std::unique_ptr< QueryExpr > left_
Definition: ParserNode.h:1713
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1510
std::unique_ptr< std::string > name_
Definition: ParserNode.h:967
std::unique_ptr< Literal > value_
Definition: ParserNode.h:968
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:546
std::unique_ptr< std::string > user_name_
Definition: ParserNode.h:2026
void check_executable(const Catalog_Namespace::SessionInfo &session, const TableDescriptor *td)
DropUserStmt(const rapidjson::Value &payload)
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
int get_colno() const
Definition: ParserNode.h:1803
SQLType(SQLTypes t, int p1, int p2, bool a, int array_size)
Definition: ParserNode.h:76
std::unique_ptr< std::string > role_
Definition: ParserNode.h:1550
std::string to_string() const override
TruncateTableStmt(std::string *tab)
Definition: ParserNode.h:1242
std::unique_ptr< std::string > table_name_
Definition: ParserNode.h:733
GrantRoleStmt(std::list< std::string * > *r, std::list< std::string * > *g)
Definition: ParserNode.h:1650
const std::list< std::unique_ptr< Expr > > & get_groupby_clause() const
Definition: ParserNode.h:1768
UnionQuery(bool u, QueryExpr *l, QueryExpr *r)
Definition: ParserNode.h:1704
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
const std::string * get_name() const
Definition: ParserNode.h:963
virtual ~Node()
Definition: ParserNode.h:64
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:874
const std::string * get_range_var() const
Definition: ParserNode.h:729
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:287
bool get_distinct() const
Definition: ParserNode.h:654
std::unique_ptr< Expr > partition_count_
Definition: ParserNode.h:577
Definition: sqldefs.h:71
static std::shared_ptr< Analyzer::Expr > analyzeValue(const std::string &stringval, const bool is_null)
Definition: ParserNode.cpp:143
DEVICE auto lower_bound(ARGS &&...args)
Definition: gpu_enabled.h:78
void insertDataToLeaf(const Catalog_Namespace::SessionInfo &parent_session_info, const size_t leaf_idx, Fragmenter_Namespace::InsertData &insert_data) override
Definition: ParserNode.h:1065
std::pair< std::unique_ptr< std::string >, std::unique_ptr< std::string >> TableNamePair
Definition: ParserNode.h:1340
std::string to_string() const override
const std::vector< std::string > & get_grantees() const
Definition: ParserNode.h:1583
const CompressDef * get_compression() const
Definition: ParserNode.h:828
const std::list< std::unique_ptr< TableElement > > & get_table_element_list() const override
Definition: ParserNode.h:1010
CreateUserStmt(std::string *n, std::list< NameValueAssign * > *l)
Definition: ParserNode.h:1974
std::string to_string() const override
Definition: ParserNode.cpp:272
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:1869
const Expr * get_lower() const
Definition: ParserNode.h:432
bool get_is_not() const
Definition: ParserNode.h:430
ArrayLiteral(std::list< Expr * > *v)
Definition: ParserNode.h:274
InExpr(bool n, Expr *a)
Definition: ParserNode.h:366
const std::list< std::unique_ptr< std::string > > & get_column_list() const
Definition: ParserNode.h:891
void execute_stmt_for_json(const std::string &query_json, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr, bool read_only_mode)
import_export::CopyParams deferred_copy_from_copy_params_
Definition: ParserNode.h:1517
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
bool isRepairTypeRemove() const
Definition: ParserNode.h:1291
DropTableStmt(std::string *tab, bool i)
Definition: ParserNode.h:1224
std::unique_ptr< Expr > where_clause_
Definition: ParserNode.h:2143
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override=0
std::vector< std::string > grantees_
Definition: ParserNode.h:1663
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::unique_ptr< QuerySpec > query_
Definition: ParserNode.h:342
CompressDef(std::string *n, int p)
Definition: ParserNode.h:815
InsertIntoTableAsSelectStmt(const rapidjson::Value &payload)
Encoding(std::string *encoding_name, int encoding_param)
Definition: DdlUtils.cpp:205
std::unique_ptr< Expr > like_string_
Definition: ParserNode.h:514
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::list< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:2053
SQLQualifier opqualifier_
Definition: ParserNode.h:319
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:778
InsertIntoTableAsSelectStmt(const std::string *table_name, const std::string *select_query, std::list< std::string * > *c)
Definition: ParserNode.h:1130
InValues(bool n, Expr *a, std::list< Expr * > *v)
Definition: ParserNode.h:404
const std::string * get_foreign_table() const
Definition: ParserNode.h:894
std::string to_string() const override
Definition: ParserNode.h:161
NameValueAssign(std::string *n, Literal *v)
Definition: ParserNode.h:962
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:959
std::list< std::unique_ptr< NameValueAssign > > storage_options_
Definition: ParserNode.h:1027
const std::string column_
Definition: ParserNode.h:953
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
CharLengthExpr(Expr *a, bool e)
Definition: ParserNode.h:454
std::string to_string() const override
static std::shared_ptr< Analyzer::Expr > analyzeValue(const int64_t numericval, const int scale, const int precision)
Definition: ParserNode.cpp:187
auto const & getNewUserName()
Definition: ParserNode.h:1328
std::unique_ptr< Expr > check_condition_
Definition: ParserNode.h:804
std::unique_ptr< QueryExpr > right_
Definition: ParserNode.h:1714
std::string to_string() const override
std::unique_ptr< std::string > foreign_column_
Definition: ParserNode.h:806
void analyze_select_clause(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
static bool test_is_simple_expr(const std::string &like_str, char escape_char)
Definition: ParserNode.cpp:643
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::vector< std::unique_ptr< ValuesList > > & get_value_lists() const
Definition: ParserNode.h:2087
CreateViewStmt(const std::string &view_name, const std::string &select_query, const bool if_not_exists)
Definition: ParserNode.h:1885
void push_back(Expr *value)
Definition: ParserNode.h:2067
const std::string * get_foreign_table() const
Definition: ParserNode.h:796
virtual std::string to_string() const =0
virtual size_t getOuterFragmentCount(QueryStateProxy, std::string &sql_query_string)=0
const Expr * get_partition_count() const
Definition: ParserNode.h:561
void analyze_from_clause(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
bool get_nulls_first() const
Definition: ParserNode.h:1806
std::unique_ptr< std::string > type_
Definition: ParserNode.h:1589
std::list< std::unique_ptr< SelectEntry > > select_clause_
Definition: ParserNode.h:1778
DumpRestoreTableStmtBase(const rapidjson::Value &payload, const bool is_restore)
std::vector< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:1159
bool shouldVacuumDeletedRows() const
Definition: ParserNode.h:1269
TableRef(std::string *t)
Definition: ParserNode.h:726
std::unique_ptr< std::string > alias_
Definition: ParserNode.h:1726
bool get_is_not() const
Definition: ParserNode.h:348
InsertValuesStmt(const rapidjson::Value &payload)
virtual std::vector< AggregatedResult > query(QueryStateProxy, std::string &sql_query_string, std::vector< size_t > outer_frag_indices, bool allow_interrupt)=0
std::unique_ptr< std::string > db_name_
Definition: ParserNode.h:1944
std::unique_ptr< Expr > escape_string_
Definition: ParserNode.h:548
RenameUserStmt(std::string *username, std::string *new_username)
Definition: ParserNode.h:1325
std::string to_string() const override
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:833
std::string to_string() const override
bool get_is_primarykey() const
Definition: ParserNode.h:793
virtual std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const =0
bool g_enable_watchdog false
Definition: Execute.cpp:79
std::unique_ptr< std::string > target_
Definition: ParserNode.h:1620
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:520
std::unique_ptr< std::string > column_
Definition: ParserNode.h:2114
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
#define CHECK(condition)
Definition: Logger.h:291
Assignment(std::string *c, Expr *a)
Definition: ParserNode.h:2109
std::list< std::unique_ptr< std::string > > foreign_column_list_
Definition: ParserNode.h:902
std::unique_ptr< Expr > upper_
Definition: ParserNode.h:444
std::unique_ptr< std::string > range_var_
Definition: ParserNode.h:734
CreateDataframeStmt(std::string *tab, std::list< TableElement * > *table_elems, std::string *filename, std::list< NameValueAssign * > *s)
Definition: ParserNode.h:1087
std::list< std::unique_ptr< OrderSpec > > orderby_clause_
Definition: ParserNode.h:1839
const std::vector< std::string > & get_privs() const
Definition: ParserNode.h:1580
std::vector< std::string > privileges_
Definition: ParserNode.h:1618
CopyTableStmt(std::string *t, std::string *f, std::list< NameValueAssign * > *o)
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:198
std::list< std::unique_ptr< NameValueAssign > > options_
Definition: ParserNode.h:1513
bool get_is_distinct() const
Definition: ParserNode.h:1760
std::string to_string() const override
Definition: ParserNode.h:222
const std::string & get_object_type() const
Definition: ParserNode.h:1632
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:484
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:528
const std::vector< std::string > & get_grantees() const
Definition: ParserNode.h:1657
ColumnConstraintDef(std::string *t, std::string *c)
Definition: ParserNode.h:785
SubqueryExpr(QuerySpec *q)
Definition: ParserNode.h:333
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:609
bool get_is_not() const
Definition: ParserNode.h:587
std::string to_string() const override
Definition: ParserNode.h:125
const std::string * get_foreign_column() const
Definition: ParserNode.h:797
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::string to_string() const override
std::list< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:868
std::vector< std::unique_ptr< ValuesList > > values_lists_
Definition: ParserNode.h:2100
The data to be inserted using the fragment manager.
Definition: Fragmenter.h:68
const std::string * get_table() const
Definition: ParserNode.h:1402
const Expr * get_left() const
Definition: ParserNode.h:303
const rapidjson::Value payload_
Definition: ParserNode.h:1215
std::list< std::unique_ptr< std::string > > column_list_
Definition: ParserNode.h:900
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::vector< std::string > & get_privs() const
Definition: ParserNode.h:1610
void analyze_group_by(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
std::unique_ptr< std::string > role_
Definition: ParserNode.h:1641
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
const Expr * get_expr2() const
Definition: ParserNode.h:688
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:683
std::list< ColumnDescriptor > getColumnDescriptors(AggregatedResult &result, bool for_create)
const std::string * get_view_name() const
Definition: ParserNode.h:1914
const QuerySpec * get_query() const
Definition: ParserNode.h:612
const std::string * get_table() const override
Definition: ParserNode.h:1106
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
Common Enum definitions for SQL processing.
std::unique_ptr< Literal > defaultval_
Definition: ParserNode.h:803
std::unique_ptr< QueryExpr > query_expr_
Definition: ParserNode.h:1838
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
WidthBucketExpr(Expr *t, Expr *l, Expr *u, Expr *p)
Definition: ParserNode.h:556
auto const & getOldUserName()
Definition: ParserNode.h:1327
const std::string & get_object() const
Definition: ParserNode.h:1612
std::unique_ptr< std::string > foreign_table_
Definition: ParserNode.h:901
ColumnRef(std::string *n1)
Definition: ParserNode.h:629
std::string to_string() const override
std::string to_string() const override
const QuerySpec * get_query() const
Definition: ParserNode.h:334
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1366
constexpr double n
Definition: Utm.h:38
std::unique_ptr< std::string > column_
Definition: ParserNode.h:641
const std::string & get_view_name() const
Definition: ParserNode.h:1894
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
AlterUserStmt(const rapidjson::Value &payload)
LikeExpr(bool n, bool i, Expr *a, Expr *l, Expr *e)
Definition: ParserNode.h:493
std::string view_name_
Definition: ParserNode.h:1900
const Expr * get_escape_string() const
Definition: ParserNode.h:533
std::list< std::unique_ptr< ExprPair > > when_then_list_
Definition: ParserNode.h:716
virtual void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode)=0
FunctionRef(std::string *n)
Definition: ParserNode.h:650
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:178
std::unique_ptr< Expr > lower_bound_
Definition: ParserNode.h:575
OperExpr(SQLOps t, Expr *l, Expr *r)
Definition: ParserNode.h:298
std::list< std::unique_ptr< TableElement > > table_element_list_
Definition: ParserNode.h:1117
const CompressionType getCompression() const
Definition: ParserNode.h:1442
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:508
const QueryExpr * get_query_expr() const
Definition: ParserNode.h:1830
RenameColumnStmt(std::string *tab, std::string *col, std::string *new_col_name)
Definition: ParserNode.h:1360
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:571
auto const & getNewDatabaseName()
Definition: ParserNode.h:1313
ValuesList(std::list< Expr * > *values)
Definition: ParserNode.h:2059
CreateTableAsSelectStmt(const rapidjson::Value &payload)
CompressionType validateCompression(const std::string &compression, const bool is_restore)
const std::list< std::unique_ptr< Assignment > > & get_assignment_list() const
Definition: ParserNode.h:2133
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:853
FunctionRef(std::string *n, bool d, Expr *a)
Definition: ParserNode.h:652
DropDBStmt(const rapidjson::Value &payload)
AlterUserStmt(std::string *n, std::list< NameValueAssign * > *l)
Definition: ParserNode.h:1997
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1023
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:464
std::unique_ptr< Parser::Stmt > create_stmt_for_query(const std::string &queryStr, const Catalog_Namespace::SessionInfo &session_info)
RenameDBStmt(std::string *database_name, std::string *new_database_name)
Definition: ParserNode.h:1309
const Expr * get_arg() const
Definition: ParserNode.h:455
OrderSpec(int n, ColumnRef *c, bool d, bool f)
Definition: ParserNode.h:1801
std::list< std::unique_ptr< Expr > > value_list
Definition: ParserNode.h:2072
void insertChunksToLeaf(const Catalog_Namespace::SessionInfo &parent_session_info, const size_t leaf_idx, const Fragmenter_Namespace::InsertChunks &insert_chunks) override
Definition: ParserNode.h:1058
CreateUserStmt(const rapidjson::Value &payload)
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:442
double get_doubleval() const
Definition: ParserNode.h:217
RegexpExpr(bool n, Expr *a, Expr *p, Expr *e)
Definition: ParserNode.h:528
const std::string & get_object_type() const
Definition: ParserNode.h:1611
std::unique_ptr< std::string > filename_
Definition: ParserNode.h:1118
ShowPrivilegesStmt(std::string *t, std::string *o, std::string *r)
Definition: ParserNode.h:1630
UniqueDef(bool p, std::list< std::string * > *cl)
Definition: ParserNode.h:854
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::string * get_table() const
Definition: ParserNode.h:1384
SelectEntry(Expr *e, std::string *r)
Definition: ParserNode.h:1719
const QueryExpr * get_right() const
Definition: ParserNode.h:1707
std::unique_ptr< std::string > object_type_
Definition: ParserNode.h:1639
void analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
std::string to_string() const override
std::unique_ptr< std::string > table_
Definition: ParserNode.h:1405
const Expr * get_expr1() const
Definition: ParserNode.h:687
std::shared_ptr< Analyzer::Expr > analyze(const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
Definition: ParserNode.cpp:623
static std::unique_ptr< Parser::DDLStmt > delegate(const rapidjson::Value &payload)
const std::string & get_object() const
Definition: ParserNode.h:1582
const std::string * get_column() const
Definition: ParserNode.h:632
size_t leafCount() override
Definition: ParserNode.h:1057
std::unique_ptr< ColumnDef > coldef_
Definition: ParserNode.h:1388
std::unique_ptr< Expr > arg_
Definition: ParserNode.h:377
static void check_like_expr(const std::string &like_str, char escape_char)
Definition: ParserNode.cpp:637
void execute(const Catalog_Namespace::SessionInfo &session, bool read_only_mode) override
const std::list< std::unique_ptr< TableRef > > & get_from_clause() const
Definition: ParserNode.h:1764
auto const & getDatabaseName()
Definition: ParserNode.h:1958
DeleteStmt(std::string *t, Expr *w)
Definition: ParserNode.h:2152
const Expr * get_assignment() const
Definition: ParserNode.h:2111