Parser::ColumnRef Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::ColumnRef:

Collaboration diagram for Parser::ColumnRef:

Public Member Functions
	ColumnRef (std::string *n1)
	ColumnRef (std::string *n1, std::string *n2)
const std::string *	get_table () const
const std::string *	get_column () const
std::shared_ptr< Analyzer::Expr >	analyze (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
std::string	to_string () const override
Public Member Functions inherited from Parser::Node
virtual	~Node ()

Private Attributes
std::unique_ptr< std::string >	table_
std::unique_ptr< std::string >	column_

Additional Inherited Members
Public Types inherited from Parser::Expr
enum	TlistRefType { TLIST_NONE, TLIST_REF, TLIST_COPY }

Detailed Description

Definition at line 628 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::ColumnRef::ColumnRef ( std::string *  n1 )

inlineexplicit

Definition at line 630 of file ParserNode.h.

: table_(nullptr), column_(n1) {}

Parser::ColumnRef::ColumnRef ( std::string *  n1, std::string *  n2  )

inline

Definition at line 631 of file ParserNode.h.

: table_(n1), column_(n2) {}

Member Function Documentation

std::shared_ptr< Analyzer::Expr > Parser::ColumnRef::analyze ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query, TlistRefType  allow_tlist_ref = TLIST_NONE  ) const

overridevirtual

Implements Parser::Expr.

Definition at line 888 of file ParserNode.cpp.

References Analyzer::Var::deep_copy(), Analyzer::RangeTableEntry::get_column_desc(), Analyzer::Query::get_rangetable(), Analyzer::Query::get_rte(), Analyzer::Query::get_rte_idx(), Analyzer::RangeTableEntry::get_table_id(), Analyzer::Query::get_targetlist(), Analyzer::Var::get_which_row(), Catalog_Namespace::Catalog::getDatabaseId(), Analyzer::Var::kGROUPBY, and Analyzer::Var::kOUTPUT.

                                        {
  int table_id{0};
  int rte_idx{0};
  const ColumnDescriptor* cd{nullptr};
  if (column_ == nullptr) {
    throw std::runtime_error("invalid column name *.");
  }
  if (table_ != nullptr) {
    rte_idx = query.get_rte_idx(*table_);
    if (rte_idx < 0) {
      throw std::runtime_error("range variable or table name " + *table_ +
                               " does not exist.");
    }
    Analyzer::RangeTableEntry* rte = query.get_rte(rte_idx);
    cd = rte->get_column_desc(catalog, *column_);
    if (cd == nullptr) {
      throw std::runtime_error("Column name " + *column_ + " does not exist.");
    }
    table_id = rte->get_table_id();
  } else {
    bool found = false;
    int i = 0;
    for (auto rte : query.get_rangetable()) {
      cd = rte->get_column_desc(catalog, *column_);
      if (cd != nullptr && !found) {
        found = true;
        rte_idx = i;
        table_id = rte->get_table_id();
      } else if (cd != nullptr && found) {
        throw std::runtime_error("Column name " + *column_ + " is ambiguous.");
      }
      i++;
    }
    if (cd == nullptr && allow_tlist_ref != TlistRefType::TLIST_NONE) {
      // check if this is a reference to a targetlist entry
      bool found = false;
      int varno = -1;
      int i = 1;
      std::shared_ptr<Analyzer::TargetEntry> tle;
      for (auto p : query.get_targetlist()) {
        if (*column_ == p->get_resname() && !found) {
          found = true;
          varno = i;
          tle = p;
        } else if (*column_ == p->get_resname() && found) {
          throw std::runtime_error("Output alias " + *column_ + " is ambiguous.");
        }
        i++;
      }
      if (found) {
        if (dynamic_cast<Analyzer::Var*>(tle->get_expr())) {
          Analyzer::Var* v = static_cast<Analyzer::Var*>(tle->get_expr());
          if (v->get_which_row() == Analyzer::Var::kGROUPBY) {
            return v->deep_copy();
          }
        }
        if (allow_tlist_ref == TlistRefType::TLIST_COPY) {
          return tle->get_expr()->deep_copy();
        } else {
          return makeExpr<Analyzer::Var>(
              tle->get_expr()->get_type_info(), Analyzer::Var::kOUTPUT, varno);
        }
      }
    }
    if (cd == nullptr) {
      throw std::runtime_error("Column name " + *column_ + " does not exist.");
    }
  }
  return makeExpr<Analyzer::ColumnVar>(
      cd->columnType,
      shared::ColumnKey{catalog.getDatabaseId(), table_id, cd->columnId},
      rte_idx);
}

Here is the call graph for this function:

const std::string* Parser::ColumnRef::get_column ( ) const

inline

Definition at line 633 of file ParserNode.h.

References column_.

{ return column_.get(); }

const std::string* Parser::ColumnRef::get_table ( ) const

inline

Definition at line 632 of file ParserNode.h.

References table_.

{ return table_.get(); }

std::string Parser::ColumnRef::to_string ( ) const

overridevirtual

Implements Parser::Expr.

Definition at line 2143 of file ParserNode.cpp.

                                     {
  std::string str;
  if (table_ == nullptr) {
    str = *column_;
  } else if (column_ == nullptr) {
    str = *table_ + ".*";
  } else {
    str = *table_ + "." + *column_;
  }
  return str;
}

Member Data Documentation

std::unique_ptr<std::string> Parser::ColumnRef::column_

private

Definition at line 642 of file ParserNode.h.

Referenced by get_column().

std::unique_ptr<std::string> Parser::ColumnRef::table_

private

Definition at line 641 of file ParserNode.h.

Referenced by get_table().

---

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