RelAggregate Class Reference

#include <RelAlgDag.h>

Inheritance diagram for RelAggregate:

Collaboration diagram for RelAggregate:

Public Member Functions
	RelAggregate ()
	RelAggregate (const size_t groupby_count, std::vector< std::unique_ptr< const RexAgg >> &agg_exprs, const std::vector< std::string > &fields, std::shared_ptr< const RelAlgNode > input)
	RelAggregate (RelAggregate const &)
size_t	size () const override
const size_t	getGroupByCount () const
const size_t	getAggExprsCount () const
const std::vector< std::string > &	getFields () const
void	setFields (std::vector< std::string > &&new_fields)
const std::string	getFieldName (const size_t i) const
std::vector< const RexAgg * >	getAggregatesAndRelease ()
std::vector< std::unique_ptr < const RexAgg > >	getAggExprsAndRelease ()
const std::vector < std::unique_ptr< const RexAgg > > &	getAggExprs () const
void	setAggExprs (std::vector< std::unique_ptr< const RexAgg >> &agg_exprs)
std::string	toString (RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override
size_t	toHash () const override
std::shared_ptr< RelAlgNode >	deepCopy () const override
void	addHint (const ExplainedQueryHint &hint_explained)
const bool	hasHintEnabled (QueryHint candidate_hint) const
const ExplainedQueryHint &	getHintInfo (QueryHint hint) const
bool	hasDeliveredHint ()
Hints *	getDeliveredHints ()
Public Member Functions inherited from RelAlgNode
	RelAlgNode (RelAlgInputs inputs={})
virtual	~RelAlgNode ()
void	resetQueryExecutionState ()
void	setContextData (const RaExecutionDesc *context_data) const
void	setOutputMetainfo (std::vector< TargetMetaInfo > targets_metainfo) const
void	setQueryPlanDag (const std::string &extracted_query_plan_dag) const
std::string	getQueryPlanDag () const
size_t	getQueryPlanDagHash () const
const std::vector < TargetMetaInfo > &	getOutputMetainfo () const
unsigned	getId () const
void	setIdInPlanTree (size_t id) const
std::optional< size_t >	getIdInPlanTree () const
bool	hasContextData () const
const RaExecutionDesc *	getContextData () const
const size_t	inputCount () const
const RelAlgNode *	getInput (const size_t idx) const
std::shared_ptr< const RelAlgNode >	getAndOwnInput (const size_t idx) const
void	addManagedInput (std::shared_ptr< const RelAlgNode > input)
bool	hasInput (const RelAlgNode *needle) const
virtual void	replaceInput (std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input)
void	setRelNodeDagId (const size_t id) const
size_t	getRelNodeDagId () const
bool	isNop () const
void	markAsNop ()
void	clearContextData () const

Private Attributes
size_t	groupby_count_
std::vector< std::unique_ptr < const RexAgg > >	agg_exprs_
std::vector< std::string >	fields_
bool	hint_applied_
std::unique_ptr< Hints >	hints_

Friends
struct	RelAlgDagSerializer

Additional Inherited Members
Static Public Member Functions inherited from RelAlgNode
static void	resetRelAlgFirstId () noexcept
Protected Attributes inherited from RelAlgNode
RelAlgInputs	inputs_
unsigned	id_
std::optional< size_t >	id_in_plan_tree_
std::optional< size_t >	hash_

Detailed Description

Definition at line 1320 of file RelAlgDag.h.

Constructor & Destructor Documentation

RelAggregate::RelAggregate ( )

inline

Definition at line 1323 of file RelAlgDag.h.

Referenced by toHash().

: groupby_count_{0}, hint_applied_{false} {}

Here is the caller graph for this function:

RelAggregate::RelAggregate ( const size_t  groupby_count, std::vector< std::unique_ptr< const RexAgg >> &  agg_exprs, const std::vector< std::string > &  fields, std::shared_ptr< const RelAlgNode >  input  )

inline

Definition at line 1326 of file RelAlgDag.h.

References RelAlgNode::inputs_.

      : groupby_count_(groupby_count)
      , agg_exprs_(std::move(agg_exprs))
      , fields_(fields)
      , hint_applied_(false)
      , hints_(std::make_unique<Hints>()) {
    inputs_.push_back(input);
  }

RelAggregate::RelAggregate

(

RelAggregate const &

rhs

)

Definition at line 583 of file RelAlgDag.cpp.

References addHint(), agg_exprs_, hint_applied_, and hints_.

    : RelAlgNode(rhs)
    , groupby_count_(rhs.groupby_count_)
    , fields_(rhs.fields_)
    , hint_applied_(false)
    , hints_(std::make_unique<Hints>()) {
  agg_exprs_.reserve(rhs.agg_exprs_.size());
  for (auto const& agg : rhs.agg_exprs_) {
    agg_exprs_.push_back(agg->deepCopy());
  }
  if (rhs.hint_applied_) {
    for (auto const& kv : *rhs.hints_) {
      addHint(kv.second);
    }
  }
}

Here is the call graph for this function:

Member Function Documentation

void RelAggregate::addHint ( const ExplainedQueryHint &  hint_explained )

inline

Definition at line 1416 of file RelAlgDag.h.

References ExplainedQueryHint::getHint(), hint_applied_, and hints_.

Referenced by RelAggregate().

                                                         {
    if (!hint_applied_) {
      hint_applied_ = true;
    }
    hints_->emplace(hint_explained.getHint(), hint_explained);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelAlgNode> RelAggregate::deepCopy ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1412 of file RelAlgDag.h.

                                                      {
    return std::make_shared<RelAggregate>(*this);
  }

const std::vector<std::unique_ptr<const RexAgg> >& RelAggregate::getAggExprs ( ) const

inline

Definition at line 1365 of file RelAlgDag.h.

References agg_exprs_.

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs(), and anonymous_namespace{RelAlgExecutor.cpp}::translate_targets().

                                                                    {
    return agg_exprs_;
  }

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexAgg> > RelAggregate::getAggExprsAndRelease ( )

inline

Definition at line 1361 of file RelAlgDag.h.

References agg_exprs_.

                                                                 {
    return std::move(agg_exprs_);
  }

const size_t RelAggregate::getAggExprsCount ( ) const

inline

Definition at line 1344 of file RelAlgDag.h.

References agg_exprs_.

{ return agg_exprs_.size(); }

std::vector<const RexAgg*> RelAggregate::getAggregatesAndRelease ( )

inline

Definition at line 1353 of file RelAlgDag.h.

References agg_exprs_, and run_benchmark_import::result.

                                                     {
    std::vector<const RexAgg*> result;
    for (auto& agg_expr : agg_exprs_) {
      result.push_back(agg_expr.release());
    }
    return result;
  }

Hints* RelAggregate::getDeliveredHints ( )

inline

Definition at line 1439 of file RelAlgDag.h.

References hints_.

Referenced by anonymous_namespace{RelAlgDag.cpp}::handle_query_hint().

{ return hints_.get(); }

Here is the caller graph for this function:

const std::string RelAggregate::getFieldName ( const size_t  i ) const

inline

Definition at line 1351 of file RelAlgDag.h.

References fields_.

{ return fields_[i]; }

const std::vector<std::string>& RelAggregate::getFields ( ) const

inline

Definition at line 1346 of file RelAlgDag.h.

References fields_.

{ return fields_; }

const size_t RelAggregate::getGroupByCount ( ) const

inline

Definition at line 1342 of file RelAlgDag.h.

References groupby_count_.

Referenced by anonymous_namespace{RelAlgDag.cpp}::add_window_function_pre_project(), anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs(), and anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs().

{ return groupby_count_; }

Here is the caller graph for this function:

const ExplainedQueryHint& RelAggregate::getHintInfo ( QueryHint  hint ) const

inline

Definition at line 1430 of file RelAlgDag.h.

References CHECK, hasHintEnabled(), hint_applied_, and hints_.

                                                              {
    CHECK(hint_applied_);
    CHECK(!hints_->empty());
    CHECK(hasHintEnabled(hint));
    return hints_->at(hint);
  }

Here is the call graph for this function:

bool RelAggregate::hasDeliveredHint ( )

inline

Definition at line 1437 of file RelAlgDag.h.

References hints_.

{ return !hints_->empty(); }

const bool RelAggregate::hasHintEnabled ( QueryHint  candidate_hint ) const

inline

Definition at line 1423 of file RelAlgDag.h.

References hint_applied_, and hints_.

Referenced by getHintInfo().

                                                            {
    if (hint_applied_ && !hints_->empty()) {
      return hints_->find(candidate_hint) != hints_->end();
    }
    return false;
  }

Here is the caller graph for this function:

void RelAggregate::setAggExprs ( std::vector< std::unique_ptr< const RexAgg >> &  agg_exprs )

inline

Definition at line 1369 of file RelAlgDag.h.

References agg_exprs_.

                                                                      {
    agg_exprs_ = std::move(agg_exprs);
  }

void RelAggregate::setFields ( std::vector< std::string > &&  new_fields )

inline

Definition at line 1347 of file RelAlgDag.h.

References fields_.

                                                    {
    fields_ = std::move(new_fields);
  }

size_t RelAggregate::size ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1340 of file RelAlgDag.h.

References agg_exprs_, and groupby_count_.

{ return groupby_count_ + agg_exprs_.size(); }

size_t RelAggregate::toHash ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1397 of file RelAlgDag.h.

References agg_exprs_, fields_, groupby_count_, RelAlgNode::hash_, RelAlgNode::inputs_, RelAggregate(), and toString().

                                 {
    if (!hash_) {
      hash_ = typeid(RelAggregate).hash_code();
      boost::hash_combine(*hash_, groupby_count_);
      for (auto& agg_expr : agg_exprs_) {
        boost::hash_combine(*hash_, agg_expr->toHash());
      }
      for (auto& node : inputs_) {
        boost::hash_combine(*hash_, node->toHash());
      }
      boost::hash_combine(*hash_, ::toString(fields_));
    }
    return *hash_;
  }

Here is the call graph for this function:

std::string RelAggregate::toString ( RelRexToStringConfig  config = RelRexToStringConfig::defaults() ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1373 of file RelAlgDag.h.

References agg_exprs_, cat(), fields_, groupby_count_, RelAlgNode::inputs_, to_string(), and typeName().

Referenced by toHash().

                                                                                   {
    auto ret = cat(::typeName(this),
                   "(",
                   std::to_string(groupby_count_),
                   ", agg_exprs=",
                   ::toString(agg_exprs_),
                   ", fields=",
                   ::toString(fields_));
    if (!config.skip_input_nodes) {
      ret += ::toString(inputs_);
    } else {
      ret += ", input node id={";
      for (auto& input : inputs_) {
        auto node_id_in_plan = input->getIdInPlanTree();
        auto node_id_str = node_id_in_plan ? std::to_string(*node_id_in_plan)
                                           : std::to_string(input->getId());
        ret += node_id_str + " ";
      }
      ret += "}";
    }
    return cat(ret, ")");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend struct RelAlgDagSerializer

friend

Definition at line 1448 of file RelAlgDag.h.

Member Data Documentation

std::vector<std::unique_ptr<const RexAgg> > RelAggregate::agg_exprs_

private

Definition at line 1443 of file RelAlgDag.h.

Referenced by getAggExprs(), getAggExprsAndRelease(), getAggExprsCount(), getAggregatesAndRelease(), RelAggregate(), setAggExprs(), size(), toHash(), and toString().

std::vector<std::string> RelAggregate::fields_

private

Definition at line 1444 of file RelAlgDag.h.

Referenced by getFieldName(), getFields(), setFields(), toHash(), and toString().

size_t RelAggregate::groupby_count_

private

Definition at line 1442 of file RelAlgDag.h.

Referenced by getGroupByCount(), size(), toHash(), and toString().

bool RelAggregate::hint_applied_

private

Definition at line 1445 of file RelAlgDag.h.

Referenced by addHint(), getHintInfo(), hasHintEnabled(), and RelAggregate().

std::unique_ptr<Hints> RelAggregate::hints_

private

Definition at line 1446 of file RelAlgDag.h.

Referenced by addHint(), getDeliveredHints(), getHintInfo(), hasDeliveredHint(), hasHintEnabled(), and RelAggregate().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.cpp