Parser::FunctionRef Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::FunctionRef:

Collaboration diagram for Parser::FunctionRef:

Public Member Functions
	FunctionRef (std::string *n)
	FunctionRef (std::string *n, Expr *a)
	FunctionRef (std::string *n, bool d, Expr *a)
const std::string *	get_name () const
bool	get_distinct () const
Expr *	get_arg () 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 >	name
bool	distinct
std::unique_ptr< Expr >	arg

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

Detailed Description

Definition at line 617 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::FunctionRef::FunctionRef ( std::string *  n )

inlineexplicit

Definition at line 619 of file ParserNode.h.

: name(n), distinct(false), arg(nullptr) {}

Parser::FunctionRef::FunctionRef ( std::string *  n, Expr *  a  )

inline

Definition at line 620 of file ParserNode.h.

: name(n), distinct(false), arg(a) {}

Parser::FunctionRef::FunctionRef ( std::string *  n, bool  d, Expr *  a  )

inline

Definition at line 621 of file ParserNode.h.

: name(n), distinct(d), arg(a) {}

Member Function Documentation

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

overridevirtual

Implements Parser::Expr.

Definition at line 785 of file ParserNode.cpp.

References SQLTypeInfo::get_compression(), SQLTypeInfo::get_elem_type(), Analyzer::Query::get_num_aggs(), SQLTypeInfo::get_type(), anonymous_namespace{RelAlgOptimizer.cpp}::is_distinct(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), kARRAY, kAVG, kBIGINT, kCOUNT, kDOUBLE, kENCODING_DICT, kMAX, kMIN, kSUM, kUNNEST, setup::name, and Analyzer::Query::set_num_aggs().

                                        {
  SQLTypeInfo result_type;
  SQLAgg agg_type;
  std::shared_ptr<Analyzer::Expr> arg_expr;
  bool is_distinct = false;
  if (boost::iequals(*name, "count")) {
    result_type = SQLTypeInfo(kBIGINT, false);
    agg_type = kCOUNT;
    if (arg) {
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      const SQLTypeInfo& ti = arg_expr->get_type_info();
      if (ti.is_string() && (ti.get_compression() != kENCODING_DICT || !distinct)) {
        throw std::runtime_error(
            "Strings must be dictionary-encoded in COUNT(DISTINCT).");
      }
      if (ti.get_type() == kARRAY && !distinct) {
        throw std::runtime_error("Only COUNT(DISTINCT) is supported on arrays.");
      }
    }
    is_distinct = distinct;
  } else {
    if (!arg) {
      throw std::runtime_error("Cannot compute " + *name + " with argument '*'.");
    }
    if (boost::iequals(*name, "min")) {
      agg_type = kMIN;
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      arg_expr = arg_expr->decompress();
      result_type = arg_expr->get_type_info();
    } else if (boost::iequals(*name, "max")) {
      agg_type = kMAX;
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      arg_expr = arg_expr->decompress();
      result_type = arg_expr->get_type_info();
    } else if (boost::iequals(*name, "avg")) {
      agg_type = kAVG;
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      if (!arg_expr->get_type_info().is_number()) {
        throw std::runtime_error("Cannot compute AVG on non-number-type arguments.");
      }
      arg_expr = arg_expr->decompress();
      result_type = SQLTypeInfo(kDOUBLE, false);
    } else if (boost::iequals(*name, "sum")) {
      agg_type = kSUM;
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      if (!arg_expr->get_type_info().is_number()) {
        throw std::runtime_error("Cannot compute SUM on non-number-type arguments.");
      }
      arg_expr = arg_expr->decompress();
      result_type = arg_expr->get_type_info().is_integer() ? SQLTypeInfo(kBIGINT, false)
                                                           : arg_expr->get_type_info();
    } else if (boost::iequals(*name, "unnest")) {
      arg_expr = arg->analyze(catalog, query, allow_tlist_ref);
      const SQLTypeInfo& arg_ti = arg_expr->get_type_info();
      if (arg_ti.get_type() != kARRAY) {
        throw std::runtime_error(arg->to_string() + " is not of array type.");
      }
      return makeExpr<Analyzer::UOper>(arg_ti.get_elem_type(), false, kUNNEST, arg_expr);
    } else {
      throw std::runtime_error("invalid function name: " + *name);
    }
    if (arg_expr->get_type_info().is_string() ||
        arg_expr->get_type_info().get_type() == kARRAY) {
      throw std::runtime_error(
          "Only COUNT(DISTINCT ) aggregate is supported on strings and arrays.");
    }
  }
  int naggs = query.get_num_aggs();
  query.set_num_aggs(naggs + 1);
  return makeExpr<Analyzer::AggExpr>(
      result_type, agg_type, arg_expr, is_distinct, nullptr);
}

Here is the call graph for this function:

Expr* Parser::FunctionRef::get_arg ( ) const

inline

Definition at line 624 of file ParserNode.h.

References arg.

{ return arg.get(); }

bool Parser::FunctionRef::get_distinct ( ) const

inline

Definition at line 623 of file ParserNode.h.

References distinct.

{ return distinct; }

const std::string* Parser::FunctionRef::get_name ( ) const

inline

Definition at line 622 of file ParserNode.h.

References name.

{ return name.get(); }

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

overridevirtual

Implements Parser::Expr.

Definition at line 1420 of file ParserNode.cpp.

References setup::name.

                                       {
  std::string str = *name + "(";
  if (distinct) {
    str += "DISTINCT ";
  }
  if (arg == nullptr) {
    str += "*)";
  } else {
    str += arg->to_string() + ")";
  }
  return str;
}

Member Data Documentation

std::unique_ptr<Expr> Parser::FunctionRef::arg

private

Definition at line 634 of file ParserNode.h.

Referenced by get_arg().

bool Parser::FunctionRef::distinct

private

Definition at line 633 of file ParserNode.h.

Referenced by get_distinct().

std::unique_ptr<std::string> Parser::FunctionRef::name

private

Definition at line 632 of file ParserNode.h.

Referenced by get_name(), omnisci.extension_functions.ttypes.TUserDefinedFunction::read(), omnisci.extension_functions.ttypes.TUserDefinedTableFunction::read(), omnisci.thrift.ttypes.TDashboardGrantees::read(), omnisci.thrift.ttypes.TGeoFileLayerInfo::read(), omnisci.extension_functions.ttypes.TUserDefinedFunction::write(), omnisci.extension_functions.ttypes.TUserDefinedTableFunction::write(), omnisci.thrift.ttypes.TDashboardGrantees::write(), and omnisci.thrift.ttypes.TGeoFileLayerInfo::write().

---

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