OmniSciDB  c1a53651b2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Analyzer.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 
22 #pragma once
23 
24 #include "Geospatial/Types.h"
25 #include "Logger/Logger.h"
26 #include "Shared/DbObjectKeys.h"
27 #include "Shared/sqldefs.h"
28 #include "Shared/sqltypes.h"
29 
30 #include <algorithm>
31 #include <cstdint>
32 #include <functional>
33 #include <iostream>
34 #include <list>
35 #include <map>
36 #include <optional>
37 #include <set>
38 #include <sstream>
39 #include <string>
40 #include <type_traits>
41 #include <utility>
42 #include <vector>
43 
44 extern bool g_enable_string_functions;
45 
46 namespace Analyzer {
47 class Expr;
48 }
49 
50 template <typename Tp, typename... Args>
51 inline typename std::enable_if<std::is_base_of<Analyzer::Expr, Tp>::value,
52  std::shared_ptr<Tp>>::type
53 makeExpr(Args&&... args) {
54  return std::make_shared<Tp>(std::forward<Args>(args)...);
55 }
56 
57 namespace Analyzer {
58 
59 class ColumnVar;
60 class TargetEntry;
61 class Expr;
62 using DomainSet = std::list<const Expr*>;
63 
64 /*
65  * @type Expr
66  * @brief super class for all expressions in parse trees and in query plans
67  */
68 class Expr : public std::enable_shared_from_this<Expr> {
69  public:
70  Expr(SQLTypes t, bool notnull) : type_info(t, notnull), contains_agg(false) {}
71  Expr(SQLTypes t, int d, bool notnull)
72  : type_info(t, d, 0, notnull), contains_agg(false) {}
73  Expr(SQLTypes t, int d, int s, bool notnull)
74  : type_info(t, d, s, notnull), contains_agg(false) {}
75  Expr(const SQLTypeInfo& ti, bool has_agg = false)
76  : type_info(ti), contains_agg(has_agg) {}
77  virtual ~Expr() {}
78  std::shared_ptr<Analyzer::Expr> get_shared_ptr() { return shared_from_this(); }
79  const SQLTypeInfo& get_type_info() const { return type_info; }
80  void set_type_info(const SQLTypeInfo& ti) { type_info = ti; }
81  bool get_contains_agg() const { return contains_agg; }
82  void set_contains_agg(bool a) { contains_agg = a; }
83  virtual std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info);
84  virtual void check_group_by(
85  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const {};
86  virtual std::shared_ptr<Analyzer::Expr> deep_copy()
87  const = 0; // make a deep copy of self
88  /*
89  * @brief normalize_simple_predicate only applies to boolean expressions.
90  * it checks if it is an expression comparing a column
91  * with a constant. if so, it returns a normalized copy of the predicate with ColumnVar
92  * always as the left operand with rte_idx set to the rte_idx of the ColumnVar.
93  * it returns nullptr with rte_idx set to -1 otherwise.
94  */
95  virtual std::shared_ptr<Analyzer::Expr> normalize_simple_predicate(int& rte_idx) const {
96  rte_idx = -1;
97  return nullptr;
98  }
99  /*
100  * @brief seperate conjunctive predicates into scan predicates, join predicates and
101  * constant predicates.
102  */
103  virtual void group_predicates(std::list<const Expr*>& scan_predicates,
104  std::list<const Expr*>& join_predicates,
105  std::list<const Expr*>& const_predicates) const {}
106  /*
107  * @brief collect_rte_idx collects the indices of all the range table
108  * entries involved in an expression
109  */
110  virtual void collect_rte_idx(std::set<int>& rte_idx_set) const {}
111  /*
112  * @brief collect_column_var collects all unique ColumnVar nodes in an expression
113  * If include_agg = false, it does not include to ColumnVar nodes inside
114  * the argument to AggExpr's. Otherwise, they are included.
115  * It does not make copies of the ColumnVar
116  */
117  virtual void collect_column_var(
118  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
119  colvar_set,
120  bool include_agg) const {}
121 
122  virtual size_t get_num_column_vars(const bool include_agg) const;
123 
124  /*
125  * @brief rewrite_with_targetlist rewrite ColumnVar's in expression with entries in a
126  * targetlist. targetlist expressions are expected to be only Var's or AggExpr's.
127  * returns a new expression copy
128  */
129  virtual std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
130  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const {
131  return deep_copy();
132  };
133  /*
134  * @brief rewrite_with_child_targetlist rewrite ColumnVar's in expression with entries
135  * in a child plan's targetlist. targetlist expressions are expected to be only Var's or
136  * ColumnVar's returns a new expression copy
137  */
138  virtual std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
139  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const {
140  return deep_copy();
141  };
142  /*
143  * @brief rewrite_agg_to_var rewrite ColumnVar's in expression with entries in an
144  * AggPlan's targetlist. targetlist expressions are expected to be only Var's or
145  * ColumnVar's or AggExpr's All AggExpr's are written into Var's. returns a new
146  * expression copy
147  */
148  virtual std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
149  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const {
150  return deep_copy();
151  }
152  virtual bool operator==(const Expr& rhs) const = 0;
153  virtual std::string toString() const = 0;
154  virtual void print() const { std::cout << toString(); }
155 
156  virtual void add_unique(std::list<const Expr*>& expr_list) const;
157  /*
158  * @brief find_expr traverse Expr hierarchy and adds the node pointer to
159  * the expr_list if the function f returns true.
160  * Duplicate Expr's are not added the list.
161  * Cannot use std::set because we don't have an ordering function.
162  */
163  virtual void find_expr(std::function<bool(const Expr*)> f,
164  std::list<const Expr*>& expr_list) const {
165  if (f(this)) {
166  add_unique(expr_list);
167  }
168  }
169  /*
170  * @brief decompress adds cast operator to decompress encoded result
171  */
172  std::shared_ptr<Analyzer::Expr> decompress();
173  /*
174  * @brief perform domain analysis on Expr and fill in domain
175  * information in domain_set. Empty domain_set means no information.
176  */
177  virtual void get_domain(DomainSet& domain_set) const { domain_set.clear(); }
178 
179  protected:
180  SQLTypeInfo type_info; // SQLTypeInfo of the return result of this expression
182 };
183 
184 using ExpressionPtr = std::shared_ptr<Analyzer::Expr>;
185 using ExpressionPtrList = std::list<ExpressionPtr>;
186 using ExpressionPtrVector = std::vector<ExpressionPtr>;
187 
188 /*
189  * @type ColumnVar
190  * @brief expression that evaluates to the value of a column in a given row from a base
191  * table. It is used in parse trees and is only used in Scan nodes in a query plan for
192  * scanning a table while Var nodes are used for all other plans.
193  */
194 class ColumnVar : public Expr {
195  public:
196  ColumnVar(const SQLTypeInfo& ti, const shared::ColumnKey& column_key, int32_t rte_idx)
197  : Expr(ti), column_key_(column_key), rte_idx_(rte_idx) {}
198  const shared::ColumnKey& getColumnKey() const { return column_key_; }
201  }
202  int32_t get_rte_idx() const { return rte_idx_; }
203  void set_rte_idx(int32_t new_rte_idx) { rte_idx_ = new_rte_idx; }
205 
206  void check_group_by(
207  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
208  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
209  void group_predicates(std::list<const Expr*>& scan_predicates,
210  std::list<const Expr*>& join_predicates,
211  std::list<const Expr*>& const_predicates) const override;
212  void collect_rte_idx(std::set<int32_t>& rte_idx_set) const override {
213  rte_idx_set.insert(rte_idx_);
214  }
215  static bool colvar_comp(const ColumnVar* l, const ColumnVar* r) {
216  CHECK(l);
217  const auto& l_column_key = l->column_key_;
218  CHECK(r);
219  const auto& r_column_key = r->column_key_;
220  return l_column_key < r_column_key;
221  }
223  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
224  colvar_set,
225  bool include_agg) const override {
226  colvar_set.insert(this);
227  }
228 
229  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
230  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
231  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
232  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
233  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
234  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
235  bool operator==(const Expr& rhs) const override;
236  std::string toString() const override;
237 
238  protected:
240  int32_t rte_idx_; // 0-based range table index, used for table ordering in multi-joins
241 };
242 
243 /*
244  * @type ExpressionTuple
245  * @brief A tuple of expressions on the side of an equi-join on multiple columns.
246  * Not to be used in any other context.
247  */
248 class ExpressionTuple : public Expr {
249  public:
250  ExpressionTuple(const std::vector<std::shared_ptr<Analyzer::Expr>>& tuple)
251  : Expr(SQLTypeInfo()), tuple_(tuple){};
252 
253  const std::vector<std::shared_ptr<Analyzer::Expr>>& getTuple() const { return tuple_; }
254 
255  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
256 
257  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
258 
259  bool operator==(const Expr& rhs) const override;
260  std::string toString() const override;
261 
262  private:
263  const std::vector<std::shared_ptr<Analyzer::Expr>> tuple_;
264 };
265 
266 /*
267  * @type Var
268  * @brief expression that evaluates to the value of a column in a given row generated
269  * from a query plan node. It is only used in plan nodes above Scan nodes.
270  * The row can be produced by either the inner or the outer plan in case of a join.
271  * It inherits from ColumnVar to keep track of the lineage through the plan nodes.
272  * The table_id will be set to 0 if the Var does not correspond to an original column
273  * value.
274  */
275 class Var : public ColumnVar {
276  public:
278  Var(const SQLTypeInfo& ti,
279  const shared::ColumnKey& column_key,
280  int32_t rte_idx,
281  WhichRow o,
282  int32_t v)
283  : ColumnVar(ti, column_key, rte_idx), which_row(o), varno(v) {}
284  Var(const SQLTypeInfo& ti, WhichRow o, int32_t v)
285  : ColumnVar(ti, {0, 0, 0}, -1), which_row(o), varno(v) {}
286  WhichRow get_which_row() const { return which_row; }
288  int32_t get_varno() const { return varno; }
289  void set_varno(int32_t n) { varno = n; }
290  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
291  std::string toString() const override;
292  void check_group_by(
293  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
294  void collect_rte_idx(std::set<int32_t>& rte_idx_set) const override {
295  rte_idx_set.insert(-1);
296  }
297  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
298  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
299  return deep_copy();
300  }
301  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
302  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
303  return deep_copy();
304  }
305  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
306  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
307 
308  private:
309  WhichRow which_row; // indicate which row this Var should project from. It can be from
310  // the outer input plan or the inner input plan (for joins) or the
311  // output row in the current plan.
312  int32_t varno; // the column number in the row. 1-based
313 };
314 
315 /*
316  * @type Constant
317  * @brief expression for a constant value
318  */
319 class Constant : public Expr {
320  public:
321  Constant(SQLTypes t, bool n) : Expr(t, !n), is_null(n) {
322  if (n) {
323  set_null_value();
324  } else {
325  type_info.set_notnull(true);
326  }
327  }
328  Constant(SQLTypes t, bool n, Datum v) : Expr(t, !n), is_null(n), constval(v) {
329  if (n) {
330  set_null_value();
331  } else {
332  type_info.set_notnull(true);
333  }
334  }
335  Constant(const SQLTypeInfo& ti, bool n, Datum v) : Expr(ti), is_null(n), constval(v) {
336  if (n) {
337  set_null_value();
338  } else {
339  type_info.set_notnull(true);
340  }
341  }
343  bool n,
344  const std::list<std::shared_ptr<Analyzer::Expr>>& l)
345  : Expr(ti), is_null(n), constval(Datum{0}), value_list(l) {}
346  ~Constant() override;
347  bool get_is_null() const { return is_null; }
348  Datum get_constval() const { return constval; }
349  void set_constval(Datum d) { constval = d; }
350  const std::list<std::shared_ptr<Analyzer::Expr>>& get_value_list() const {
351  return value_list;
352  }
353  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
354  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) override;
355  bool operator==(const Expr& rhs) const override;
356  std::string toString() const override;
357 
358  protected:
359  bool is_null; // constant is NULL
360  Datum constval; // the constant value
361  const std::list<std::shared_ptr<Analyzer::Expr>> value_list;
362  void cast_number(const SQLTypeInfo& new_type_info);
363  void cast_string(const SQLTypeInfo& new_type_info);
364  void cast_from_string(const SQLTypeInfo& new_type_info);
365  void cast_to_string(const SQLTypeInfo& new_type_info);
366  void do_cast(const SQLTypeInfo& new_type_info);
367  void set_null_value();
368 };
369 
370 /*
371  * @type UOper
372  * @brief represents unary operator expressions. operator types include
373  * kUMINUS, kISNULL, kEXISTS, kCAST
374  */
375 class UOper : public Expr {
376  public:
377  UOper(const SQLTypeInfo& ti, bool has_agg, SQLOps o, std::shared_ptr<Analyzer::Expr> p)
378  : Expr(ti, has_agg), optype(o), operand(p) {}
379  UOper(SQLTypes t, SQLOps o, std::shared_ptr<Analyzer::Expr> p)
380  : Expr(t, o == kISNULL ? true : p->get_type_info().get_notnull())
381  , optype(o)
382  , operand(p) {}
383  SQLOps get_optype() const { return optype; }
384  const Expr* get_operand() const { return operand.get(); }
385  const std::shared_ptr<Analyzer::Expr> get_own_operand() const { return operand; }
386  void check_group_by(
387  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
388  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
389  void group_predicates(std::list<const Expr*>& scan_predicates,
390  std::list<const Expr*>& join_predicates,
391  std::list<const Expr*>& const_predicates) const override;
392  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
393  operand->collect_rte_idx(rte_idx_set);
394  }
396  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
397  colvar_set,
398  bool include_agg) const override {
399  operand->collect_column_var(colvar_set, include_agg);
400  }
401  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
402  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
403  return makeExpr<UOper>(
404  type_info, contains_agg, optype, operand->rewrite_with_targetlist(tlist));
405  }
406  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
407  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
408  return makeExpr<UOper>(
409  type_info, contains_agg, optype, operand->rewrite_with_child_targetlist(tlist));
410  }
411  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
412  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
413  return makeExpr<UOper>(
414  type_info, contains_agg, optype, operand->rewrite_agg_to_var(tlist));
415  }
416  bool operator==(const Expr& rhs) const override;
417  std::string toString() const override;
418  void find_expr(std::function<bool(const Expr*)> f,
419  std::list<const Expr*>& expr_list) const override;
420  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) override;
421 
422  protected:
423  SQLOps optype; // operator type, e.g., kUMINUS, kISNULL, kEXISTS
424  std::shared_ptr<Analyzer::Expr> operand; // operand expression
425 };
426 
427 /*
428  * @type BinOper
429  * @brief represents binary operator expressions. it includes all
430  * comparison, arithmetic and boolean binary operators. it handles ANY/ALL qualifiers
431  * in case the right_operand is a subquery.
432  */
433 class BinOper : public Expr {
434  public:
435  BinOper(const SQLTypeInfo& ti,
436  bool has_agg,
437  SQLOps o,
438  SQLQualifier q,
439  std::shared_ptr<Analyzer::Expr> l,
440  std::shared_ptr<Analyzer::Expr> r)
441  : Expr(ti, has_agg), optype(o), qualifier(q), left_operand(l), right_operand(r) {}
443  SQLOps o,
444  SQLQualifier q,
445  std::shared_ptr<Analyzer::Expr> l,
446  std::shared_ptr<Analyzer::Expr> r)
447  : Expr(t, l->get_type_info().get_notnull() && r->get_type_info().get_notnull())
448  , optype(o)
449  , qualifier(q)
450  , left_operand(l)
451  , right_operand(r) {}
452  SQLOps get_optype() const { return optype; }
453  bool is_overlaps_oper() const { return optype == kOVERLAPS; }
455  const Expr* get_left_operand() const { return left_operand.get(); }
456  const Expr* get_right_operand() const { return right_operand.get(); }
457  const std::shared_ptr<Analyzer::Expr> get_own_left_operand() const {
458  return left_operand;
459  }
460  const std::shared_ptr<Analyzer::Expr> get_own_right_operand() const {
461  return right_operand;
462  }
464  const SQLTypeInfo& left_type,
465  const SQLTypeInfo& right_type,
466  SQLTypeInfo* new_left_type,
467  SQLTypeInfo* new_right_type);
468  static SQLTypeInfo common_numeric_type(const SQLTypeInfo& type1,
469  const SQLTypeInfo& type2);
470  static SQLTypeInfo common_string_type(const SQLTypeInfo& type1,
471  const SQLTypeInfo& type2);
472  void check_group_by(
473  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
474  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
475  std::shared_ptr<Analyzer::Expr> normalize_simple_predicate(int& rte_idx) const override;
476  void group_predicates(std::list<const Expr*>& scan_predicates,
477  std::list<const Expr*>& join_predicates,
478  std::list<const Expr*>& const_predicates) const override;
479  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
480  left_operand->collect_rte_idx(rte_idx_set);
481  right_operand->collect_rte_idx(rte_idx_set);
482  }
484  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
485  colvar_set,
486  bool include_agg) const override {
487  left_operand->collect_column_var(colvar_set, include_agg);
488  right_operand->collect_column_var(colvar_set, include_agg);
489  }
490  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
491  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
492  return makeExpr<BinOper>(type_info,
493  contains_agg,
494  optype,
495  qualifier,
496  left_operand->rewrite_with_targetlist(tlist),
497  right_operand->rewrite_with_targetlist(tlist));
498  }
499  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
500  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
501  return makeExpr<BinOper>(type_info,
502  contains_agg,
503  optype,
504  qualifier,
505  left_operand->rewrite_with_child_targetlist(tlist),
506  right_operand->rewrite_with_child_targetlist(tlist));
507  }
508  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
509  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
510  return makeExpr<BinOper>(type_info,
511  contains_agg,
512  optype,
513  qualifier,
514  left_operand->rewrite_agg_to_var(tlist),
515  right_operand->rewrite_agg_to_var(tlist));
516  }
517  bool operator==(const Expr& rhs) const override;
518  std::string toString() const override;
519  void find_expr(std::function<bool(const Expr*)> f,
520  std::list<const Expr*>& expr_list) const override;
522  const std::shared_ptr<Analyzer::Expr> cast_operand,
523  const std::shared_ptr<Analyzer::Expr> const_operand);
524 
525  private:
526  SQLOps optype; // operator type, e.g., kLT, kAND, kPLUS, etc.
527  SQLQualifier qualifier; // qualifier kANY, kALL or kONE. Only relevant with
528  // right_operand is Subquery
529  std::shared_ptr<Analyzer::Expr> left_operand; // the left operand expression
530  std::shared_ptr<Analyzer::Expr> right_operand; // the right operand expression
531 };
532 
537 class RangeOper : public Expr {
538  public:
539  RangeOper(const bool l_inclusive,
540  const bool r_inclusive,
541  std::shared_ptr<Analyzer::Expr> l,
542  std::shared_ptr<Analyzer::Expr> r)
543  : Expr(SQLTypeInfo(kNULLT), /*not_null=*/false)
544  , left_inclusive_(l_inclusive)
545  , right_inclusive_(r_inclusive)
546  , left_operand_(l)
547  , right_operand_(r) {
550  }
551 
552  const Expr* get_left_operand() const { return left_operand_.get(); }
553  const Expr* get_right_operand() const { return right_operand_.get(); }
554 
555  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
556  bool operator==(const Expr& rhs) const override;
557  std::string toString() const override;
558 
559  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
560  left_operand_->collect_rte_idx(rte_idx_set);
561  right_operand_->collect_rte_idx(rte_idx_set);
562  }
563 
565  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
566  colvar_set,
567  bool include_agg) const override {
568  left_operand_->collect_column_var(colvar_set, include_agg);
569  right_operand_->collect_column_var(colvar_set, include_agg);
570  }
571 
572  private:
573  // build a range between these two operands
576  std::shared_ptr<Analyzer::Expr> left_operand_;
577  std::shared_ptr<Analyzer::Expr> right_operand_;
578 };
579 
580 class Query;
581 
582 /*
583  * @type Subquery
584  * @brief subquery expression. Note that the type of the expression is the type of the
585  * TargetEntry in the subquery instead of the set.
586  */
587 class Subquery : public Expr {
588  public:
589  Subquery(const SQLTypeInfo& ti, Query* q)
590  : Expr(ti), parsetree(q) /*, plan(nullptr)*/ {}
591  ~Subquery() override;
592  const Query* get_parsetree() const { return parsetree; }
593  // const Plan *get_plan() const { return plan; }
594  // void set_plan(Plan *p) { plan = p; } // subquery plan is set by the optimizer
595  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) override;
596  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
597  void group_predicates(std::list<const Expr*>& scan_predicates,
598  std::list<const Expr*>& join_predicates,
599  std::list<const Expr*>& const_predicates) const override {
600  CHECK(false);
601  }
602  void collect_rte_idx(std::set<int>& rte_idx_set) const override { CHECK(false); }
604  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
605  colvar_set,
606  bool include_agg) const override {
607  CHECK(false);
608  }
609  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
610  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
611  abort();
612  }
613  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
614  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
615  abort();
616  }
617  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
618  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
619  abort();
620  }
621  bool operator==(const Expr& rhs) const override {
622  CHECK(false);
623  return false;
624  }
625  std::string toString() const override;
626  void find_expr(std::function<bool(const Expr*)> f,
627  std::list<const Expr*>& expr_list) const override {
628  CHECK(false);
629  }
630 
631  private:
632  Query* parsetree; // parse tree of the subquery
633 };
634 
635 /*
636  * @type InValues
637  * @brief represents predicate expr IN (v1, v2, ...)
638  * v1, v2, ... are can be either Constant or Parameter.
639  */
640 class InValues : public Expr {
641  public:
642  InValues(std::shared_ptr<Analyzer::Expr> a,
643  const std::list<std::shared_ptr<Analyzer::Expr>>& l);
644  const Expr* get_arg() const { return arg.get(); }
645  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
646  const std::list<std::shared_ptr<Analyzer::Expr>>& get_value_list() const {
647  return value_list;
648  }
649  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
650  void group_predicates(std::list<const Expr*>& scan_predicates,
651  std::list<const Expr*>& join_predicates,
652  std::list<const Expr*>& const_predicates) const override;
653  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
654  arg->collect_rte_idx(rte_idx_set);
655  }
657  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
658  colvar_set,
659  bool include_agg) const override {
660  arg->collect_column_var(colvar_set, include_agg);
661  }
662  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
663  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
664  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
665  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
666  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
667  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
668  bool operator==(const Expr& rhs) const override;
669  std::string toString() const override;
670  void find_expr(std::function<bool(const Expr*)> f,
671  std::list<const Expr*>& expr_list) const override;
672 
673  private:
674  std::shared_ptr<Analyzer::Expr> arg; // the argument left of IN
675  const std::list<std::shared_ptr<Analyzer::Expr>>
676  value_list; // the list of values right of IN
677 };
678 
679 /*
680  * @type InIntegerSet
681  * @brief represents predicate expr IN (v1, v2, ...) for the case where the right
682  * hand side is a list of integers or dictionary-encoded strings generated
683  * by a IN subquery. Avoids the overhead of storing a list of shared pointers
684  * to Constant objects, making it more suitable for IN sub-queries usage.
685  * v1, v2, ... are integers
686  */
687 class InIntegerSet : public Expr {
688  public:
689  InIntegerSet(const std::shared_ptr<const Analyzer::Expr> a,
690  const std::vector<int64_t>& values,
691  const bool not_null);
692 
693  const Expr* get_arg() const { return arg.get(); }
694 
695  const std::vector<int64_t>& get_value_list() const { return value_list; }
696 
697  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
698 
699  bool operator==(const Expr& rhs) const override;
700  std::string toString() const override;
701 
702  private:
703  const std::shared_ptr<const Analyzer::Expr> arg; // the argument left of IN
704  const std::vector<int64_t> value_list; // the list of values right of IN
705 };
706 
707 /*
708  * @type CharLengthExpr
709  * @brief expression for the CHAR_LENGTH expression.
710  * arg must evaluate to char, varchar or text.
711  */
712 class CharLengthExpr : public Expr {
713  public:
714  CharLengthExpr(std::shared_ptr<Analyzer::Expr> a, bool e)
715  : Expr(kINT, a->get_type_info().get_notnull()), arg(a), calc_encoded_length(e) {}
716  const Expr* get_arg() const { return arg.get(); }
717  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
719  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
720  void group_predicates(std::list<const Expr*>& scan_predicates,
721  std::list<const Expr*>& join_predicates,
722  std::list<const Expr*>& const_predicates) const override;
723  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
724  arg->collect_rte_idx(rte_idx_set);
725  }
727  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
728  colvar_set,
729  bool include_agg) const override {
730  arg->collect_column_var(colvar_set, include_agg);
731  }
732  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
733  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
734  return makeExpr<CharLengthExpr>(arg->rewrite_with_targetlist(tlist),
736  }
737  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
738  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
739  return makeExpr<CharLengthExpr>(arg->rewrite_with_child_targetlist(tlist),
741  }
742  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
743  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
744  return makeExpr<CharLengthExpr>(arg->rewrite_agg_to_var(tlist), calc_encoded_length);
745  }
746  bool operator==(const Expr& rhs) const override;
747  std::string toString() const override;
748  void find_expr(std::function<bool(const Expr*)> f,
749  std::list<const Expr*>& expr_list) const override;
750 
751  private:
752  std::shared_ptr<Analyzer::Expr> arg;
754 };
755 
756 /*
757  * @type KeyForStringExpr
758  * @brief expression for the KEY_FOR_STRING expression.
759  * arg must be a dict encoded column, not str literal.
760  */
761 class KeyForStringExpr : public Expr {
762  public:
763  KeyForStringExpr(std::shared_ptr<Analyzer::Expr> a)
764  : Expr(kINT, a->get_type_info().get_notnull()), arg(a) {}
765  const Expr* get_arg() const { return arg.get(); }
766  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
767  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
768  void group_predicates(std::list<const Expr*>& scan_predicates,
769  std::list<const Expr*>& join_predicates,
770  std::list<const Expr*>& const_predicates) const override;
771  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
772  arg->collect_rte_idx(rte_idx_set);
773  }
775  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
776  colvar_set,
777  bool include_agg) const override {
778  arg->collect_column_var(colvar_set, include_agg);
779  }
780  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
781  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
782  return makeExpr<KeyForStringExpr>(arg->rewrite_with_targetlist(tlist));
783  }
784  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
785  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
786  return makeExpr<KeyForStringExpr>(arg->rewrite_with_child_targetlist(tlist));
787  }
788  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
789  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
790  return makeExpr<KeyForStringExpr>(arg->rewrite_agg_to_var(tlist));
791  }
792  bool operator==(const Expr& rhs) const override;
793  std::string toString() const override;
794  void find_expr(std::function<bool(const Expr*)> f,
795  std::list<const Expr*>& expr_list) const override;
796 
797  private:
798  std::shared_ptr<Analyzer::Expr> arg;
799 };
800 
801 /*
802  * @type SampleRatioExpr
803  * @brief expression for the SAMPLE_RATIO expression. Argument range is expected to be
804  * between 0 and 1.
805  */
806 class SampleRatioExpr : public Expr {
807  public:
808  SampleRatioExpr(std::shared_ptr<Analyzer::Expr> a)
809  : Expr(kBOOLEAN, a->get_type_info().get_notnull()), arg(a) {}
810  const Expr* get_arg() const { return arg.get(); }
811  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
812  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
813  void group_predicates(std::list<const Expr*>& scan_predicates,
814  std::list<const Expr*>& join_predicates,
815  std::list<const Expr*>& const_predicates) const override;
816  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
817  arg->collect_rte_idx(rte_idx_set);
818  }
820  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
821  colvar_set,
822  bool include_agg) const override {
823  arg->collect_column_var(colvar_set, include_agg);
824  }
825  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
826  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
827  return makeExpr<SampleRatioExpr>(arg->rewrite_with_targetlist(tlist));
828  }
829  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
830  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
831  return makeExpr<SampleRatioExpr>(arg->rewrite_with_child_targetlist(tlist));
832  }
833  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
834  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
835  return makeExpr<SampleRatioExpr>(arg->rewrite_agg_to_var(tlist));
836  }
837  bool operator==(const Expr& rhs) const override;
838  std::string toString() const override;
839  void find_expr(std::function<bool(const Expr*)> f,
840  std::list<const Expr*>& expr_list) const override;
841 
842  private:
843  std::shared_ptr<Analyzer::Expr> arg;
844 };
845 
846 /*
847  * @type CardinalityExpr
848  * @brief expression for the CARDINALITY expression.
849  * arg must evaluate to array (or multiset when supported).
850  */
851 class CardinalityExpr : public Expr {
852  public:
853  CardinalityExpr(std::shared_ptr<Analyzer::Expr> a)
854  : Expr(kINT, a->get_type_info().get_notnull()), arg(a) {}
855  const Expr* get_arg() const { return arg.get(); }
856  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
857  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
858  void group_predicates(std::list<const Expr*>& scan_predicates,
859  std::list<const Expr*>& join_predicates,
860  std::list<const Expr*>& const_predicates) const override;
861  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
862  arg->collect_rte_idx(rte_idx_set);
863  }
865  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
866  colvar_set,
867  bool include_agg) const override {
868  arg->collect_column_var(colvar_set, include_agg);
869  }
870  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
871  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
872  return makeExpr<CardinalityExpr>(arg->rewrite_with_targetlist(tlist));
873  }
874  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
875  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
876  return makeExpr<CardinalityExpr>(arg->rewrite_with_child_targetlist(tlist));
877  }
878  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
879  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
880  return makeExpr<CardinalityExpr>(arg->rewrite_agg_to_var(tlist));
881  }
882  bool operator==(const Expr& rhs) const override;
883  std::string toString() const override;
884  void find_expr(std::function<bool(const Expr*)> f,
885  std::list<const Expr*>& expr_list) const override;
886 
887  private:
888  std::shared_ptr<Analyzer::Expr> arg;
889 };
890 
891 /*
892  * @type LikeExpr
893  * @brief expression for the LIKE predicate.
894  * arg must evaluate to char, varchar or text.
895  */
896 class LikeExpr : public Expr {
897  public:
898  LikeExpr(std::shared_ptr<Analyzer::Expr> a,
899  std::shared_ptr<Analyzer::Expr> l,
900  std::shared_ptr<Analyzer::Expr> e,
901  bool i,
902  bool s)
903  : Expr(kBOOLEAN, a->get_type_info().get_notnull())
904  , arg(a)
905  , like_expr(l)
906  , escape_expr(e)
907  , is_ilike(i)
908  , is_simple(s) {}
909  const Expr* get_arg() const { return arg.get(); }
910  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
911  const Expr* get_like_expr() const { return like_expr.get(); }
912  const Expr* get_escape_expr() const { return escape_expr.get(); }
913  bool get_is_ilike() const { return is_ilike; }
914  bool get_is_simple() const { return is_simple; }
915  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
916  void group_predicates(std::list<const Expr*>& scan_predicates,
917  std::list<const Expr*>& join_predicates,
918  std::list<const Expr*>& const_predicates) const override;
919  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
920  arg->collect_rte_idx(rte_idx_set);
921  }
923  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
924  colvar_set,
925  bool include_agg) const override {
926  arg->collect_column_var(colvar_set, include_agg);
927  }
928  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
929  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
930  return makeExpr<LikeExpr>(arg->rewrite_with_targetlist(tlist),
931  like_expr->deep_copy(),
932  escape_expr ? escape_expr->deep_copy() : nullptr,
933  is_ilike,
934  is_simple);
935  }
936  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
937  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
938  return makeExpr<LikeExpr>(arg->rewrite_with_child_targetlist(tlist),
939  like_expr->deep_copy(),
940  escape_expr ? escape_expr->deep_copy() : nullptr,
941  is_ilike,
942  is_simple);
943  }
944  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
945  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
946  return makeExpr<LikeExpr>(arg->rewrite_agg_to_var(tlist),
947  like_expr->deep_copy(),
948  escape_expr ? escape_expr->deep_copy() : nullptr,
949  is_ilike,
950  is_simple);
951  }
952  bool operator==(const Expr& rhs) const override;
953  std::string toString() const override;
954  void find_expr(std::function<bool(const Expr*)> f,
955  std::list<const Expr*>& expr_list) const override;
956 
957  private:
958  std::shared_ptr<Analyzer::Expr> arg; // the argument to the left of LIKE
959  std::shared_ptr<Analyzer::Expr> like_expr; // expression that evaluates to like string
960  std::shared_ptr<Analyzer::Expr>
961  escape_expr; // expression that evaluates to escape string, can be nullptr
962  bool is_ilike; // is this ILIKE?
963  bool is_simple; // is this simple, meaning we can use fast path search (fits '%str%'
964  // pattern with no inner '%','_','[',']'
965 };
966 
967 /*
968  * @type RegexpExpr
969  * @brief expression for REGEXP.
970  * arg must evaluate to char, varchar or text.
971  */
972 class RegexpExpr : public Expr {
973  public:
974  RegexpExpr(std::shared_ptr<Analyzer::Expr> a,
975  std::shared_ptr<Analyzer::Expr> p,
976  std::shared_ptr<Analyzer::Expr> e)
977  : Expr(kBOOLEAN, a->get_type_info().get_notnull())
978  , arg(a)
979  , pattern_expr(p)
980  , escape_expr(e) {}
981  const Expr* get_arg() const { return arg.get(); }
982  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
983  const Expr* get_pattern_expr() const { return pattern_expr.get(); }
984  const Expr* get_escape_expr() const { return escape_expr.get(); }
985  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
986  void group_predicates(std::list<const Expr*>& scan_predicates,
987  std::list<const Expr*>& join_predicates,
988  std::list<const Expr*>& const_predicates) const override;
989  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
990  arg->collect_rte_idx(rte_idx_set);
991  }
993  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
994  colvar_set,
995  bool include_agg) const override {
996  arg->collect_column_var(colvar_set, include_agg);
997  }
998  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
999  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1000  return makeExpr<RegexpExpr>(arg->rewrite_with_targetlist(tlist),
1001  pattern_expr->deep_copy(),
1002  escape_expr ? escape_expr->deep_copy() : nullptr);
1003  }
1004  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1005  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1006  return makeExpr<RegexpExpr>(arg->rewrite_with_child_targetlist(tlist),
1007  pattern_expr->deep_copy(),
1008  escape_expr ? escape_expr->deep_copy() : nullptr);
1009  }
1010  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1011  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1012  return makeExpr<RegexpExpr>(arg->rewrite_agg_to_var(tlist),
1013  pattern_expr->deep_copy(),
1014  escape_expr ? escape_expr->deep_copy() : nullptr);
1015  }
1016  bool operator==(const Expr& rhs) const override;
1017  std::string toString() const override;
1018  void find_expr(std::function<bool(const Expr*)> f,
1019  std::list<const Expr*>& expr_list) const override;
1020 
1021  private:
1022  std::shared_ptr<Analyzer::Expr> arg; // the argument to the left of REGEXP
1023  std::shared_ptr<Analyzer::Expr>
1024  pattern_expr; // expression that evaluates to pattern string
1025  std::shared_ptr<Analyzer::Expr>
1026  escape_expr; // expression that evaluates to escape string, can be nullptr
1027 };
1028 
1029 /*
1030  * @type WidthBucketExpr
1031  * @brief expression for width_bucket functions.
1032  */
1033 class WidthBucketExpr : public Expr {
1034  public:
1035  WidthBucketExpr(const std::shared_ptr<Analyzer::Expr> target_value,
1036  const std::shared_ptr<Analyzer::Expr> lower_bound,
1037  const std::shared_ptr<Analyzer::Expr> upper_bound,
1038  const std::shared_ptr<Analyzer::Expr> partition_count)
1039  : Expr(kINT, target_value->get_type_info().get_notnull())
1040  , target_value_(target_value)
1041  , lower_bound_(lower_bound)
1042  , upper_bound_(upper_bound)
1043  , partition_count_(partition_count)
1046  const Expr* get_target_value() const { return target_value_.get(); }
1047  const Expr* get_lower_bound() const { return lower_bound_.get(); }
1048  const Expr* get_upper_bound() const { return upper_bound_.get(); }
1049  const Expr* get_partition_count() const { return partition_count_.get(); }
1050  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1051  void group_predicates(std::list<const Expr*>& scan_predicates,
1052  std::list<const Expr*>& join_predicates,
1053  std::list<const Expr*>& const_predicates) const override;
1054  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
1055  target_value_->collect_rte_idx(rte_idx_set);
1056  }
1058  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1059  colvar_set,
1060  bool include_agg) const override {
1061  target_value_->collect_column_var(colvar_set, include_agg);
1062  }
1063  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1064  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1065  return makeExpr<WidthBucketExpr>(target_value_->rewrite_with_targetlist(tlist),
1066  lower_bound_,
1067  upper_bound_,
1069  }
1070  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1071  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1072  return makeExpr<WidthBucketExpr>(target_value_->rewrite_with_child_targetlist(tlist),
1073  lower_bound_,
1074  upper_bound_,
1076  }
1077  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1078  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1079  return makeExpr<WidthBucketExpr>(target_value_->rewrite_agg_to_var(tlist),
1080  lower_bound_,
1081  upper_bound_,
1083  }
1084  double get_bound_val(const Analyzer::Expr* bound_expr) const;
1085  int32_t get_partition_count_val() const;
1086  template <typename T>
1087  int32_t compute_bucket(T target_const_val, SQLTypeInfo& ti) const {
1088  // this utility function is useful for optimizing expression range decision
1089  // for an expression depending on width_bucket expr
1090  T null_val = ti.is_integer() ? inline_int_null_val(ti) : inline_fp_null_val(ti);
1091  double lower_bound_val = get_bound_val(lower_bound_.get());
1092  double upper_bound_val = get_bound_val(upper_bound_.get());
1093  auto partition_count_val = get_partition_count_val();
1094  if (target_const_val == null_val) {
1095  return INT32_MIN;
1096  }
1097  float res;
1098  if (lower_bound_val < upper_bound_val) {
1099  if (target_const_val < lower_bound_val) {
1100  return 0;
1101  } else if (target_const_val >= upper_bound_val) {
1102  return partition_count_val + 1;
1103  }
1104  double dividend = upper_bound_val - lower_bound_val;
1105  res = ((partition_count_val * (target_const_val - lower_bound_val)) / dividend) + 1;
1106  } else {
1107  if (target_const_val > lower_bound_val) {
1108  return 0;
1109  } else if (target_const_val <= upper_bound_val) {
1110  return partition_count_val + 1;
1111  }
1112  double dividend = lower_bound_val - upper_bound_val;
1113  res = ((partition_count_val * (lower_bound_val - target_const_val)) / dividend) + 1;
1114  }
1115  return res;
1116  }
1117  bool operator==(const Expr& rhs) const override;
1118  std::string toString() const override;
1119  void find_expr(std::function<bool(const Expr*)> f,
1120  std::list<const Expr*>& expr_list) const override;
1123  void set_constant_expr() const { constant_expr_ = true; }
1124  bool is_constant_expr() const { return constant_expr_; }
1125 
1126  private:
1127  std::shared_ptr<Analyzer::Expr> target_value_; // target value expression
1128  std::shared_ptr<Analyzer::Expr> lower_bound_; // lower_bound
1129  std::shared_ptr<Analyzer::Expr> upper_bound_; // upper_bound
1130  std::shared_ptr<Analyzer::Expr> partition_count_; // partition_count
1131  // true if lower, upper and partition count exprs are constant
1132  mutable bool constant_expr_;
1133  // true if we can skip oob check and is determined within compile time
1135 };
1136 
1137 /*
1138  * @type LikelihoodExpr
1139  * @brief expression for LIKELY and UNLIKELY boolean identity functions.
1140  */
1141 class LikelihoodExpr : public Expr {
1142  public:
1143  LikelihoodExpr(std::shared_ptr<Analyzer::Expr> a, float l = 0.5)
1144  : Expr(kBOOLEAN, a->get_type_info().get_notnull()), arg(a), likelihood(l) {}
1145  const Expr* get_arg() const { return arg.get(); }
1146  const std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
1147  float get_likelihood() const { return likelihood; }
1148  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1149  void group_predicates(std::list<const Expr*>& scan_predicates,
1150  std::list<const Expr*>& join_predicates,
1151  std::list<const Expr*>& const_predicates) const override;
1152  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
1153  arg->collect_rte_idx(rte_idx_set);
1154  }
1156  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1157  colvar_set,
1158  bool include_agg) const override {
1159  arg->collect_column_var(colvar_set, include_agg);
1160  }
1161  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1162  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1163  return makeExpr<LikelihoodExpr>(arg->rewrite_with_targetlist(tlist), likelihood);
1164  }
1165  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1166  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1167  return makeExpr<LikelihoodExpr>(arg->rewrite_with_child_targetlist(tlist),
1168  likelihood);
1169  }
1170  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1171  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override {
1172  return makeExpr<LikelihoodExpr>(arg->rewrite_agg_to_var(tlist), likelihood);
1173  }
1174  bool operator==(const Expr& rhs) const override;
1175  std::string toString() const override;
1176  void find_expr(std::function<bool(const Expr*)> f,
1177  std::list<const Expr*>& expr_list) const override;
1178 
1179  private:
1180  std::shared_ptr<Analyzer::Expr> arg; // the argument to LIKELY, UNLIKELY
1181  float likelihood;
1182 };
1183 
1184 /*
1185  * @type AggExpr
1186  * @brief expression for builtin SQL aggregates.
1187  */
1188 class AggExpr : public Expr {
1189  public:
1191  SQLAgg a,
1192  std::shared_ptr<Analyzer::Expr> g,
1193  bool d,
1194  std::shared_ptr<Analyzer::Expr> e)
1195  : Expr(ti, true), aggtype(a), arg(g), is_distinct(d), arg1(e) {}
1197  SQLAgg a,
1198  Expr* g,
1199  bool d,
1200  std::shared_ptr<Analyzer::Expr> e,
1201  int idx)
1202  : Expr(SQLTypeInfo(t, g == nullptr ? true : g->get_type_info().get_notnull()), true)
1203  , aggtype(a)
1204  , arg(g)
1205  , is_distinct(d)
1206  , arg1(e) {}
1207  SQLAgg get_aggtype() const { return aggtype; }
1208  Expr* get_arg() const { return arg.get(); }
1209  std::shared_ptr<Analyzer::Expr> get_own_arg() const { return arg; }
1210  bool get_is_distinct() const { return is_distinct; }
1211  std::shared_ptr<Analyzer::Expr> get_arg1() const { return arg1; }
1212  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1213  void group_predicates(std::list<const Expr*>& scan_predicates,
1214  std::list<const Expr*>& join_predicates,
1215  std::list<const Expr*>& const_predicates) const override;
1216  void collect_rte_idx(std::set<int>& rte_idx_set) const override {
1217  if (arg) {
1218  arg->collect_rte_idx(rte_idx_set);
1219  }
1220  };
1222  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1223  colvar_set,
1224  bool include_agg) const override {
1225  if (include_agg && arg != nullptr) {
1226  arg->collect_column_var(colvar_set, include_agg);
1227  }
1228  }
1229  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1230  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1231  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1232  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1233  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1234  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1235  bool operator==(const Expr& rhs) const override;
1236  std::string toString() const override;
1237  void find_expr(std::function<bool(const Expr*)> f,
1238  std::list<const Expr*>& expr_list) const override;
1239 
1240  private:
1241  SQLAgg aggtype; // aggregate type: kAVG, kMIN, kMAX, kSUM, kCOUNT
1242  std::shared_ptr<Analyzer::Expr> arg; // argument to aggregate
1243  bool is_distinct; // true only if it is for COUNT(DISTINCT x)
1244  // APPROX_COUNT_DISTINCT error_rate, APPROX_QUANTILE quantile
1245  std::shared_ptr<Analyzer::Expr> arg1;
1246 };
1247 
1248 /*
1249  * @type CaseExpr
1250  * @brief the CASE-WHEN-THEN-ELSE expression
1251  */
1252 class CaseExpr : public Expr {
1253  public:
1255  bool has_agg,
1256  const std::list<std::pair<std::shared_ptr<Analyzer::Expr>,
1257  std::shared_ptr<Analyzer::Expr>>>& w,
1258  std::shared_ptr<Analyzer::Expr> e)
1259  : Expr(ti, has_agg), expr_pair_list(w), else_expr(e) {}
1260  const std::list<
1261  std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>&
1263  return expr_pair_list;
1264  }
1265  const Expr* get_else_expr() const { return else_expr.get(); }
1266  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1267  void check_group_by(
1268  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
1269  void group_predicates(std::list<const Expr*>& scan_predicates,
1270  std::list<const Expr*>& join_predicates,
1271  std::list<const Expr*>& const_predicates) const override;
1272  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1273  void collect_column_var(
1274  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1275  colvar_set,
1276  bool include_agg) const override;
1277  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1278  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1279  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1280  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1281  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1282  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1283  bool operator==(const Expr& rhs) const override;
1284  std::string toString() const override;
1285  void find_expr(std::function<bool(const Expr*)> f,
1286  std::list<const Expr*>& expr_list) const override;
1287  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) override;
1288  void get_domain(DomainSet& domain_set) const override;
1289 
1290  private:
1291  std::list<std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
1292  expr_pair_list; // a pair of expressions for each WHEN expr1 THEN expr2. expr1
1293  // must be of boolean type. all expr2's must be of compatible
1294  // types and will be promoted to the common type.
1295  std::shared_ptr<Analyzer::Expr> else_expr; // expression for ELSE. nullptr if omitted.
1296 };
1297 
1298 /*
1299  * @type ExtractExpr
1300  * @brief the EXTRACT expression
1301  */
1302 class ExtractExpr : public Expr {
1303  public:
1305  bool has_agg,
1306  ExtractField f,
1307  std::shared_ptr<Analyzer::Expr> e)
1308  : Expr(ti, has_agg), field_(f), from_expr_(e) {}
1309  ExtractField get_field() const { return field_; }
1310  const Expr* get_from_expr() const { return from_expr_.get(); }
1311  const std::shared_ptr<Analyzer::Expr> get_own_from_expr() const { return from_expr_; }
1312  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1313  void check_group_by(
1314  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
1315  void group_predicates(std::list<const Expr*>& scan_predicates,
1316  std::list<const Expr*>& join_predicates,
1317  std::list<const Expr*>& const_predicates) const override;
1318  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1319  void collect_column_var(
1320  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1321  colvar_set,
1322  bool include_agg) const override;
1323  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1324  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1325  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1326  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1327  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1328  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1329  bool operator==(const Expr& rhs) const override;
1330  std::string toString() const override;
1331  void find_expr(std::function<bool(const Expr*)> f,
1332  std::list<const Expr*>& expr_list) const override;
1333 
1334  private:
1336  std::shared_ptr<Analyzer::Expr> from_expr_;
1337 };
1338 
1339 /*
1340  * @type DateaddExpr
1341  * @brief the DATEADD expression
1342  */
1343 class DateaddExpr : public Expr {
1344  public:
1346  const DateaddField f,
1347  const std::shared_ptr<Analyzer::Expr> number,
1348  const std::shared_ptr<Analyzer::Expr> datetime)
1349  : Expr(ti, false)
1350  , field_(f)
1351  , number_(number)
1352  , datetime_(datetime)
1354  DateaddField get_field() const { return field_; }
1355  const Expr* get_number_expr() const { return number_.get(); }
1356  const Expr* get_datetime_expr() const { return datetime_.get(); }
1359  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1360  void check_group_by(
1361  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
1362  void group_predicates(std::list<const Expr*>& scan_predicates,
1363  std::list<const Expr*>& join_predicates,
1364  std::list<const Expr*>& const_predicates) const override;
1365  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1366  void collect_column_var(
1367  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1368  colvar_set,
1369  bool include_agg) const override;
1370  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1371  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1372  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1373  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1374  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1375  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1376  bool operator==(const Expr& rhs) const override;
1377  std::string toString() const override;
1378  void find_expr(std::function<bool(const Expr*)> f,
1379  std::list<const Expr*>& expr_list) const override;
1380 
1381  private:
1383  const std::shared_ptr<Analyzer::Expr> number_;
1384  const std::shared_ptr<Analyzer::Expr> datetime_;
1385  // if expr (i.e., column_var) of datetime has fixed encoding but is not casted
1386  // to nullable int64_t type before generating a code for this dateAdd expr,
1387  // we manually set this to deal with such case during the codegen
1389 };
1390 
1391 /*
1392  * @type DatediffExpr
1393  * @brief the DATEDIFF expression
1394  */
1395 class DatediffExpr : public Expr {
1396  public:
1398  const DatetruncField f,
1399  const std::shared_ptr<Analyzer::Expr> start,
1400  const std::shared_ptr<Analyzer::Expr> end)
1401  : Expr(ti, false), field_(f), start_(start), end_(end) {}
1402  DatetruncField get_field() const { return field_; }
1403  const Expr* get_start_expr() const { return start_.get(); }
1404  const Expr* get_end_expr() const { return end_.get(); }
1405  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1406  void check_group_by(
1407  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
1408  void group_predicates(std::list<const Expr*>& scan_predicates,
1409  std::list<const Expr*>& join_predicates,
1410  std::list<const Expr*>& const_predicates) const override;
1411  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1412  void collect_column_var(
1413  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1414  colvar_set,
1415  bool include_agg) const override;
1416  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1417  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1418  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1419  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1420  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1421  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1422  bool operator==(const Expr& rhs) const override;
1423  std::string toString() const override;
1424  void find_expr(std::function<bool(const Expr*)> f,
1425  std::list<const Expr*>& expr_list) const override;
1426 
1427  private:
1429  const std::shared_ptr<Analyzer::Expr> start_;
1430  const std::shared_ptr<Analyzer::Expr> end_;
1431 };
1432 
1433 /*
1434  * @type DatetruncExpr
1435  * @brief the DATE_TRUNC expression
1436  */
1437 class DatetruncExpr : public Expr {
1438  public:
1440  bool has_agg,
1441  DatetruncField f,
1442  std::shared_ptr<Analyzer::Expr> e)
1443  : Expr(ti, has_agg), field_(f), from_expr_(e) {}
1444  DatetruncField get_field() const { return field_; }
1445  const Expr* get_from_expr() const { return from_expr_.get(); }
1446  const std::shared_ptr<Analyzer::Expr> get_own_from_expr() const { return from_expr_; }
1447  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1448  void check_group_by(
1449  const std::list<std::shared_ptr<Analyzer::Expr>>& groupby) const override;
1450  void group_predicates(std::list<const Expr*>& scan_predicates,
1451  std::list<const Expr*>& join_predicates,
1452  std::list<const Expr*>& const_predicates) const override;
1453  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1454  void collect_column_var(
1455  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1456  colvar_set,
1457  bool include_agg) const override;
1458  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1459  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1460  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1461  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1462  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1463  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1464  bool operator==(const Expr& rhs) const override;
1465  std::string toString() const override;
1466  void find_expr(std::function<bool(const Expr*)> f,
1467  std::list<const Expr*>& expr_list) const override;
1468 
1469  private:
1471  std::shared_ptr<Analyzer::Expr> from_expr_;
1472 };
1473 
1479 class StringOper : public Expr {
1480  public:
1481  // Todo(todd): Set nullability based on literals too
1482 
1484 
1486  const std::vector<std::shared_ptr<Analyzer::Expr>>& args)
1487  : Expr(StringOper::get_return_type(kind, args)), kind_(kind), args_(args) {}
1488 
1490  const SQLTypeInfo& return_ti,
1491  const std::vector<std::shared_ptr<Analyzer::Expr>>& args)
1492  : Expr(return_ti), kind_(kind), args_(args) {}
1493 
1495  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
1496  const size_t min_args,
1497  const std::vector<OperandTypeFamily>& expected_type_families,
1498  const std::vector<std::string>& arg_names)
1499  : Expr(StringOper::get_return_type(kind, args)), kind_(kind), args_(args) {
1500  check_operand_types(min_args,
1501  expected_type_families,
1502  arg_names,
1503  false /* dict_encoded_cols_only */,
1504  !(kind == SqlStringOpKind::CONCAT ||
1505  kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
1506  }
1507 
1509  const SQLTypeInfo& return_ti,
1510  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
1511  const size_t min_args,
1512  const std::vector<OperandTypeFamily>& expected_type_families,
1513  const std::vector<std::string>& arg_names)
1514  : Expr(return_ti), kind_(kind), args_(args) {
1515  check_operand_types(min_args,
1516  expected_type_families,
1517  arg_names,
1518  false /* dict_encoded_cols_only */,
1519  !(kind == SqlStringOpKind::CONCAT ||
1520  kind == SqlStringOpKind::RCONCAT) /* cols_first_arg_only */);
1521  }
1522 
1524  const SQLTypeInfo& return_ti,
1525  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
1526  const std::vector<std::shared_ptr<Analyzer::Expr>>& chained_string_op_exprs)
1527  : Expr(return_ti)
1528  , kind_(kind)
1529  , args_(args)
1530  , chained_string_op_exprs_(chained_string_op_exprs) {}
1531 
1532  StringOper(const StringOper& other_string_oper)
1533  : Expr(other_string_oper.get_type_info()) {
1534  kind_ = other_string_oper.kind_;
1535  args_ = other_string_oper.args_;
1537  }
1538 
1539  StringOper(const std::shared_ptr<StringOper>& other_string_oper)
1540  : Expr(other_string_oper->get_type_info()) {
1541  kind_ = other_string_oper->kind_;
1542  args_ = other_string_oper->args_;
1543  chained_string_op_exprs_ = other_string_oper->chained_string_op_exprs_;
1544  }
1545 
1546  SqlStringOpKind get_kind() const { return kind_; }
1547 
1548  size_t getArity() const { return args_.size(); }
1549 
1550  size_t getLiteralsArity() const {
1551  size_t num_literals{0UL};
1552  for (const auto& arg : args_) {
1553  if (dynamic_cast<const Constant*>(arg.get())) {
1554  num_literals++;
1555  }
1556  }
1557  return num_literals;
1558  }
1559 
1560  size_t getNonLiteralsArity() const { return getArity() - getLiteralsArity(); }
1561 
1562  const Expr* getArg(const size_t i) const {
1563  CHECK_LT(i, args_.size());
1564  return args_[i].get();
1565  }
1566 
1567  std::shared_ptr<Analyzer::Expr> getOwnArg(const size_t i) const {
1568  CHECK_LT(i, args_.size());
1569  return args_[i];
1570  }
1571 
1572  std::vector<std::shared_ptr<Analyzer::Expr>> getOwnArgs() const { return args_; }
1573 
1574  std::vector<std::shared_ptr<Analyzer::Expr>> getChainedStringOpExprs() const {
1575  return chained_string_op_exprs_;
1576  }
1577 
1579  const auto& return_ti = get_type_info();
1580  if (return_ti.is_none_encoded_string() ||
1581  (return_ti.is_dict_encoded_string() &&
1582  return_ti.getStringDictKey().isTransientDict())) {
1583  return true;
1584  }
1585 
1586  // Anything that returns the transient dictionary by definition
1587  // (see StringOper::get_return_type) requires per-row translation,
1588  // but there is also a path with string->numeric functions (the output is
1589  // not a string) where we need to see if any of the inputs are none-encoded
1590  // or transient dictionary encoded, in which case we also need to do per-row
1591  // translation. The handling of that condition follows below.
1592 
1593  size_t num_var_str_args{0};
1594  for (const auto& arg : args_) {
1595  const auto arg_is_const = dynamic_cast<const Analyzer::Constant*>(arg.get());
1596  if (arg_is_const) {
1597  continue;
1598  }
1599  const auto& arg_ti = arg->get_type_info();
1600  if (arg_ti.is_none_encoded_string() ||
1601  (arg_ti.is_dict_encoded_string() &&
1602  arg_ti.getStringDictKey().isTransientDict())) {
1603  return true;
1604  }
1605  num_var_str_args++;
1606  }
1607  return num_var_str_args > 1UL;
1608  }
1609 
1610  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
1611 
1612  void collect_column_var(
1613  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
1614  colvar_set,
1615  bool include_agg) const override;
1616 
1617  bool hasNoneEncodedTextArg() const {
1618  if (args_.empty()) {
1619  return false;
1620  }
1621  const auto& arg0_ti = args_[0]->get_type_info();
1622  if (!arg0_ti.is_string()) {
1623  return false;
1624  }
1625  if (arg0_ti.is_none_encoded_string()) {
1626  return true;
1627  }
1628  CHECK(arg0_ti.is_dict_encoded_string());
1629  return arg0_ti.getStringDictKey().isTransientDict();
1630  }
1631 
1639  bool hasSingleDictEncodedColInput() const;
1640 
1641  std::vector<size_t> getLiteralArgIndexes() const;
1642 
1643  using LiteralArgMap = std::map<size_t, std::pair<SQLTypes, Datum>>;
1644 
1645  LiteralArgMap getLiteralArgs() const;
1646 
1647  std::shared_ptr<Analyzer::Expr> rewrite_with_targetlist(
1648  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1649 
1650  std::shared_ptr<Analyzer::Expr> rewrite_with_child_targetlist(
1651  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1652 
1653  std::shared_ptr<Analyzer::Expr> rewrite_agg_to_var(
1654  const std::vector<std::shared_ptr<TargetEntry>>& tlist) const override;
1655 
1656  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1657 
1658  void group_predicates(std::list<const Expr*>& scan_predicates,
1659  std::list<const Expr*>& join_predicates,
1660  std::list<const Expr*>& const_predicates) const override;
1661 
1662  bool operator==(const Expr& rhs) const override;
1663 
1664  std::string toString() const override;
1665 
1666  void find_expr(std::function<bool(const Expr*)> f,
1667  std::list<const Expr*>& expr_list) const override;
1668 
1669  virtual size_t getMinArgs() const {
1670  CHECK(false);
1671  return {};
1672  }
1673  virtual std::vector<OperandTypeFamily> getExpectedTypeFamilies() const {
1674  CHECK(false);
1675  return {};
1676  }
1677  virtual std::vector<std::string> getArgNames() const {
1678  CHECK(false);
1679  return {};
1680  }
1681 
1682  private:
1684  const SqlStringOpKind kind,
1685  const std::vector<std::shared_ptr<Analyzer::Expr>>& args);
1686 
1687  void check_operand_types(const size_t min_args,
1688  const std::vector<OperandTypeFamily>& expected_type_families,
1689  const std::vector<std::string>& arg_names,
1690  const bool dict_encoded_cols_only = false,
1691  const bool cols_first_arg_only = true) const;
1692 
1694  std::vector<std::shared_ptr<Analyzer::Expr>> args_;
1695  std::vector<std::shared_ptr<Analyzer::Expr>> chained_string_op_exprs_;
1696 };
1697 
1698 class LowerStringOper : public StringOper {
1699  public:
1700  LowerStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
1702  {operand},
1703  getMinArgs(),
1706 
1707  LowerStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1709  operands,
1710  getMinArgs(),
1712  getArgNames()) {}
1713 
1714  LowerStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1715  : StringOper(string_oper) {}
1716 
1717  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1718 
1719  size_t getMinArgs() const override { return 1UL; }
1720 
1721  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1723  }
1724 
1725  std::vector<std::string> getArgNames() const override { return {"operand"}; }
1726 };
1727 class UpperStringOper : public StringOper {
1728  public:
1729  UpperStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
1731  {operand},
1732  getMinArgs(),
1735 
1736  UpperStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1738  operands,
1739  getMinArgs(),
1741  getArgNames()) {}
1742 
1743  UpperStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1744  : StringOper(string_oper) {}
1745 
1746  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1747 
1748  size_t getMinArgs() const override { return 1UL; }
1749 
1750  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1752  }
1753 
1754  std::vector<std::string> getArgNames() const override { return {"operand"}; }
1755 };
1756 
1758  public:
1759  InitCapStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
1761  {operand},
1762  getMinArgs(),
1765 
1766  InitCapStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1768  operands,
1769  getMinArgs(),
1771  getArgNames()) {}
1772 
1773  InitCapStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1774  : StringOper(string_oper) {}
1775 
1776  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1777 
1778  size_t getMinArgs() const override { return 1UL; }
1779 
1780  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1782  }
1783  std::vector<std::string> getArgNames() const override { return {"operand"}; }
1784 };
1785 
1787  public:
1788  ReverseStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
1790  {operand},
1791  getMinArgs(),
1794 
1795  ReverseStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1797  operands,
1798  getMinArgs(),
1800  getArgNames()) {}
1801 
1802  ReverseStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1803  : StringOper(string_oper) {}
1804 
1805  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1806 
1807  size_t getMinArgs() const override { return 1UL; }
1808 
1809  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1811  }
1812  std::vector<std::string> getArgNames() const override { return {"operand"}; }
1813 };
1814 
1816  public:
1817  RepeatStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
1818  const std::shared_ptr<Analyzer::Expr>& num_repeats)
1820  {operand, num_repeats},
1821  getMinArgs(),
1824 
1825  RepeatStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1827  operands,
1828  getMinArgs(),
1830  getArgNames()) {}
1831 
1832  RepeatStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1833  : StringOper(string_oper) {}
1834 
1835  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1836 
1837  size_t getMinArgs() const override { return 2UL; }
1838 
1839  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1841  }
1842  std::vector<std::string> getArgNames() const override {
1843  return {"operand", "num_repeats"};
1844  }
1845 };
1846 
1848  public:
1849  ConcatStringOper(const std::shared_ptr<Analyzer::Expr>& left_operand,
1850  const std::shared_ptr<Analyzer::Expr>& right_operand)
1851  : StringOper(
1852  ConcatStringOper::get_concat_ordered_kind({left_operand, right_operand}),
1853  ConcatStringOper::normalize_operands({left_operand, right_operand}),
1854  getMinArgs(),
1857 
1858  ConcatStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1861  getMinArgs(),
1863  getArgNames()) {}
1864 
1865  ConcatStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1866  : StringOper(string_oper) {}
1867 
1868  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1869 
1870  size_t getMinArgs() const override { return 2UL; }
1871 
1872  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1874  }
1875  std::vector<std::string> getArgNames() const override {
1876  return {"left operand", "right operand"};
1877  }
1878 
1879  private:
1881  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands);
1882 
1883  static std::vector<std::shared_ptr<Analyzer::Expr>> normalize_operands(
1884  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands);
1885 };
1886 
1887 class PadStringOper : public StringOper {
1888  public:
1889  PadStringOper(const SqlStringOpKind pad_op_kind,
1890  const std::shared_ptr<Analyzer::Expr>& operand,
1891  const std::shared_ptr<Analyzer::Expr>& padded_length,
1892  const std::shared_ptr<Analyzer::Expr>& padding_str)
1894  {operand, padded_length, padding_str},
1895  getMinArgs(),
1898 
1899  PadStringOper(const SqlStringOpKind pad_op_kind,
1900  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1902  operands,
1903  getMinArgs(),
1905  getArgNames()) {}
1906 
1907  PadStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1908  : StringOper(string_oper) {}
1909 
1910  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1911 
1912  size_t getMinArgs() const override { return 3UL; }
1913 
1914  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1918  }
1919  std::vector<std::string> getArgNames() const override {
1920  return {"operand", "padded length", "padding string"};
1921  }
1922 
1923  private:
1925 };
1926 
1927 class TrimStringOper : public StringOper {
1928  public:
1929  TrimStringOper(const SqlStringOpKind trim_op_kind,
1930  const std::shared_ptr<Analyzer::Expr>& operand,
1931  const std::shared_ptr<Analyzer::Expr>& trim_chars)
1933  {operand, trim_chars},
1934  getMinArgs(),
1937 
1938  TrimStringOper(const SqlStringOpKind trim_op_kind,
1939  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
1940  : StringOper(TrimStringOper::get_and_validate_trim_op_kind(trim_op_kind, operands),
1941  TrimStringOper::normalize_operands(operands, trim_op_kind),
1942  getMinArgs(),
1944  getArgNames()) {}
1945 
1946  TrimStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
1947  : StringOper(string_oper) {}
1948 
1949  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
1950 
1951  size_t getMinArgs() const override { return 2UL; }
1952 
1953  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
1955  }
1956  std::vector<std::string> getArgNames() const override {
1957  return {"operand", "trim_chars"};
1958  }
1959 
1960  private:
1962  if (!(trim_op_kind == SqlStringOpKind::TRIM ||
1963  trim_op_kind == SqlStringOpKind::LTRIM ||
1964  trim_op_kind == SqlStringOpKind::RTRIM)) {
1965  // Arguably should CHECK here
1966  throw std::runtime_error("Invalid trim type supplied to TRIM operator");
1967  }
1968  return trim_op_kind;
1969  }
1970 
1972  const SqlStringOpKind trim_op_kind_maybe,
1973  const std::vector<std::shared_ptr<Analyzer::Expr>>& args);
1974 
1975  static std::vector<std::shared_ptr<Analyzer::Expr>> normalize_operands(
1976  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands,
1977  const SqlStringOpKind string_op_kind);
1978 };
1979 
1981  public:
1982  SubstringStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
1983  const std::shared_ptr<Analyzer::Expr>& start_pos)
1985  {operand, start_pos},
1986  getMinArgs(),
1989 
1990  SubstringStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
1991  const std::shared_ptr<Analyzer::Expr>& start_pos,
1992  const std::shared_ptr<Analyzer::Expr>& length)
1994  {operand, start_pos, length},
1995  getMinArgs(),
1998 
1999  SubstringStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2001  operands,
2002  getMinArgs(),
2004  getArgNames()) {}
2005 
2006  SubstringStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2007  : StringOper(string_oper) {}
2008 
2009  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2010 
2011  size_t getMinArgs() const override { return 2UL; }
2012 
2013  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2016  OperandTypeFamily::INT_FAMILY};
2017  }
2018  std::vector<std::string> getArgNames() const override {
2019  return {"operand", "start position", "substring length"};
2020  }
2021 };
2022 
2024  public:
2025  OverlayStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2026  const std::shared_ptr<Analyzer::Expr>& replacing_str,
2027  const std::shared_ptr<Analyzer::Expr>& start_pos)
2029  {operand, replacing_str, start_pos},
2030  getMinArgs(),
2033 
2034  OverlayStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2035  const std::shared_ptr<Analyzer::Expr>& replacing_str,
2036  const std::shared_ptr<Analyzer::Expr>& start_pos,
2037  const std::shared_ptr<Analyzer::Expr>& replacing_length)
2039  {operand, replacing_str, start_pos, replacing_length},
2040  getMinArgs(),
2043 
2044  OverlayStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2045  : StringOper(string_oper) {}
2046 
2047  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2048 
2049  OverlayStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2051  operands,
2052  getMinArgs(),
2054  getArgNames()) {}
2055 
2056  size_t getMinArgs() const override { return 3UL; }
2057 
2058  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2062  OperandTypeFamily::INT_FAMILY};
2063  }
2064  std::vector<std::string> getArgNames() const override {
2065  return {"operand", "replacing string", "start position", "replacing length"};
2066  }
2067 };
2068 
2070  public:
2071  ReplaceStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2072  const std::shared_ptr<Analyzer::Expr>& search_pattern,
2073  const std::shared_ptr<Analyzer::Expr>& replacing_str)
2075  {operand, search_pattern, replacing_str},
2076  getMinArgs(),
2079 
2080  ReplaceStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2082  operands,
2083  getMinArgs(),
2085  getArgNames()) {}
2086 
2087  ReplaceStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2088  : StringOper(string_oper) {}
2089 
2090  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2091 
2092  size_t getMinArgs() const override { return 3UL; }
2093 
2094  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2097  OperandTypeFamily::STRING_FAMILY};
2098  }
2099  std::vector<std::string> getArgNames() const override {
2100  return {"operand", "search pattern", "replacing string"};
2101  }
2102 };
2103 
2105  public:
2106  SplitPartStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2107  const std::shared_ptr<Analyzer::Expr>& delimiter,
2108  const std::shared_ptr<Analyzer::Expr>& split_index)
2110  {operand, delimiter, split_index},
2111  getMinArgs(),
2114 
2115  SplitPartStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2117  operands,
2118  getMinArgs(),
2120  getArgNames()) {}
2121 
2122  SplitPartStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2123  : StringOper(string_oper) {}
2124 
2125  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2126 
2127  size_t getMinArgs() const override { return 3UL; }
2128 
2129  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2133  }
2134  std::vector<std::string> getArgNames() const override {
2135  return {"operand", "delimiter", "split index"};
2136  }
2137 };
2138 
2140  public:
2141  RegexpReplaceStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2142  const std::shared_ptr<Analyzer::Expr>& regex_pattern,
2143  const std::shared_ptr<Analyzer::Expr>& replacing_str,
2144  const std::shared_ptr<Analyzer::Expr>& start_pos,
2145  const std::shared_ptr<Analyzer::Expr>& occurrence,
2146  const std::shared_ptr<Analyzer::Expr>& regex_params)
2147  : StringOper(
2149  {operand, regex_pattern, replacing_str, start_pos, occurrence, regex_params},
2150  getMinArgs(),
2153 
2154  RegexpReplaceStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2156  operands,
2157  getMinArgs(),
2159  getArgNames()) {}
2160 
2161  RegexpReplaceStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2162  : StringOper(string_oper) {}
2163 
2164  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2165 
2166  size_t getMinArgs() const override { return 6UL; }
2167 
2168  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2174  OperandTypeFamily::STRING_FAMILY};
2175  }
2176  std::vector<std::string> getArgNames() const override {
2177  return {"operand",
2178  "regex pattern",
2179  "replacing string",
2180  "start position",
2181  "occurrence",
2182  "regex parameters"};
2183  }
2184 };
2185 
2187  public:
2188  RegexpSubstrStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2189  const std::shared_ptr<Analyzer::Expr>& regex_pattern,
2190  const std::shared_ptr<Analyzer::Expr>& start_pos,
2191  const std::shared_ptr<Analyzer::Expr>& occurrence,
2192  const std::shared_ptr<Analyzer::Expr>& regex_params,
2193  const std::shared_ptr<Analyzer::Expr>& sub_match_group_idx)
2195  {operand,
2196  regex_pattern,
2197  start_pos,
2198  occurrence,
2199  regex_params,
2200  sub_match_group_idx},
2201  getMinArgs(),
2204 
2205  RegexpSubstrStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2207  operands,
2208  getMinArgs(),
2210  getArgNames()) {}
2211 
2212  RegexpSubstrStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2213  : StringOper(string_oper) {}
2214 
2215  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2216 
2217  size_t getMinArgs() const override { return 6UL; }
2218 
2219  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2225  OperandTypeFamily::INT_FAMILY};
2226  }
2227  std::vector<std::string> getArgNames() const override {
2228  return {"operand",
2229  "regex pattern",
2230  "start position",
2231  "occurrence",
2232  "regex parameters",
2233  "sub-match group index"};
2234  }
2235 };
2237  public:
2238  JsonValueStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
2239  const std::shared_ptr<Analyzer::Expr>& json_path)
2241  {operand, json_path},
2242  getMinArgs(),
2245 
2246  JsonValueStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2248  operands,
2249  getMinArgs(),
2251  getArgNames()) {}
2252 
2253  JsonValueStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2254  : StringOper(string_oper) {}
2255 
2256  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2257 
2258  size_t getMinArgs() const override { return 2UL; }
2259 
2260  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2262  }
2263  std::vector<std::string> getArgNames() const override {
2264  return {"operand", "JSON path"};
2265  }
2266 };
2267 
2269  public:
2270  Base64EncodeStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
2272  {operand},
2273  getMinArgs(),
2276 
2277  Base64EncodeStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2279  operands,
2280  getMinArgs(),
2282  getArgNames()) {}
2283 
2284  Base64EncodeStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2285  : StringOper(string_oper) {}
2286 
2287  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2288 
2289  size_t getMinArgs() const override { return 1UL; }
2290 
2291  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2293  }
2294  std::vector<std::string> getArgNames() const override { return {"operand"}; }
2295 };
2296 
2298  public:
2299  Base64DecodeStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
2301  {operand},
2302  getMinArgs(),
2305 
2306  Base64DecodeStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2308  operands,
2309  getMinArgs(),
2311  getArgNames()) {}
2312 
2313  Base64DecodeStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2314  : StringOper(string_oper) {}
2315 
2316  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2317 
2318  size_t getMinArgs() const override { return 1UL; }
2319 
2320  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2322  }
2323  std::vector<std::string> getArgNames() const override { return {"operand"}; }
2324 };
2325 
2327  public:
2328  TryStringCastOper(const SQLTypeInfo& ti, const std::shared_ptr<Analyzer::Expr>& operand)
2330  ti,
2331  {operand},
2332  getMinArgs(),
2335 
2337  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2339  ti,
2340  operands,
2341  getMinArgs(),
2343  getArgNames()) {}
2344 
2345  TryStringCastOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2346  : StringOper(string_oper) {}
2347 
2348  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2349 
2350  size_t getMinArgs() const override { return 1UL; }
2351 
2352  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2354  }
2355  std::vector<std::string> getArgNames() const override { return {"operand"}; }
2356 };
2357 
2359  public:
2360  PositionStringOper(const std::shared_ptr<Analyzer::Expr>& search_str,
2361  const std::shared_ptr<Analyzer::Expr>& source_str,
2362  const std::shared_ptr<Analyzer::Expr>& start_offset)
2365  {source_str, search_str, start_offset},
2366  getMinArgs(),
2369 
2370  PositionStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
2374  getMinArgs(),
2376  getArgNames()) {}
2377 
2378  PositionStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
2379  : StringOper(string_oper) {}
2380 
2381  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2382 
2383  size_t getMinArgs() const override { return 2UL; }
2384 
2385  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
2389  }
2390  std::vector<std::string> getArgNames() const override {
2391  return {"search string", "source string", "start position"};
2392  }
2393 
2394  private:
2395  static std::vector<std::shared_ptr<Analyzer::Expr>> normalize_operands(
2396  const std::vector<std::shared_ptr<Analyzer::Expr>>& operands);
2397 };
2398 
2399 class FunctionOper : public Expr {
2400  public:
2402  const std::string& name,
2403  const std::vector<std::shared_ptr<Analyzer::Expr>>& args)
2404  : Expr(ti, false), name_(name), args_(args) {}
2405 
2406  std::string getName() const { return name_; }
2407 
2408  size_t getArity() const { return args_.size(); }
2409 
2410  const Analyzer::Expr* getArg(const size_t i) const {
2411  CHECK_LT(i, args_.size());
2412  return args_[i].get();
2413  }
2414 
2415  std::shared_ptr<Analyzer::Expr> getOwnArg(const size_t i) const {
2416  CHECK_LT(i, args_.size());
2417  return args_[i];
2418  }
2419 
2420  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2421  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
2422  void collect_column_var(
2423  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
2424  colvar_set,
2425  bool include_agg) const override;
2426  void find_expr(std::function<bool(const Expr*)> f,
2427  std::list<const Expr*>& expr_list) const override;
2428 
2429  bool operator==(const Expr& rhs) const override;
2430  std::string toString() const override;
2431 
2432  private:
2433  const std::string name_;
2434  const std::vector<std::shared_ptr<Analyzer::Expr>> args_;
2435 };
2436 
2438  public:
2440  const SQLTypeInfo& ti,
2441  const std::string& name,
2442  const std::vector<std::shared_ptr<Analyzer::Expr>>& args)
2443  : FunctionOper(ti, name, args) {}
2444 
2445  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2446 
2447  bool operator==(const Expr& rhs) const override;
2448 };
2449 
2450 /*
2451  * @type OffsetInFragment
2452  * @brief The offset of a row in the current fragment. To be used by updates.
2453  */
2454 class OffsetInFragment : public Expr {
2455  public:
2457 
2458  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2459 
2460  bool operator==(const Expr& rhs) const override;
2461  std::string toString() const override;
2462 };
2463 
2464 /*
2465  * @type OrderEntry
2466  * @brief represents an entry in ORDER BY clause.
2467  */
2468 struct OrderEntry {
2469  OrderEntry(int t, bool d, bool nf) : tle_no(t), is_desc(d), nulls_first(nf){};
2471  std::string toString() const;
2472  void print() const { std::cout << toString(); }
2473  int tle_no; /* targetlist entry number: 1-based */
2474  bool is_desc; /* true if order is DESC */
2475  bool nulls_first; /* true if nulls are ordered first. otherwise last. */
2476 };
2477 
2478 /*
2479  * @type WindowFrame
2480  * @brief A window frame bound.
2481  */
2482 class WindowFrame : public Expr {
2483  public:
2485  const std::shared_ptr<Analyzer::Expr> bound_expr)
2486  : Expr(SQLTypeInfo(kVOID)), bound_type_(bound_type), bound_expr_(bound_expr) {}
2487 
2489 
2490  const Analyzer::Expr* getBoundExpr() const {
2491  CHECK(bound_expr_);
2492  return bound_expr_.get();
2493  }
2494 
2496  if (bound_expr_) {
2497  const auto bound_ti = bound_expr_->get_type_info();
2498  return bound_ti.is_date() || bound_ti.is_timestamp();
2499  }
2500  return false;
2501  }
2502 
2503  bool isCurrentRowBound() const {
2505  }
2506 
2507  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2508 
2509  bool operator==(const Expr& rhs) const override;
2510 
2511  std::string toString() const override;
2512 
2513  private:
2515  const std::shared_ptr<Analyzer::Expr> bound_expr_;
2516 };
2517 
2518 /*
2519  * @type WindowFunction
2520  * @brief A window function.
2521  */
2522 class WindowFunction : public Expr {
2523  public:
2524  enum class FrameBoundType { NONE, ROW, RANGE };
2525  static constexpr std::array<SqlWindowFunctionKind, 11> FRAMING_ALLOWED_WINDOW_FUNCS{
2537  static constexpr std::array<SqlWindowFunctionKind, 8>
2547  static constexpr std::array<SqlWindowFunctionKind, 3> REQUIRE_HASH_TABLE_FOR_FRAMING{
2551 
2553  const SqlWindowFunctionKind kind,
2554  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
2555  const std::vector<std::shared_ptr<Analyzer::Expr>>& partition_keys,
2556  const std::vector<std::shared_ptr<Analyzer::Expr>>& order_keys,
2557  const FrameBoundType frame_bound_type,
2558  const std::shared_ptr<Expr> frame_start_bound,
2559  const std::shared_ptr<Expr> frame_end_bound,
2560  const std::vector<OrderEntry>& collation)
2561  : Expr(ti)
2562  , kind_(kind)
2563  , args_(args)
2564  , partition_keys_(partition_keys)
2565  , order_keys_(order_keys)
2566  , frame_bound_type_(frame_bound_type)
2567  , frame_start_bound_(frame_start_bound)
2568  , frame_end_bound_(frame_end_bound)
2569  , collation_(collation){};
2570 
2571  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2572 
2573  bool operator==(const Expr& rhs) const override;
2574  std::string toString() const override;
2575 
2577 
2578  const std::vector<std::shared_ptr<Analyzer::Expr>>& getArgs() const { return args_; }
2579 
2580  const std::vector<std::shared_ptr<Analyzer::Expr>>& getPartitionKeys() const {
2581  return partition_keys_;
2582  }
2583 
2584  const std::vector<std::shared_ptr<Analyzer::Expr>>& getOrderKeys() const {
2585  return order_keys_;
2586  }
2587 
2589  std::shared_ptr<WindowFrame> frame_start_bound =
2590  std::dynamic_pointer_cast<WindowFrame>(frame_start_bound_);
2591  CHECK(frame_start_bound);
2592  return frame_start_bound.get();
2593  }
2594 
2596  std::shared_ptr<WindowFrame> frame_end_bound =
2597  std::dynamic_pointer_cast<WindowFrame>(frame_end_bound_);
2598  CHECK(frame_end_bound);
2599  return frame_end_bound.get();
2600  }
2601 
2602  const std::vector<OrderEntry>& getCollation() const { return collation_; }
2603 
2605  return frame_bound_type_;
2606  }
2607 
2609 
2611 
2612  bool hasFraming() const {
2615  }
2616 
2618  return std::any_of(
2621  [kind](SqlWindowFunctionKind target_kind) { return kind == target_kind; });
2622  }
2623 
2625  return std::any_of(
2628  [this](SqlWindowFunctionKind target_kind) { return kind_ == target_kind; });
2629  }
2631  return std::any_of(
2634  [this](SqlWindowFunctionKind target_kind) { return kind_ == target_kind; });
2635  }
2636 
2637  private:
2639  const std::vector<std::shared_ptr<Analyzer::Expr>> args_;
2640  const std::vector<std::shared_ptr<Analyzer::Expr>> partition_keys_;
2641  const std::vector<std::shared_ptr<Analyzer::Expr>> order_keys_;
2643  const std::shared_ptr<Analyzer::Expr> frame_start_bound_;
2644  const std::shared_ptr<Analyzer::Expr> frame_end_bound_;
2645  const std::vector<OrderEntry> collation_;
2646 };
2647 
2648 /*
2649  * @type ArrayExpr
2650  * @brief Corresponds to ARRAY[] statements in SQL
2651  */
2652 
2653 class ArrayExpr : public Expr {
2654  public:
2655  ArrayExpr(SQLTypeInfo const& array_ti,
2656  ExpressionPtrVector const& array_exprs,
2657  bool is_null = false,
2658  bool local_alloc = false)
2659  : Expr(array_ti)
2660  , contained_expressions_(array_exprs)
2661  , local_alloc_(local_alloc)
2662  , is_null_(is_null) {}
2663 
2664  Analyzer::ExpressionPtr deep_copy() const override;
2665  std::string toString() const override;
2666  bool operator==(Expr const& rhs) const override;
2667  size_t getElementCount() const { return contained_expressions_.size(); }
2668  bool isLocalAlloc() const { return local_alloc_; }
2669  bool isNull() const { return is_null_; }
2670 
2671  const Analyzer::Expr* getElement(const size_t i) const {
2672  CHECK_LT(i, contained_expressions_.size());
2673  return contained_expressions_[i].get();
2674  }
2675 
2676  void collect_rte_idx(std::set<int>& rte_idx_set) const override;
2677  void collect_column_var(
2678  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
2679  colvar_set,
2680  bool include_agg) const override;
2681 
2682  private:
2685  bool is_null_; // constant is NULL
2686 };
2687 
2688 /*
2689  * @type GeoUOper
2690  * @brief Geo unary operation
2691  */
2692 class GeoUOper : public Expr {
2693  public:
2695  const SQLTypeInfo& ti,
2696  const SQLTypeInfo& ti0,
2697  const std::vector<std::shared_ptr<Analyzer::Expr>>& args)
2698  : Expr(ti), op_(op), ti0_(ti0), args0_(args){};
2699 
2700  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2701 
2702  bool operator==(const Expr& rhs) const override;
2703  std::string toString() const override;
2704 
2706  const SQLTypeInfo getTypeInfo0() const { return ti0_; }
2707  const std::vector<std::shared_ptr<Analyzer::Expr>>& getArgs0() const { return args0_; }
2708 
2709  private:
2711  SQLTypeInfo ti0_; // Type of geo input 0 (or geo output)
2712  const std::vector<std::shared_ptr<Analyzer::Expr>> args0_;
2713 };
2714 
2715 /*
2716  * @type GeoBinOper
2717  * @brief Geo binary operation
2718  */
2719 class GeoBinOper : public Expr {
2720  public:
2722  const SQLTypeInfo& ti,
2723  const SQLTypeInfo& ti0,
2724  const SQLTypeInfo& ti1,
2725  const std::vector<std::shared_ptr<Analyzer::Expr>>& args0,
2726  const std::vector<std::shared_ptr<Analyzer::Expr>>& args1)
2727  : Expr(ti), op_(op), ti0_(ti0), ti1_(ti1), args0_(args0), args1_(args1){};
2728 
2729  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2730 
2731  bool operator==(const Expr& rhs) const override;
2732  std::string toString() const override;
2733 
2735  const SQLTypeInfo getTypeInfo0() const { return ti0_; }
2736  const SQLTypeInfo getTypeInfo1() const { return ti1_; }
2737  const std::vector<std::shared_ptr<Analyzer::Expr>>& getArgs0() const { return args0_; }
2738  const std::vector<std::shared_ptr<Analyzer::Expr>>& getArgs1() const { return args1_; }
2739 
2740  private:
2742  SQLTypeInfo ti0_; // Type of geo input 0 (or geo output)
2743  SQLTypeInfo ti1_; // Type of geo input 1
2744  const std::vector<std::shared_ptr<Analyzer::Expr>> args0_;
2745  const std::vector<std::shared_ptr<Analyzer::Expr>> args1_;
2746 };
2747 
2748 /*
2749  * @type TargetEntry
2750  * @brief Target list defines a relational projection. It is a list of TargetEntry's.
2751  */
2753  public:
2754  TargetEntry(const std::string& n, std::shared_ptr<Analyzer::Expr> e, bool u)
2755  : resname(n), expr(e), unnest(u) {}
2756  virtual ~TargetEntry() {}
2757  const std::string& get_resname() const { return resname; }
2758  void set_resname(const std::string& name) { resname = name; }
2759  Expr* get_expr() const { return expr.get(); }
2760  std::shared_ptr<Expr> get_own_expr() const { return expr; }
2761  void set_expr(std::shared_ptr<Analyzer::Expr> e) { expr = e; }
2762  bool get_unnest() const { return unnest; }
2763  std::string toString() const;
2764  void print() const { std::cout << toString(); }
2765 
2766  private:
2767  std::string resname; // alias name, e.g., SELECT salary + bonus AS compensation,
2768  std::shared_ptr<Analyzer::Expr> expr; // expression to evaluate for the value
2769  bool unnest; // unnest a collection type
2770 };
2771 
2772 class RangeTableEntry;
2773 
2774 /*
2775  * @type Query
2776  * @brief parse tree for a query
2777  */
2778 class Query {
2779  public:
2781  : is_distinct(false)
2782  , where_predicate(nullptr)
2783  , having_predicate(nullptr)
2784  , order_by(nullptr)
2785  , next_query(nullptr)
2786  , is_unionall(false)
2787  , stmt_type(kSELECT)
2788  , num_aggs(0)
2789  , result_table_id(0)
2790  , limit(0)
2791  , offset(0) {}
2792  virtual ~Query();
2793  bool get_is_distinct() const { return is_distinct; }
2794  int get_num_aggs() const { return num_aggs; }
2795  const std::vector<std::shared_ptr<TargetEntry>>& get_targetlist() const {
2796  return targetlist;
2797  }
2798  std::vector<std::shared_ptr<TargetEntry>>& get_targetlist_nonconst() {
2799  return targetlist;
2800  }
2801  const std::vector<std::vector<std::shared_ptr<TargetEntry>>>& get_values_lists() const {
2802  return values_lists;
2803  }
2804  std::vector<std::vector<std::shared_ptr<TargetEntry>>>& get_values_lists() {
2805  return values_lists;
2806  }
2807  const std::vector<RangeTableEntry*>& get_rangetable() const { return rangetable; }
2808  const Expr* get_where_predicate() const { return where_predicate.get(); }
2809  const std::list<std::shared_ptr<Analyzer::Expr>>& get_group_by() const {
2810  return group_by;
2811  };
2812  const Expr* get_having_predicate() const { return having_predicate.get(); }
2813  const std::list<OrderEntry>* get_order_by() const { return order_by; }
2814  const Query* get_next_query() const { return next_query; }
2816  bool get_is_unionall() const { return is_unionall; }
2817  int get_result_table_id() const { return result_table_id; }
2818  const std::list<int>& get_result_col_list() const { return result_col_list; }
2819  void set_result_col_list(const std::list<int>& col_list) { result_col_list = col_list; }
2820  void set_result_table_id(int id) { result_table_id = id; }
2821  void set_is_distinct(bool d) { is_distinct = d; }
2822  void set_where_predicate(std::shared_ptr<Analyzer::Expr> p) { where_predicate = p; }
2823  void set_group_by(std::list<std::shared_ptr<Analyzer::Expr>>& g) { group_by = g; }
2824  void set_having_predicate(std::shared_ptr<Analyzer::Expr> p) { having_predicate = p; }
2825  void set_order_by(std::list<OrderEntry>* o) { order_by = o; }
2826  void set_next_query(Query* q) { next_query = q; }
2827  void set_is_unionall(bool u) { is_unionall = u; }
2829  void set_num_aggs(int a) { num_aggs = a; }
2830  int get_rte_idx(const std::string& range_var_name) const;
2831  RangeTableEntry* get_rte(int rte_idx) const { return rangetable[rte_idx]; }
2832  void add_rte(RangeTableEntry* rte);
2833  void add_tle(std::shared_ptr<TargetEntry> tle) { targetlist.push_back(tle); }
2834  int64_t get_limit() const { return limit; }
2835  void set_limit(int64_t l) { limit = l; }
2836  int64_t get_offset() const { return offset; }
2837  void set_offset(int64_t o) { offset = o; }
2838 
2839  private:
2840  bool is_distinct; // true only if SELECT DISTINCT
2841  std::vector<std::shared_ptr<TargetEntry>> targetlist; // represents the SELECT clause
2842  std::vector<RangeTableEntry*> rangetable; // represents the FROM clause for SELECT. For
2843  // INSERT, DELETE, UPDATE the result table is
2844  // always the first entry in rangetable.
2845  std::shared_ptr<Analyzer::Expr> where_predicate; // represents the WHERE clause
2846  std::list<std::shared_ptr<Analyzer::Expr>> group_by; // represents the GROUP BY clause
2847  std::shared_ptr<Analyzer::Expr> having_predicate; // represents the HAVING clause
2848  std::list<OrderEntry>* order_by; // represents the ORDER BY clause
2849  Query* next_query; // the next query to UNION
2850  bool is_unionall; // true only if it is UNION ALL
2852  int num_aggs; // number of aggregate functions in query
2853  int result_table_id; // for INSERT statements only
2854  std::list<int> result_col_list; // for INSERT statement only
2855  std::vector<std::vector<std::shared_ptr<TargetEntry>>> values_lists; // for INSERT only
2856  int64_t limit; // row count for LIMIT clause. 0 means ALL
2857  int64_t offset; // offset in OFFSET clause. 0 means no offset.
2858 };
2859 
2860 class GeoExpr : public Expr {
2861  public:
2862  GeoExpr(const SQLTypeInfo& ti) : Expr(ti) {}
2863 
2864  // geo expressions might hide child expressions (e.g. constructors). Centralize logic
2865  // for pulling out child expressions for simplicity in visitors.
2866  virtual std::vector<Analyzer::Expr*> getChildExprs() const { return {}; }
2867 };
2868 
2874 class GeoColumnVar : public ColumnVar {
2875  public:
2877  const shared::ColumnKey& column_key,
2878  const int32_t range_table_index,
2879  const bool with_bounds,
2880  const bool with_render_group)
2881  : ColumnVar(ti, column_key, range_table_index)
2882  , with_bounds_(with_bounds)
2883  , with_render_group_(with_render_group) {}
2884 
2886  const bool with_bounds,
2887  const bool with_render_group)
2888  : ColumnVar(column_var->get_type_info(),
2889  column_var->getColumnKey(),
2890  column_var->get_rte_idx())
2891  , with_bounds_(with_bounds)
2892  , with_render_group_(with_render_group) {}
2893 
2894  protected:
2897 };
2898 
2899 class GeoConstant : public GeoExpr {
2900  public:
2901  GeoConstant(std::unique_ptr<Geospatial::GeoBase>&& geo, const SQLTypeInfo& ti);
2902 
2903  std::shared_ptr<Analyzer::Expr> deep_copy() const final;
2904 
2905  std::string toString() const final;
2906 
2907  bool operator==(const Expr&) const final;
2908 
2909  size_t physicalCols() const;
2910 
2911  std::shared_ptr<Analyzer::Constant> makePhysicalConstant(const size_t index) const;
2912 
2913  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) final;
2914 
2915  std::string getWKTString() const;
2916 
2917  private:
2918  std::unique_ptr<Geospatial::GeoBase> geo_;
2919 };
2920 
2925 class GeoOperator : public GeoExpr {
2926  public:
2927  GeoOperator(const SQLTypeInfo& ti,
2928  const std::string& name,
2929  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
2930  const std::optional<int>& output_srid_override = std::nullopt);
2931 
2932  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2933 
2934  void collect_rte_idx(std::set<int>& rte_idx_set) const final;
2935 
2936  void collect_column_var(
2937  std::set<const ColumnVar*, bool (*)(const ColumnVar*, const ColumnVar*)>&
2938  colvar_set,
2939  bool include_agg) const final;
2940 
2941  std::string toString() const override;
2942 
2943  bool operator==(const Expr&) const override;
2944 
2945  size_t size() const;
2946 
2947  Analyzer::Expr* getOperand(const size_t index) const;
2948 
2949  const std::string& getName() const { return name_; }
2950 
2951  std::vector<std::shared_ptr<Analyzer::Expr>> getArgs() const { return args_; }
2952 
2953  std::vector<Analyzer::Expr*> getChildExprs() const override {
2954  std::vector<Analyzer::Expr*> ret;
2955  ret.reserve(args_.size());
2956  for (const auto& arg : args_) {
2957  ret.push_back(arg.get());
2958  }
2959  return ret;
2960  }
2961 
2962  std::shared_ptr<Analyzer::Expr> add_cast(const SQLTypeInfo& new_type_info) final;
2963 
2965 
2966  protected:
2967  const std::string name_;
2968  const std::vector<std::shared_ptr<Analyzer::Expr>> args_;
2969 
2970  // for legacy geo code, allow passing in a srid to force a transform in the function
2971  std::optional<int> output_srid_override_;
2972 };
2973 
2975  public:
2977  const std::string& name,
2978  const std::vector<std::shared_ptr<Analyzer::Expr>>& args,
2979  const int32_t input_srid,
2980  const int32_t output_srid)
2981  : GeoOperator(ti, name, args), input_srid_(input_srid), output_srid_(output_srid) {}
2982 
2983  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
2984 
2985  std::string toString() const override;
2986 
2987  bool operator==(const Expr&) const override;
2988 
2989  int32_t getInputSRID() const { return input_srid_; }
2990 
2991  int32_t getOutputSRID() const { return output_srid_; }
2992 
2993  private:
2994  const int32_t input_srid_;
2995  const int32_t output_srid_;
2996 };
2997 } // namespace Analyzer
2998 
2999 inline std::shared_ptr<Analyzer::Var> var_ref(const Analyzer::Expr* expr,
3000  const Analyzer::Var::WhichRow which_row,
3001  const int varno) {
3002  const auto col_expr = dynamic_cast<const Analyzer::ColumnVar*>(expr);
3003  const shared::ColumnKey& column_key =
3004  col_expr ? col_expr->getColumnKey() : shared::ColumnKey{0, 0, 0};
3005  const int rte_idx = col_expr ? col_expr->get_rte_idx() : -1;
3006  return makeExpr<Analyzer::Var>(
3007  expr->get_type_info(), column_key, rte_idx, which_row, varno);
3008 }
3009 
3010 // Returns true iff the two expression lists are equal (same size and each element are
3011 // equal).
3012 bool expr_list_match(const std::vector<std::shared_ptr<Analyzer::Expr>>& lhs,
3013  const std::vector<std::shared_ptr<Analyzer::Expr>>& rhs);
3014 
3015 // Remove a cast operator if present.
3016 std::shared_ptr<Analyzer::Expr> remove_cast(const std::shared_ptr<Analyzer::Expr>& expr);
3017 const Analyzer::Expr* remove_cast(const Analyzer::Expr* expr);
DEVICE auto upper_bound(ARGS &&...args)
Definition: gpu_enabled.h:123
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:1180
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3720
std::list< ExpressionPtr > ExpressionPtrList
Definition: Analyzer.h:185
GeoBinOper(const Geospatial::GeoBase::GeoOp op, const SQLTypeInfo &ti, const SQLTypeInfo &ti0, const SQLTypeInfo &ti1, const std::vector< std::shared_ptr< Analyzer::Expr >> &args0, const std::vector< std::shared_ptr< Analyzer::Expr >> &args1)
Definition: Analyzer.h:2721
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:1022
Query * next_query
Definition: Analyzer.h:2849
bool hasRangeModeFraming() const
Definition: Analyzer.h:2610
CaseExpr(const SQLTypeInfo &ti, bool has_agg, const std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr >>> &w, std::shared_ptr< Analyzer::Expr > e)
Definition: Analyzer.h:1254
InIntegerSet(const std::shared_ptr< const Analyzer::Expr > a, const std::vector< int64_t > &values, const bool not_null)
Definition: Analyzer.cpp:1679
TryStringCastOper(const SQLTypeInfo &ti, const std::shared_ptr< Analyzer::Expr > &operand)
Definition: Analyzer.h:2328
SqlWindowFrameBoundType
Definition: sqldefs.h:150
virtual void get_domain(DomainSet &domain_set) const
Definition: Analyzer.h:177
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2026
bool operator==(const Expr &rhs) const override
Definition: Analyzer.h:621
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:656
WindowFrame(SqlWindowFrameBoundType bound_type, const std::shared_ptr< Analyzer::Expr > bound_expr)
Definition: Analyzer.h:2484
TargetEntry(const std::string &n, std::shared_ptr< Analyzer::Expr > e, bool u)
Definition: Analyzer.h:2754
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1914
static constexpr std::array< SqlWindowFunctionKind, 8 > AGGREGATION_TREE_REQUIRED_WINDOW_FUNCS_FOR_FRAMING
Definition: Analyzer.h:2538
std::string toString() const override
Definition: Analyzer.cpp:2871
Query * parsetree
Definition: Analyzer.h:632
bool isCurrentRowBound() const
Definition: Analyzer.h:2503
const std::list< std::shared_ptr< Analyzer::Expr > > & get_value_list() const
Definition: Analyzer.h:350
TrimStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:1946
SQLAgg
Definition: sqldefs.h:73
float get_likelihood() const
Definition: Analyzer.h:1147
size_t getMinArgs() const override
Definition: Analyzer.h:1837
std::vector< Analyzer::Expr * > getChildExprs() const override
Definition: Analyzer.h:2953
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2175
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:297
std::shared_ptr< Analyzer::Expr > expr
Definition: Analyzer.h:2768
virtual bool operator==(const Expr &rhs) const =0
std::string toString() const override
Definition: Analyzer.cpp:2793
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:564
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2129
SqlWindowFunctionKind getKind() const
Definition: Analyzer.h:2576
LowerStringOper(const std::shared_ptr< Analyzer::Expr > &operand)
Definition: Analyzer.h:1700
std::vector< std::vector< std::shared_ptr< TargetEntry > > > & get_values_lists()
Definition: Analyzer.h:2804
virtual ~Expr()
Definition: Analyzer.h:77
Expr(SQLTypes t, int d, int s, bool notnull)
Definition: Analyzer.h:73
bool unnest
Definition: Analyzer.h:2769
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1665
ConcatStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:1865
InValues(std::shared_ptr< Analyzer::Expr > a, const std::list< std::shared_ptr< Analyzer::Expr >> &l)
Definition: Analyzer.cpp:1661
PositionStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2378
const Expr * get_from_expr() const
Definition: Analyzer.h:1310
static bool simple_predicate_has_simple_cast(const std::shared_ptr< Analyzer::Expr > cast_operand, const std::shared_ptr< Analyzer::Expr > const_operand)
Definition: Analyzer.cpp:1526
const Expr * get_partition_count() const
Definition: Analyzer.h:1049
InitCapStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:1766
bool hasNoneEncodedTextArg() const
Definition: Analyzer.h:1617
Constant(const SQLTypeInfo &ti, bool n, Datum v)
Definition: Analyzer.h:335
const std::shared_ptr< Analyzer::Expr > get_own_arg() const
Definition: Analyzer.h:982
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2514
std::string toString() const override
Definition: Analyzer.cpp:2621
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3630
GeoConstant(std::unique_ptr< Geospatial::GeoBase > &&geo, const SQLTypeInfo &ti)
Definition: Analyzer.cpp:3820
void get_domain(DomainSet &domain_set) const override
Definition: Analyzer.cpp:3471
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2197
std::string toString() const final
Definition: Analyzer.cpp:3835
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2300
bool is_constant_expr() const
Definition: Analyzer.h:1124
const Expr * get_else_expr() const
Definition: Analyzer.h:1265
const SQLTypeInfo getTypeInfo0() const
Definition: Analyzer.h:2735
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3545
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2402
bool hasTimestampTypeFrameBound() const
Definition: Analyzer.h:2495
static std::vector< std::shared_ptr< Analyzer::Expr > > normalize_operands(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.cpp:4312
void set_contains_agg(bool a)
Definition: Analyzer.h:82
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1809
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:239
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs0() const
Definition: Analyzer.h:2737
Expr(SQLTypes t, bool notnull)
Definition: Analyzer.h:70
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:3680
const std::vector< int64_t > & get_value_list() const
Definition: Analyzer.h:695
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2320
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2292
void check_operand_types(const size_t min_args, const std::vector< OperandTypeFamily > &expected_type_families, const std::vector< std::string > &arg_names, const bool dict_encoded_cols_only=false, const bool cols_first_arg_only=true) const
Definition: Analyzer.cpp:4128
bool isFrameNavigateWindowFunction() const
Definition: Analyzer.h:2630
OrderEntry(int t, bool d, bool nf)
Definition: Analyzer.h:2469
const Expr * get_escape_expr() const
Definition: Analyzer.h:912
virtual std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const
Definition: Analyzer.h:129
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2260
size_t getMinArgs() const override
Definition: Analyzer.h:1951
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:798
std::vector< std::vector< std::shared_ptr< TargetEntry > > > values_lists
Definition: Analyzer.h:2855
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:864
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3157
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2104
std::shared_ptr< Analyzer::Expr > decompress()
Definition: Analyzer.cpp:732
size_t getArity() const
Definition: Analyzer.h:2408
std::optional< int > output_srid_override_
Definition: Analyzer.h:2971
Definition: Analyzer.h:2752
DatediffExpr(const SQLTypeInfo &ti, const DatetruncField f, const std::shared_ptr< Analyzer::Expr > start, const std::shared_ptr< Analyzer::Expr > end)
Definition: Analyzer.h:1397
int32_t getInputSRID() const
Definition: Analyzer.h:2989
std::shared_ptr< Analyzer::Expr > remove_cast(const std::shared_ptr< Analyzer::Expr > &expr)
Definition: Analyzer.cpp:4339
RangeOper(const bool l_inclusive, const bool r_inclusive, std::shared_ptr< Analyzer::Expr > l, std::shared_ptr< Analyzer::Expr > r)
Definition: Analyzer.h:539
size_t getMinArgs() const override
Definition: Analyzer.h:2092
ReplaceStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &search_pattern, const std::shared_ptr< Analyzer::Expr > &replacing_str)
Definition: Analyzer.h:2071
static bool colvar_comp(const ColumnVar *l, const ColumnVar *r)
Definition: Analyzer.h:215
SQLTypes
Definition: sqltypes.h:55
const std::shared_ptr< Analyzer::Expr > frame_end_bound_
Definition: Analyzer.h:2644
const std::vector< std::vector< std::shared_ptr< TargetEntry > > > & get_values_lists() const
Definition: Analyzer.h:2801
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3625
void add_rte(RangeTableEntry *rte)
Definition: Analyzer.cpp:1479
const SQLTypeInfo getTypeInfo0() const
Definition: Analyzer.h:2706
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2227
std::shared_ptr< Analyzer::Expr > operand
Definition: Analyzer.h:424
virtual void print() const
Definition: Analyzer.h:154
std::list< int > result_col_list
Definition: Analyzer.h:2854
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3580
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:752
std::list< std::pair< std::shared_ptr< Analyzer::Expr >, std::shared_ptr< Analyzer::Expr > > > expr_pair_list
Definition: Analyzer.h:1292
const std::shared_ptr< Analyzer::Expr > get_own_arg() const
Definition: Analyzer.h:811
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:222
GeoUOper(const Geospatial::GeoBase::GeoOp op, const SQLTypeInfo &ti, const SQLTypeInfo &ti0, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.h:2694
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1846
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2161
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:406
RegexpSubstrStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &regex_pattern, const std::shared_ptr< Analyzer::Expr > &start_pos, const std::shared_ptr< Analyzer::Expr > &occurrence, const std::shared_ptr< Analyzer::Expr > &regex_params, const std::shared_ptr< Analyzer::Expr > &sub_match_group_idx)
Definition: Analyzer.h:2188
bool hasAggregateTreeRequiredWindowFunc() const
Definition: Analyzer.h:2624
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2531
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:508
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3530
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3166
const std::shared_ptr< Analyzer::Expr > get_own_arg() const
Definition: Analyzer.h:1146
StringOper(const StringOper &other_string_oper)
Definition: Analyzer.h:1532
void collect_rte_idx(std::set< int > &rte_idx_set) const final
Definition: Analyzer.cpp:3938
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2147
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2354
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1601
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:992
SQLQualifier
Definition: sqldefs.h:71
virtual void add_unique(std::list< const Expr * > &expr_list) const
Definition: Analyzer.cpp:3116
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:816
std::shared_ptr< Analyzer::Expr > right_operand
Definition: Analyzer.h:530
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1953
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3195
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:1216
SQLStmtType stmt_type
Definition: Analyzer.h:2851
std::shared_ptr< Analyzer::Expr > escape_expr
Definition: Analyzer.h:1026
const Query * get_parsetree() const
Definition: Analyzer.h:592
bool operator==(Expr const &rhs) const override
Definition: Analyzer.cpp:2566
ExtractField get_field() const
Definition: Analyzer.h:1309
TryStringCastOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2345
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:1919
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:1967
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1698
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3361
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:140
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2058
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:301
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:102
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3429
const Expr * get_escape_expr() const
Definition: Analyzer.h:984
const Expr * get_right_operand() const
Definition: Analyzer.h:456
SQLOps
Definition: sqldefs.h:28
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1812
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3340
GeoTransformOperator(const SQLTypeInfo &ti, const std::string &name, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const int32_t input_srid, const int32_t output_srid)
Definition: Analyzer.h:2976
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:1077
std::string toString() const override
Definition: Analyzer.cpp:3064
std::shared_ptr< Analyzer::Expr > get_shared_ptr()
Definition: Analyzer.h:78
virtual void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const
Definition: Analyzer.h:84
shared::ColumnKey column_key_
Definition: Analyzer.h:239
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:922
RepeatStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:1825
auto getOutputSridOverride() const
Definition: Analyzer.h:2964
Var(const SQLTypeInfo &ti, WhichRow o, int32_t v)
Definition: Analyzer.h:284
std::map< size_t, std::pair< SQLTypes, Datum >> LiteralArgMap
Definition: Analyzer.h:1643
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3595
SqlWindowFrameBoundType bound_type_
Definition: Analyzer.h:2514
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3296
std::list< std::shared_ptr< Analyzer::Expr > > group_by
Definition: Analyzer.h:2846
static bool isFramingAvailableWindowFunc(SqlWindowFunctionKind kind)
Definition: Analyzer.h:2617
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:674
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:87
void print() const
Definition: Analyzer.h:2764
const std::vector< std::shared_ptr< Analyzer::Expr > > args0_
Definition: Analyzer.h:2712
SQLTypeInfo ti0_
Definition: Analyzer.h:2742
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:617
std::shared_ptr< Analyzer::Expr > like_expr
Definition: Analyzer.h:959
bool get_is_null() const
Definition: Analyzer.h:347
void set_varno(int32_t n)
Definition: Analyzer.h:289
const std::vector< std::shared_ptr< Analyzer::Expr > > args0_
Definition: Analyzer.h:2744
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:1152
std::string toString() const override
Definition: Analyzer.cpp:3711
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:874
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3399
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3136
int tle_no
Definition: Analyzer.h:2473
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3145
~OrderEntry()
Definition: Analyzer.h:2470
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:148
std::shared_ptr< Analyzer::Var > var_ref(const Analyzer::Expr *expr, const Analyzer::Var::WhichRow which_row, const int varno)
Definition: Analyzer.h:2999
GeoColumnVar(const SQLTypeInfo &ti, const shared::ColumnKey &column_key, const int32_t range_table_index, const bool with_bounds, const bool with_render_group)
Definition: Analyzer.h:2876
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2263
const std::shared_ptr< const Analyzer::Expr > arg
Definition: Analyzer.h:703
const std::shared_ptr< Analyzer::Expr > get_own_operand() const
Definition: Analyzer.h:385
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:213
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:222
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:1070
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:499
void cast_from_string(const SQLTypeInfo &new_type_info)
Definition: Analyzer.cpp:1184
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3550
bool get_contains_agg() const
Definition: Analyzer.h:81
SqlStringOpKind
Definition: sqldefs.h:89
void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const override
Definition: Analyzer.cpp:3466
std::string toString() const override
Definition: Analyzer.cpp:2835
std::shared_ptr< Analyzer::Expr > add_cast(const SQLTypeInfo &new_type_info) override
Definition: Analyzer.cpp:1436
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:1165
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3615
const SQLTypeInfo getTypeInfo1() const
Definition: Analyzer.h:2736
std::shared_ptr< Analyzer::Expr > ExpressionPtr
Definition: Analyzer.h:184
const Geospatial::GeoBase::GeoOp op_
Definition: Analyzer.h:2741
const Expr * get_arg() const
Definition: Analyzer.h:981
size_t getArity() const
Definition: Analyzer.h:1548
const std::vector< std::shared_ptr< Analyzer::Expr > > order_keys_
Definition: Analyzer.h:2641
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2139
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:3648
void set_order_by(std::list< OrderEntry > *o)
Definition: Analyzer.h:2825
Expr * get_arg() const
Definition: Analyzer.h:1208
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2457
DatetruncField get_field() const
Definition: Analyzer.h:1444
const std::list< OrderEntry > * get_order_by() const
Definition: Analyzer.h:2813
static SqlStringOpKind get_and_validate_trim_op_kind(const SqlStringOpKind trim_op_kind_maybe, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.cpp:4255
bool requiresPerRowTranslation() const
Definition: Analyzer.h:1578
void set_result_col_list(const std::list< int > &col_list)
Definition: Analyzer.h:2819
const Expr * get_arg() const
Definition: Analyzer.h:1145
std::shared_ptr< Analyzer::Expr > upper_bound_
Definition: Analyzer.h:1129
Constants for Builtin SQL Types supported by HEAVY.AI.
void set_which_row(WhichRow r)
Definition: Analyzer.h:287
size_t getMinArgs() const override
Definition: Analyzer.h:2383
size_t getMinArgs() const override
Definition: Analyzer.h:2217
std::shared_ptr< Analyzer::Expr > add_cast(const SQLTypeInfo &new_type_info) override
Definition: Analyzer.cpp:1418
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:1242
const Expr * get_where_predicate() const
Definition: Analyzer.h:2808
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3217
int get_num_aggs() const
Definition: Analyzer.h:2794
RegexpReplaceStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &regex_pattern, const std::shared_ptr< Analyzer::Expr > &replacing_str, const std::shared_ptr< Analyzer::Expr > &start_pos, const std::shared_ptr< Analyzer::Expr > &occurrence, const std::shared_ptr< Analyzer::Expr > &regex_params)
Definition: Analyzer.h:2141
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:3729
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3930
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:928
virtual std::vector< OperandTypeFamily > getExpectedTypeFamilies() const
Definition: Analyzer.h:1673
Definition: sqltypes.h:82
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:66
const Analyzer::WindowFrame * getFrameStartBound() const
Definition: Analyzer.h:2588
const std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:2434
const std::vector< std::shared_ptr< Analyzer::Expr > > partition_keys_
Definition: Analyzer.h:2640
static std::vector< std::shared_ptr< Analyzer::Expr > > normalize_operands(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.cpp:4237
void set_constant_expr() const
Definition: Analyzer.h:1123
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2094
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3590
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3354
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2436
void set_offset(int64_t o)
Definition: Analyzer.h:2837
ReplaceStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2080
StringOper(const SqlStringOpKind kind, const SQLTypeInfo &return_ti, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.h:1489
UOper(SQLTypes t, SQLOps o, std::shared_ptr< Analyzer::Expr > p)
Definition: Analyzer.h:379
~Constant() override
Definition: Analyzer.cpp:40
std::shared_ptr< Analyzer::Expr > getOwnArg(const size_t i) const
Definition: Analyzer.h:1567
std::unique_ptr< Geospatial::GeoBase > geo_
Definition: Analyzer.h:2918
size_t getLiteralsArity() const
Definition: Analyzer.h:1550
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3277
SQLQualifier qualifier
Definition: Analyzer.h:527
bool isNull() const
Definition: Analyzer.h:2669
std::shared_ptr< Analyzer::Expr > partition_count_
Definition: Analyzer.h:1130
virtual std::vector< Analyzer::Expr * > getChildExprs() const
Definition: Analyzer.h:2866
const Analyzer::WindowFrame * getFrameEndBound() const
Definition: Analyzer.h:2595
std::string toString() const override
Definition: Analyzer.cpp:2962
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1780
const std::vector< std::shared_ptr< Analyzer::Expr > > & getOrderKeys() const
Definition: Analyzer.h:2584
std::string toString() const override
Definition: Analyzer.cpp:2683
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:490
SQLTypeInfo type_info
Definition: Analyzer.h:180
const std::vector< OrderEntry > & getCollation() const
Definition: Analyzer.h:2602
const Expr * get_left_operand() const
Definition: Analyzer.h:552
EncodingType get_compression() const
Definition: Analyzer.h:204
std::list< const Expr * > DomainSet
Definition: Analyzer.h:62
double inline_fp_null_val(const SQL_TYPE_INFO &ti)
virtual void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const
Definition: Analyzer.h:117
void set_constval(Datum d)
Definition: Analyzer.h:349
const Expr * get_arg() const
Definition: Analyzer.h:909
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:784
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2064
std::enable_if< std::is_base_of< Analyzer::Expr, Tp >::value, std::shared_ptr< Tp > >::type makeExpr(Args &&...args)
Definition: Analyzer.h:53
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.h:597
std::string toString() const override
Definition: Analyzer.cpp:2630
void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const override
Definition: Analyzer.cpp:1511
const std::string & get_resname() const
Definition: Analyzer.h:2757
double get_bound_val(const Analyzer::Expr *bound_expr) const
Definition: Analyzer.cpp:3752
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2133
constexpr double f
Definition: Utm.h:31
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:1010
RepeatStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:1832
~Subquery() override
Definition: Analyzer.cpp:46
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:613
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2474
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:737
TrimStringOper(const SqlStringOpKind trim_op_kind, const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &trim_chars)
Definition: Analyzer.h:1929
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:1004
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:603
bool operator==(const Expr &) const override
Definition: Analyzer.cpp:4025
int get_rte_idx(const std::string &range_var_name) const
Definition: Analyzer.cpp:1468
void cast_string(const SQLTypeInfo &new_type_info)
Definition: Analyzer.cpp:1173
void set_type_info(const SQLTypeInfo &ti)
Definition: Analyzer.h:80
const std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:2639
void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const override
Definition: Analyzer.cpp:3449
std::string toString() const override
Definition: Analyzer.cpp:2652
JsonValueStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2246
const std::shared_ptr< Analyzer::Expr > get_own_from_expr() const
Definition: Analyzer.h:1446
std::vector< std::shared_ptr< Analyzer::Expr > > chained_string_op_exprs_
Definition: Analyzer.h:1695
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:76
std::string toString() const override
Definition: Analyzer.cpp:2758
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3600
LikelihoodExpr(std::shared_ptr< Analyzer::Expr > a, float l=0.5)
Definition: Analyzer.h:1143
constexpr double a
Definition: Utm.h:32
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2332
StringOper(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.h:1485
BinOper(const SQLTypeInfo &ti, bool has_agg, SQLOps o, SQLQualifier q, std::shared_ptr< Analyzer::Expr > l, std::shared_ptr< Analyzer::Expr > r)
Definition: Analyzer.h:435
bool g_enable_string_functions
std::string toString() const override
Definition: Analyzer.cpp:2849
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2176
std::vector< size_t > getLiteralArgIndexes() const
Definition: Analyzer.cpp:4064
std::string toString() const override
Definition: Analyzer.cpp:2880
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:878
std::string toString() const override
Definition: Analyzer.cpp:2816
bool get_calc_encoded_length() const
Definition: Analyzer.h:718
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2309
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2017
std::string toString() const override
Definition: Analyzer.cpp:3035
DatetruncField field_
Definition: Analyzer.h:1470
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:1981
const FrameBoundType frame_bound_type_
Definition: Analyzer.h:2642
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3635
const Geospatial::GeoBase::GeoOp op_
Definition: Analyzer.h:2710
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:1057
std::string toString() const override
Definition: Analyzer.cpp:2985
SQLOps get_optype() const
Definition: Analyzer.h:452
std::shared_ptr< Analyzer::Expr > left_operand
Definition: Analyzer.h:529
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2548
const std::vector< std::shared_ptr< Analyzer::Expr > > args1_
Definition: Analyzer.h:2745
RepeatStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &num_repeats)
Definition: Analyzer.h:1817
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3286
std::string toString() const
Definition: Analyzer.cpp:3094
SqlWindowFrameBoundType getBoundType() const
Definition: Analyzer.h:2488
const Query * get_next_query() const
Definition: Analyzer.h:2814
SubstringStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &start_pos, const std::shared_ptr< Analyzer::Expr > &length)
Definition: Analyzer.h:1990
const std::shared_ptr< Analyzer::Expr > frame_start_bound_
Definition: Analyzer.h:2643
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:115
std::shared_ptr< Analyzer::Expr > normalize_simple_predicate(int &rte_idx) const override
Definition: Analyzer.cpp:1550
const std::list< std::shared_ptr< Analyzer::Expr > > value_list
Definition: Analyzer.h:676
Base64EncodeStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2277
EncodingType
Definition: sqltypes.h:230
SplitPartStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &delimiter, const std::shared_ptr< Analyzer::Expr > &split_index)
Definition: Analyzer.h:2106
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:173
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:166
static SQLTypeInfo common_string_type(const SQLTypeInfo &type1, const SQLTypeInfo &type2)
Definition: Analyzer.cpp:435
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:217
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:479
UpperStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:1736
DatetruncExpr(const SQLTypeInfo &ti, bool has_agg, DatetruncField f, std::shared_ptr< Analyzer::Expr > e)
Definition: Analyzer.h:1439
std::shared_ptr< Analyzer::Expr > right_operand_
Definition: Analyzer.h:577
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1593
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:483
void set_fixed_encoding_null_val() const
Definition: Analyzer.h:1357
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:182
static SqlStringOpKind validate_trim_op_kind(const SqlStringOpKind trim_op_kind)
Definition: Analyzer.h:1961
bool hasSingleDictEncodedColInput() const
returns whether we have one and only one column involved in this StringOper and all its descendents...
Definition: Analyzer.cpp:4050
RegexpReplaceStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2161
Expr(const SQLTypeInfo &ti, bool has_agg=false)
Definition: Analyzer.h:75
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3184
std::shared_ptr< Analyzer::Expr > deep_copy() const final
Definition: Analyzer.cpp:3830
LiteralArgMap getLiteralArgs() const
Definition: Analyzer.cpp:4077
std::string toString() const override
Definition: Analyzer.cpp:2747
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2058
const DatetruncField field_
Definition: Analyzer.h:1428
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2535
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1742
const std::vector< std::shared_ptr< Analyzer::Expr > > & getTuple() const
Definition: Analyzer.h:253
CONSTEXPR DEVICE bool is_null(const T &value)
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3345
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2181
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs() const
Definition: Analyzer.h:2578
AggExpr(SQLTypes t, SQLAgg a, Expr *g, bool d, std::shared_ptr< Analyzer::Expr > e, int idx)
Definition: Analyzer.h:1196
void collect_rte_idx(std::set< int32_t > &rte_idx_set) const override
Definition: Analyzer.h:212
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1872
RangeTableEntry * get_rte(int rte_idx) const
Definition: Analyzer.h:2831
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3336
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:825
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3367
const std::shared_ptr< Analyzer::Expr > get_own_from_expr() const
Definition: Analyzer.h:1311
DateaddField
Definition: DateAdd.h:42
std::shared_ptr< Analyzer::Expr > lower_bound_
Definition: Analyzer.h:1128
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:936
bool is_integer() const
Definition: sqltypes.h:582
std::vector< std::shared_ptr< TargetEntry > > targetlist
Definition: Analyzer.h:2841
std::string toString() const override
Definition: Analyzer.cpp:2828
const DateaddField field_
Definition: Analyzer.h:1382
PositionStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2370
std::shared_ptr< Analyzer::Expr > arg1
Definition: Analyzer.h:1245
DatetruncField
Definition: DateTruncate.h:27
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:122
std::shared_ptr< Analyzer::Expr > from_expr_
Definition: Analyzer.h:1471
const std::shared_ptr< Analyzer::Expr > get_own_arg() const
Definition: Analyzer.h:645
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3242
bool expr_list_match(const std::vector< std::shared_ptr< Analyzer::Expr >> &lhs, const std::vector< std::shared_ptr< Analyzer::Expr >> &rhs)
Definition: Analyzer.cpp:4326
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3412
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2785
Subquery(const SQLTypeInfo &ti, Query *q)
Definition: Analyzer.h:589
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs0() const
Definition: Analyzer.h:2707
StringOper(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const size_t min_args, const std::vector< OperandTypeFamily > &expected_type_families, const std::vector< std::string > &arg_names)
Definition: Analyzer.h:1494
std::shared_ptr< Analyzer::Expr > getOwnArg(const size_t i) const
Definition: Analyzer.h:2415
ReverseStringOper(const std::shared_ptr< Analyzer::Expr > &operand)
Definition: Analyzer.h:1788
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:395
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:1812
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:392
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:198
Expr * get_expr() const
Definition: Analyzer.h:2759
ColumnVar(const SQLTypeInfo &ti, const shared::ColumnKey &column_key, int32_t rte_idx)
Definition: Analyzer.h:196
int64_t get_offset() const
Definition: Analyzer.h:2836
size_t getMinArgs() const override
Definition: Analyzer.h:1748
std::string toString() const override
Definition: Analyzer.cpp:2614
size_t getMinArgs() const override
Definition: Analyzer.h:2166
size_t getMinArgs() const override
Definition: Analyzer.h:2318
void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const override
Definition: Analyzer.cpp:1499
const std::shared_ptr< Analyzer::Expr > end_
Definition: Analyzer.h:1430
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2497
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:870
std::string toString() const override
Definition: Analyzer.cpp:2860
WhichRow get_which_row() const
Definition: Analyzer.h:286
void check_group_by(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const override
Definition: Analyzer.cpp:3454
void set_expr(std::shared_ptr< Analyzer::Expr > e)
Definition: Analyzer.h:2761
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2422
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3251
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2294
const std::shared_ptr< Analyzer::Expr > number_
Definition: Analyzer.h:1383
ArrayExpr(SQLTypeInfo const &array_ti, ExpressionPtrVector const &array_exprs, bool is_null=false, bool local_alloc=false)
Definition: Analyzer.h:2655
Base64DecodeStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2313
const std::list< std::shared_ptr< Analyzer::Expr > > value_list
Definition: Analyzer.h:361
std::string resname
Definition: Analyzer.h:2767
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3565
Base64EncodeStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2284
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:2781
const Analyzer::Expr * getBoundExpr() const
Definition: Analyzer.h:2490
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2505
bool get_is_distinct() const
Definition: Analyzer.h:2793
const std::string & getName() const
Definition: Analyzer.h:2949
std::string toString() const override
Definition: Analyzer.cpp:2972
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:732
static SQLTypeInfo common_numeric_type(const SQLTypeInfo &type1, const SQLTypeInfo &type2)
Definition: Analyzer.cpp:483
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3350
SQLTypeInfo ti1_
Definition: Analyzer.h:2743
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2352
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2035
int32_t get_varno() const
Definition: Analyzer.h:288
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:609
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1756
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2203
const std::shared_ptr< Analyzer::Expr > start_
Definition: Analyzer.h:1429
virtual ~TargetEntry()
Definition: Analyzer.h:2756
size_t getMinArgs() const override
Definition: Analyzer.h:2056
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:559
virtual std::vector< std::string > getArgNames() const
Definition: Analyzer.h:1677
std::string toString() const
Definition: Analyzer.cpp:3104
bool get_is_simple() const
Definition: Analyzer.h:914
SplitPartStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2115
OverlayStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &replacing_str, const std::shared_ptr< Analyzer::Expr > &start_pos)
Definition: Analyzer.h:2025
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1712
std::vector< std::shared_ptr< Analyzer::Expr > > getArgs() const
Definition: Analyzer.h:2951
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:861
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1770
bool nulls_first
Definition: Analyzer.h:2475
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:1999
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3374
const std::shared_ptr< Analyzer::Expr > get_own_arg() const
Definition: Analyzer.h:717
int64_t get_limit() const
Definition: Analyzer.h:2834
bool get_is_distinct() const
Definition: Analyzer.h:1210
FunctionOperWithCustomTypeHandling(const SQLTypeInfo &ti, const std::string &name, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.h:2439
static constexpr std::array< SqlWindowFunctionKind, 3 > REQUIRE_HASH_TABLE_FOR_FRAMING
Definition: Analyzer.h:2547
static std::vector< std::shared_ptr< Analyzer::Expr > > normalize_operands(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands, const SqlStringOpKind string_op_kind)
Definition: Analyzer.cpp:4286
bool get_unnest() const
Definition: Analyzer.h:2762
ReplaceStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2087
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2320
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:726
StringOper(const SqlStringOpKind kind, const SQLTypeInfo &return_ti, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const size_t min_args, const std::vector< OperandTypeFamily > &expected_type_families, const std::vector< std::string > &arg_names)
Definition: Analyzer.h:1508
const std::vector< OrderEntry > collation_
Definition: Analyzer.h:2645
bool g_enable_smem_group_by true
ExtractExpr(const SQLTypeInfo &ti, bool has_agg, ExtractField f, std::shared_ptr< Analyzer::Expr > e)
Definition: Analyzer.h:1304
const Expr * get_start_expr() const
Definition: Analyzer.h:1403
void do_cast(const SQLTypeInfo &new_type_info)
Definition: Analyzer.cpp:1257
std::string toString() const override
Definition: Analyzer.cpp:2638
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1890
Constant(const SQLTypeInfo &ti, bool n, const std::list< std::shared_ptr< Analyzer::Expr >> &l)
Definition: Analyzer.h:342
const Expr * get_right_operand() const
Definition: Analyzer.h:553
bool operator==(const Expr &rhs) const override
Definition: Analyzer.cpp:2598
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2013
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:833
void set_num_aggs(int a)
Definition: Analyzer.h:2829
void set_group_by(std::list< std::shared_ptr< Analyzer::Expr >> &g)
Definition: Analyzer.h:2823
WhichRow which_row
Definition: Analyzer.h:309
const SQLTypeInfo & get_type_info() const
Definition: Analyzer.h:79
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2075
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3406
void add_tle(std::shared_ptr< TargetEntry > tle)
Definition: Analyzer.h:2833
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1860
WindowFunction(const SQLTypeInfo &ti, const SqlWindowFunctionKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args, const std::vector< std::shared_ptr< Analyzer::Expr >> &partition_keys, const std::vector< std::shared_ptr< Analyzer::Expr >> &order_keys, const FrameBoundType frame_bound_type, const std::shared_ptr< Expr > frame_start_bound, const std::shared_ptr< Expr > frame_end_bound, const std::vector< OrderEntry > &collation)
Definition: Analyzer.h:2552
void set_next_query(Query *q)
Definition: Analyzer.h:2826
bool get_is_unionall() const
Definition: Analyzer.h:2816
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3555
static SQLTypeInfo get_return_type(const SqlStringOpKind kind, const std::vector< std::shared_ptr< Analyzer::Expr >> &args)
Definition: Analyzer.cpp:4092
std::shared_ptr< Analyzer::Expr > add_cast(const SQLTypeInfo &new_type_info) final
Definition: Analyzer.cpp:3901
int get_result_table_id() const
Definition: Analyzer.h:2817
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:3640
size_t getElementCount() const
Definition: Analyzer.h:2667
Base64DecodeStringOper(const std::shared_ptr< Analyzer::Expr > &operand)
Definition: Analyzer.h:2299
int32_t getOutputSRID() const
Definition: Analyzer.h:2991
SQLStmtType
Definition: sqldefs.h:159
std::shared_ptr< Analyzer::Expr > arg
Definition: Analyzer.h:958
std::shared_ptr< Analyzer::Expr > get_arg1() const
Definition: Analyzer.h:1211
const std::vector< std::shared_ptr< Analyzer::Expr > > tuple_
Definition: Analyzer.h:263
RegexpSubstrStringOper(const std::shared_ptr< Analyzer::StringOper > &string_oper)
Definition: Analyzer.h:2212
OverlayStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &replacing_str, const std::shared_ptr< Analyzer::Expr > &start_pos, const std::shared_ptr< Analyzer::Expr > &replacing_length)
Definition: Analyzer.h:2034
void set_having_predicate(std::shared_ptr< Analyzer::Expr > p)
Definition: Analyzer.h:2824
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:4005
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:2219
std::vector< std::shared_ptr< Analyzer::Expr > > args_
Definition: Analyzer.h:1694
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3306
void set_result_table_id(int id)
Definition: Analyzer.h:2820
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:780
const std::vector< int64_t > value_list
Definition: Analyzer.h:704
std::shared_ptr< Analyzer::Expr > rewrite_with_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:401
std::shared_ptr< Analyzer::Expr > rewrite_agg_to_var(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.h:742
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.cpp:3326
const Expr * get_pattern_expr() const
Definition: Analyzer.h:983
void collect_rte_idx(std::set< int > &rte_idx_set) const override
Definition: Analyzer.h:723
JsonValueStringOper(const std::shared_ptr< Analyzer::Expr > &operand, const std::shared_ptr< Analyzer::Expr > &json_path)
Definition: Analyzer.h:2238
#define CHECK_LT(x, y)
Definition: Logger.h:303
size_t getMinArgs() const override
Definition: Analyzer.h:2258
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:1956
std::vector< OperandTypeFamily > getExpectedTypeFamilies() const override
Definition: Analyzer.h:1721
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:2355
int64_t offset
Definition: Analyzer.h:2857
virtual std::string toString() const =0
WidthBucketExpr(const std::shared_ptr< Analyzer::Expr > target_value, const std::shared_ptr< Analyzer::Expr > lower_bound, const std::shared_ptr< Analyzer::Expr > upper_bound, const std::shared_ptr< Analyzer::Expr > partition_count)
Definition: Analyzer.h:1035
ExpressionPtrVector contained_expressions_
Definition: Analyzer.h:2683
std::shared_ptr< Analyzer::Expr > rewrite_with_child_targetlist(const std::vector< std::shared_ptr< TargetEntry >> &tlist) const override
Definition: Analyzer.cpp:2049
SqlStringOpKind kind_
Definition: Analyzer.h:1693
std::vector< std::string > getArgNames() const override
Definition: Analyzer.h:1754
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.cpp:3421
Expression class for string functions The &quot;arg&quot; constructor parameter must be an expression that reso...
Definition: Analyzer.h:1479
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const override
Definition: Analyzer.h:819
void group_predicates(std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const override
Definition: Analyzer.cpp:1826
UOper(const SQLTypeInfo &ti, bool has_agg, SQLOps o, std::shared_ptr< Analyzer::Expr > p)
Definition: Analyzer.h:377
std::shared_ptr< Analyzer::Expr > deep_copy() const override
Definition: Analyzer.cpp:144
const Expr * get_from_expr() const
Definition: Analyzer.h:1445
virtual ~Query()
Definition: Analyzer.cpp:50
const shared::ColumnKey & getColumnKey() const
Definition: Analyzer.h:198
void find_expr(std::function< bool(const Expr *)> f, std::list< const Expr * > &expr_list) const override
Definition: Analyzer.cpp:3262
size_t getMinArgs() const override
Definition: Analyzer.h:2011
DEVICE auto lower_bound(ARGS &&...args)
Definition: gpu_enabled.h:78
const std::shared_ptr< Analyzer::Expr > bound_expr_
Definition: Analyzer.h:2515
RegexpReplaceStringOper(const std::vector< std::shared_ptr< Analyzer::Expr >> &operands)
Definition: Analyzer.h:2154
const Expr * get_datetime_expr() const
Definition: Analyzer.h:1356
void set_is_distinct(bool d)
Definition: Analyzer.h:2821
HOST DEVICE EncodingType get_compression() const
Definition: sqltypes.h:389