Parser::QuerySpec Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::QuerySpec:

Collaboration diagram for Parser::QuerySpec:

Public Member Functions
	QuerySpec (bool d, std::list< SelectEntry * > *s, std::list< TableRef * > *f, Expr *w, std::list< Expr * > *g, Expr *h)
bool	get_is_distinct () const
const std::list < std::unique_ptr< SelectEntry > > &	get_select_clause () const
const std::list < std::unique_ptr< TableRef > > &	get_from_clause () const
const Expr *	get_where_clause () const
const std::list < std::unique_ptr< Expr > > &	get_groupby_clause () const
const Expr *	get_having_clause () const
void	analyze (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const override
std::string	to_string () const
Public Member Functions inherited from Parser::Node
virtual	~Node ()

Private Member Functions
void	analyze_from_clause (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void	analyze_select_clause (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void	analyze_where_clause (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void	analyze_group_by (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const
void	analyze_having_clause (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query) const

Private Attributes
bool	is_distinct_
std::list< std::unique_ptr < SelectEntry > >	select_clause_
std::list< std::unique_ptr < TableRef > >	from_clause_
std::unique_ptr< Expr >	where_clause_
std::list< std::unique_ptr < Expr > >	groupby_clause_
std::unique_ptr< Expr >	having_clause_

Detailed Description

Definition at line 1720 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::QuerySpec::QuerySpec ( bool  d, std::list< SelectEntry * > *  s, std::list< TableRef * > *  f, Expr *  w, std::list< Expr * > *  g, Expr *  h  )

inline

Definition at line 1722 of file ParserNode.h.

References CHECK, f(), from_clause_, groupby_clause_, and select_clause_.

      : is_distinct_(d), where_clause_(w), having_clause_(h) {
    if (s) {
      for (const auto e : *s) {
        select_clause_.emplace_back(e);
      }
      delete s;
    }
    CHECK(f);
    for (const auto e : *f) {
      from_clause_.emplace_back(e);
    }
    delete f;
    if (g) {
      for (const auto e : *g) {
        groupby_clause_.emplace_back(e);
      }
      delete g;
    }
  }

Here is the call graph for this function:

Member Function Documentation

void Parser::QuerySpec::analyze ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

overridevirtual

Implements Parser::QueryExpr.

Definition at line 1974 of file ParserNode.cpp.

References Analyzer::Query::set_is_distinct().

                                                    {
  query.set_is_distinct(is_distinct_);
  analyze_from_clause(catalog, query);
  analyze_select_clause(catalog, query);
  analyze_where_clause(catalog, query);
  analyze_group_by(catalog, query);
  analyze_having_clause(catalog, query);
}

Here is the call graph for this function:

void Parser::QuerySpec::analyze_from_clause ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

private

Definition at line 1954 of file ParserNode.cpp.

References Analyzer::Query::add_rte(), and Catalog_Namespace::Catalog::getMetadataForTable().

                                                                {
  Analyzer::RangeTableEntry* rte;
  for (auto& p : from_clause_) {
    const TableDescriptor* table_desc;
    table_desc = catalog.getMetadataForTable(*p->get_table_name());
    if (table_desc == nullptr) {
      throw std::runtime_error("Table " + *p->get_table_name() + " does not exist.");
    }
    std::string range_var;
    if (p->get_range_var() == nullptr) {
      range_var = *p->get_table_name();
    } else {
      range_var = *p->get_range_var();
    }
    rte = new Analyzer::RangeTableEntry(range_var, table_desc, nullptr);
    query.add_rte(rte);
  }
}

Here is the call graph for this function:

void Parser::QuerySpec::analyze_group_by ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

private

Definition at line 1815 of file ParserNode.cpp.

References Analyzer::Expr::add_cast(), SQLTypeInfo::get_compression(), Parser::IntLiteral::get_intval(), Analyzer::Query::get_num_aggs(), Analyzer::Query::get_targetlist(), SQLTypeInfo::is_string(), kENCODING_DICT, kENCODING_NONE, Analyzer::Var::kGROUPBY, Analyzer::Var::kOUTPUT, shared::StringDictKey::kTransientDictKey, anonymous_namespace{Utm.h}::n, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_fixed_size(), Analyzer::Query::set_group_by(), SQLTypeInfo::setStringDictKey(), and TRANSIENT_DICT_ID.

                                                             {
  std::list<std::shared_ptr<Analyzer::Expr>> groupby;
  if (!groupby_clause_.empty()) {
    int gexpr_no = 1;
    std::shared_ptr<Analyzer::Expr> gexpr;
    const std::vector<std::shared_ptr<Analyzer::TargetEntry>>& tlist =
        query.get_targetlist();
    for (auto& c : groupby_clause_) {
      // special-case ordinal numbers in GROUP BY
      if (dynamic_cast<Literal*>(c.get())) {
        IntLiteral* i = dynamic_cast<IntLiteral*>(c.get());
        if (!i) {
          throw std::runtime_error("Invalid literal in GROUP BY clause.");
        }
        int varno = (int)i->get_intval();
        if (varno <= 0 || varno > static_cast<int>(tlist.size())) {
          throw std::runtime_error("Invalid ordinal number in GROUP BY clause.");
        }
        if (tlist[varno - 1]->get_expr()->get_contains_agg()) {
          throw std::runtime_error(
              "Ordinal number in GROUP BY cannot reference an expression containing "
              "aggregate "
              "functions.");
        }
        gexpr = makeExpr<Analyzer::Var>(
            tlist[varno - 1]->get_expr()->get_type_info(), Analyzer::Var::kOUTPUT, varno);
      } else {
        gexpr = c->analyze(catalog, query, Expr::TlistRefType::TLIST_REF);
      }
      const SQLTypeInfo gti = gexpr->get_type_info();
      bool set_new_type = false;
      SQLTypeInfo ti(gti);
      if (gti.is_string() && gti.get_compression() == kENCODING_NONE) {
        set_new_type = true;
        ti.set_compression(kENCODING_DICT);
        ti.set_comp_param(TRANSIENT_DICT_ID);
        ti.setStringDictKey(shared::StringDictKey::kTransientDictKey);
        ti.set_fixed_size();
      }
      std::shared_ptr<Analyzer::Var> v;
      if (std::dynamic_pointer_cast<Analyzer::Var>(gexpr)) {
        v = std::static_pointer_cast<Analyzer::Var>(gexpr);
        int n = v->get_varno();
        gexpr = tlist[n - 1]->get_own_expr();
        auto cv = std::dynamic_pointer_cast<Analyzer::ColumnVar>(gexpr);
        if (cv != nullptr) {
          // inherit all ColumnVar info for lineage.
          *std::static_pointer_cast<Analyzer::ColumnVar>(v) = *cv;
        }
        v->set_which_row(Analyzer::Var::kGROUPBY);
        v->set_varno(gexpr_no);
        tlist[n - 1]->set_expr(v);
      }
      if (set_new_type) {
        auto new_e = gexpr->add_cast(ti);
        groupby.push_back(new_e);
        if (v != nullptr) {
          v->set_type_info(new_e->get_type_info());
        }
      } else {
        groupby.push_back(gexpr);
      }
      gexpr_no++;
    }
  }
  if (query.get_num_aggs() > 0 || !groupby.empty()) {
    for (auto t : query.get_targetlist()) {
      auto e = t->get_expr();
      e->check_group_by(groupby);
    }
  }
  query.set_group_by(groupby);
}

Here is the call graph for this function:

void Parser::QuerySpec::analyze_having_clause ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

private

Definition at line 1802 of file ParserNode.cpp.

References Analyzer::Query::get_group_by(), kBOOLEAN, and Analyzer::Query::set_having_predicate().

                                                                  {
  std::shared_ptr<Analyzer::Expr> p;
  if (having_clause_ != nullptr) {
    p = having_clause_->analyze(catalog, query, Expr::TlistRefType::TLIST_COPY);
    if (p->get_type_info().get_type() != kBOOLEAN) {
      throw std::runtime_error("Only boolean expressions can be in HAVING clause.");
    }
    p->check_group_by(query.get_group_by());
  }
  query.set_having_predicate(p);
}

Here is the call graph for this function:

void Parser::QuerySpec::analyze_select_clause ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

private

Definition at line 1903 of file ParserNode.cpp.

References Parser::Expr::analyze(), ColumnDescriptor::columnName, Analyzer::RangeTableEntry::expand_star_in_targetlist(), Analyzer::Query::get_rangetable(), Analyzer::Query::get_rte(), Analyzer::Query::get_rte_idx(), Analyzer::Query::get_targetlist_nonconst(), Analyzer::ColumnVar::getColumnKey(), Catalog_Namespace::Catalog::getMetadataForColumn(), kNULLT, and kUNNEST.

                                                                  {
  std::vector<std::shared_ptr<Analyzer::TargetEntry>>& tlist =
      query.get_targetlist_nonconst();
  if (select_clause_.empty()) {
    // this means SELECT *
    int rte_idx = 0;
    for (auto rte : query.get_rangetable()) {
      rte->expand_star_in_targetlist(catalog, tlist, rte_idx++);
    }
  } else {
    for (auto& p : select_clause_) {
      const Parser::Expr* select_expr = p->get_select_expr();
      // look for the case of range_var.*
      if (typeid(*select_expr) == typeid(ColumnRef) &&
          dynamic_cast<const ColumnRef*>(select_expr)->get_column() == nullptr) {
        const std::string* range_var_name =
            dynamic_cast<const ColumnRef*>(select_expr)->get_table();
        int rte_idx = query.get_rte_idx(*range_var_name);
        if (rte_idx < 0) {
          throw std::runtime_error("invalid range variable name: " + *range_var_name);
        }
        Analyzer::RangeTableEntry* rte = query.get_rte(rte_idx);
        rte->expand_star_in_targetlist(catalog, tlist, rte_idx);
      } else {
        auto e = select_expr->analyze(catalog, query);
        std::string resname;

        if (p->get_alias() != nullptr) {
          resname = *p->get_alias();
        } else if (std::dynamic_pointer_cast<Analyzer::ColumnVar>(e) &&
                   !std::dynamic_pointer_cast<Analyzer::Var>(e)) {
          auto colvar = std::static_pointer_cast<Analyzer::ColumnVar>(e);
          const auto& column_key = colvar->getColumnKey();
          const ColumnDescriptor* col_desc =
              catalog.getMetadataForColumn(column_key.table_id, column_key.column_id);
          resname = col_desc->columnName;
        }
        if (e->get_type_info().get_type() == kNULLT) {
          throw std::runtime_error(
              "Untyped NULL in SELECT clause.  Use CAST to specify a type.");
        }
        auto o = std::static_pointer_cast<Analyzer::UOper>(e);
        bool unnest = (o != nullptr && o->get_optype() == kUNNEST);
        auto tle = std::make_shared<Analyzer::TargetEntry>(resname, e, unnest);
        tlist.push_back(tle);
      }
    }
  }
}

Here is the call graph for this function:

void Parser::QuerySpec::analyze_where_clause ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query  ) const

private

Definition at line 1890 of file ParserNode.cpp.

References kBOOLEAN, and Analyzer::Query::set_where_predicate().

                                                                 {
  if (where_clause_ == nullptr) {
    query.set_where_predicate(nullptr);
    return;
  }
  auto p = where_clause_->analyze(catalog, query, Expr::TlistRefType::TLIST_COPY);
  if (p->get_type_info().get_type() != kBOOLEAN) {
    throw std::runtime_error("Only boolean expressions can be in WHERE clause.");
  }
  query.set_where_predicate(p);
}

Here is the call graph for this function:

const std::list<std::unique_ptr<TableRef> >& Parser::QuerySpec::get_from_clause ( ) const

inline

Definition at line 1751 of file ParserNode.h.

References from_clause_.

                                                                  {
    return from_clause_;
  }

const std::list<std::unique_ptr<Expr> >& Parser::QuerySpec::get_groupby_clause ( ) const

inline

Definition at line 1755 of file ParserNode.h.

References groupby_clause_.

                                                                 {
    return groupby_clause_;
  }

const Expr* Parser::QuerySpec::get_having_clause ( ) const

inline

Definition at line 1758 of file ParserNode.h.

References having_clause_.

{ return having_clause_.get(); }

bool Parser::QuerySpec::get_is_distinct ( ) const

inline

Definition at line 1747 of file ParserNode.h.

References is_distinct_.

{ return is_distinct_; }

const std::list<std::unique_ptr<SelectEntry> >& Parser::QuerySpec::get_select_clause ( ) const

inline

Definition at line 1748 of file ParserNode.h.

References select_clause_.

                                                                       {
    return select_clause_;
  }

const Expr* Parser::QuerySpec::get_where_clause ( ) const

inline

Definition at line 1754 of file ParserNode.h.

References where_clause_.

{ return where_clause_.get(); }

std::string Parser::QuerySpec::to_string

(

)

const

Definition at line 2306 of file ParserNode.cpp.

                                     {
  std::string query_str = "SELECT ";
  if (is_distinct_) {
    query_str += "DISTINCT ";
  }
  if (select_clause_.empty()) {
    query_str += "* ";
  } else {
    bool notfirst = false;
    for (auto& p : select_clause_) {
      if (notfirst) {
        query_str += ", ";
      } else {
        notfirst = true;
      }
      query_str += p->to_string();
    }
  }
  query_str += " FROM ";
  bool notfirst = false;
  for (auto& p : from_clause_) {
    if (notfirst) {
      query_str += ", ";
    } else {
      notfirst = true;
    }
    query_str += p->to_string();
  }
  if (where_clause_) {
    query_str += " WHERE " + where_clause_->to_string();
  }
  if (!groupby_clause_.empty()) {
    query_str += " GROUP BY ";
    bool notfirst = false;
    for (auto& p : groupby_clause_) {
      if (notfirst) {
        query_str += ", ";
      } else {
        notfirst = true;
      }
      query_str += p->to_string();
    }
  }
  if (having_clause_) {
    query_str += " HAVING " + having_clause_->to_string();
  }
  query_str += ";";
  return query_str;
}

Member Data Documentation

std::list<std::unique_ptr<TableRef> > Parser::QuerySpec::from_clause_

private

Definition at line 1766 of file ParserNode.h.

Referenced by get_from_clause(), and QuerySpec().

std::list<std::unique_ptr<Expr> > Parser::QuerySpec::groupby_clause_

private

Definition at line 1768 of file ParserNode.h.

Referenced by get_groupby_clause(), and QuerySpec().

std::unique_ptr<Expr> Parser::QuerySpec::having_clause_

private

Definition at line 1769 of file ParserNode.h.

Referenced by get_having_clause().

bool Parser::QuerySpec::is_distinct_

private

Definition at line 1764 of file ParserNode.h.

Referenced by get_is_distinct().

std::list<std::unique_ptr<SelectEntry> > Parser::QuerySpec::select_clause_

private

Definition at line 1765 of file ParserNode.h.

Referenced by get_select_clause(), and QuerySpec().

std::unique_ptr<Expr> Parser::QuerySpec::where_clause_

private

Definition at line 1767 of file ParserNode.h.

Referenced by get_where_clause().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.h
• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.cpp