QueryPlanDagChecker Class Reference

#include <QueryPlanDagChecker.h>

Inheritance diagram for QueryPlanDagChecker:

Collaboration diagram for QueryPlanDagChecker:

Public Member Functions
	QueryPlanDagChecker ()
void	check (const RelAlgNode *)
void	detectNonSupportedNode (const std::string &node_tag)
void	reset ()
bool	getCheckResult () const
std::string const &	getNonSupportedNodeTag () const
Public Member Functions inherited from RelRexDagVisitor
virtual	~RelRexDagVisitor ()=default
virtual void	visit (RelAlgNode const *)
virtual void	visit (RexScalar const *)

Static Public Member Functions
static std::unordered_set < std::string >	getNonSupportedFunctionsList ()
static std::pair< bool, std::string >	hasNonSupportedNodeInDag (const RelAlgNode *rel_alg_node)

Private Member Functions
void	visit (const RelLogicalValues *) override
void	visit (const RelModify *) override
void	visit (const RelProject *) override
void	visit (const RelScan *) override
void	visit (const RelCompound *) override
void	visit (const RelLogicalUnion *) override
void	visit (const RexFunctionOperator *) override
void	visit (const RexOperator *) override

Private Attributes
bool	detect_non_supported_node_
std::string	non_supported_node_tag_
const std::unordered_set < std::string >	non_supported_functions_

Additional Inherited Members
Protected Member Functions inherited from RelRexDagVisitor
virtual void	visit (RelAggregate const *)
virtual void	visit (RelFilter const *)
virtual void	visit (RelJoin const *)
virtual void	visit (RelLeftDeepInnerJoin const *)
virtual void	visit (RelSort const *)
virtual void	visit (RelTableFunction const *)
virtual void	visit (RelTranslatedJoin const *)
virtual void	visit (RexAbstractInput const *)
virtual void	visit (RexCase const *)
virtual void	visit (RexInput const *)
virtual void	visit (RexLiteral const *)
virtual void	visit (RexRef const *)
virtual void	visit (RexSubQuery const *)
virtual void	visit (RexWindowFunctionOperator const *)
void	castAndVisit (RelAlgNode const *)

Detailed Description

Definition at line 25 of file QueryPlanDagChecker.h.

Constructor & Destructor Documentation

QueryPlanDagChecker::QueryPlanDagChecker ( )

inline

Definition at line 27 of file QueryPlanDagChecker.h.

      : detect_non_supported_node_(false)
      , non_supported_node_tag_("")
      , non_supported_functions_(getNonSupportedFunctionsList()) {}

Member Function Documentation

void QueryPlanDagChecker::check

(

const RelAlgNode *

rel_alg_node

)

Definition at line 35 of file QueryPlanDagChecker.cpp.

References RelRexDagVisitor::visit().

Referenced by hasNonSupportedNodeInDag().

                                                              {
  RelRexDagVisitor::visit(rel_alg_node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QueryPlanDagChecker::detectNonSupportedNode

(

const std::string &

node_tag

)

Definition at line 23 of file QueryPlanDagChecker.cpp.

References detect_non_supported_node_, and non_supported_node_tag_.

Referenced by visit().

                                                                          {
  detect_non_supported_node_ = true;
  non_supported_node_tag_ = node_tag;
}

Here is the caller graph for this function:

bool QueryPlanDagChecker::getCheckResult

(

)

const

Definition at line 19 of file QueryPlanDagChecker.cpp.

References detect_non_supported_node_.

Referenced by hasNonSupportedNodeInDag(), and visit().

                                               {
  return detect_non_supported_node_;
}

Here is the caller graph for this function:

static std::unordered_set<std::string> QueryPlanDagChecker::getNonSupportedFunctionsList ( )

inlinestatic

Definition at line 31 of file QueryPlanDagChecker.h.

                                                                    {
    std::unordered_set<std::string> non_supported_functions;
    non_supported_functions.emplace("CURRENT_USER");
    non_supported_functions.emplace("CURRENT_TIME");
    non_supported_functions.emplace("CURRENT_DATE");
    non_supported_functions.emplace("CURRENT_TIMESTAMP");
    non_supported_functions.emplace("CARDINALITY");
    non_supported_functions.emplace("ARRAY_LENGTH");
    non_supported_functions.emplace("ITEM");
    non_supported_functions.emplace("NOW");
    non_supported_functions.emplace("SIGN");
    non_supported_functions.emplace("OFFSET_IN_FRAGMENT");
    non_supported_functions.emplace("DATETIME");
    return non_supported_functions;
  }

const std::string & QueryPlanDagChecker::getNonSupportedNodeTag

(

)

const

Definition at line 134 of file QueryPlanDagChecker.cpp.

References non_supported_node_tag_.

Referenced by hasNonSupportedNodeInDag().

                                                                   {
  return non_supported_node_tag_;
}

Here is the caller graph for this function:

std::pair< bool, std::string > QueryPlanDagChecker::hasNonSupportedNodeInDag ( const RelAlgNode *  rel_alg_node )

static

Definition at line 28 of file QueryPlanDagChecker.cpp.

References check(), getCheckResult(), and getNonSupportedNodeTag().

Referenced by QueryPlanDagExtractor::extractQueryPlanDag().

                                    {
  QueryPlanDagChecker checker;
  checker.check(rel_alg_node);
  return std::make_pair(checker.getCheckResult(), checker.getNonSupportedNodeTag());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QueryPlanDagChecker::reset

(

)

Definition at line 129 of file QueryPlanDagChecker.cpp.

References detect_non_supported_node_, and non_supported_node_tag_.

                                {
  detect_non_supported_node_ = false;
  non_supported_node_tag_ = "";
}

void QueryPlanDagChecker::visit ( const RelLogicalValues *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 39 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode().

                                                                    {
  detectNonSupportedNode("Detect RelLogicalValues node");
  return;
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RelModify *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 44 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode().

                                                             {
  detectNonSupportedNode("Detect RelModify node");
  return;
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RelProject *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 49 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode(), ModifyManipulationTarget::isDeleteViaSelect(), ModifyManipulationTarget::isUpdateViaSelect(), ModifyManipulationTarget::isVarlenUpdateRequired(), and RelRexDagVisitor::visit().

                                                              {
  if (rel_alg_node->isDeleteViaSelect() || rel_alg_node->isUpdateViaSelect() ||
      rel_alg_node->isVarlenUpdateRequired()) {
    detectNonSupportedNode("Executing UPDATE/MODIFY/DELETE query");
    return;
  }
  RelRexDagVisitor::visit(rel_alg_node);
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RelScan *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 87 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode(), RelScan::getTableDescriptor(), TableDescriptor::is_system_table, TableDescriptor::isForeignTable(), TableDescriptor::isTemporaryTable(), and RelRexDagVisitor::visit().

                                                           {
  if (rel_alg_node->getTableDescriptor()->isForeignTable()) {
    detectNonSupportedNode("Detect foreign table");
    return;
  }
  if (rel_alg_node->getTableDescriptor()->isTemporaryTable()) {
    detectNonSupportedNode("Detect temporary table");
  }

  if (rel_alg_node->getTableDescriptor()->is_system_table) {
    detectNonSupportedNode("Detect system table");
  }
  RelRexDagVisitor::visit(rel_alg_node);
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RelCompound *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 58 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode(), RelCompound::getTargetExpr(), RelCompound::isAggregate(), ModifyManipulationTarget::isDeleteViaSelect(), ModifyManipulationTarget::isUpdateViaSelect(), ModifyManipulationTarget::isVarlenUpdateRequired(), kAPPROX_QUANTILE, kSAMPLE, kSINGLE_VALUE, RelCompound::size(), and RelRexDagVisitor::visit().

                                                               {
  if (rel_alg_node->isDeleteViaSelect() || rel_alg_node->isUpdateViaSelect() ||
      rel_alg_node->isVarlenUpdateRequired()) {
    detectNonSupportedNode("Executing UPDATE/MODIFY/DELETE query");
    return;
  }
  // SINGLE_VALUE / SAMPLE query
  if (rel_alg_node->isAggregate() && rel_alg_node->size() > 0) {
    for (size_t i = 0; i < rel_alg_node->size(); ++i) {
      auto target_expr = rel_alg_node->getTargetExpr(i);
      auto agg_expr = dynamic_cast<const RexAgg*>(target_expr);
      if (agg_expr && (agg_expr->getKind() == SQLAgg::kSINGLE_VALUE ||
                       agg_expr->getKind() == SQLAgg::kSAMPLE ||
                       agg_expr->getKind() == SQLAgg::kAPPROX_QUANTILE)) {
        detectNonSupportedNode(
            "Detect non-supported aggregation function: "
            "SINGLE_VALUE/SAMPLE/APPROX_QUANTILE");
        return;
      }
    }
  }
  RelRexDagVisitor::visit(rel_alg_node);
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RelLogicalUnion *  rel_alg_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 82 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode().

                                                                   {
  detectNonSupportedNode("Detect RelLogicalUnion node");
  return;
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RexFunctionOperator *  rex_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 115 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode(), getCheckResult(), RexFunctionOperator::getName(), RexOperator::getOperand(), non_supported_functions_, RexOperator::size(), and RelRexDagVisitor::visit().

                                                                   {
  if (non_supported_functions_.count(rex_node->getName())) {
    detectNonSupportedNode("Detect non-supported function: " + rex_node->getName());
  }
  if (getCheckResult()) {
    return;
  }
  for (size_t i = 0; i < rex_node->size(); ++i) {
    if (rex_node->getOperand(i)) {
      RelRexDagVisitor::visit(rex_node->getOperand(i));
    }
  }
}

Here is the call graph for this function:

void QueryPlanDagChecker::visit ( const RexOperator *  rex_node )

overrideprivatevirtual

Reimplemented from RelRexDagVisitor.

Definition at line 102 of file QueryPlanDagChecker.cpp.

References detectNonSupportedNode(), RexOperator::getOperand(), RexOperator::getOperator(), kOR, RexOperator::size(), and RelRexDagVisitor::visit().

                                                           {
  // prevent too heavy IN clause containing more than 20 values to check
  if (rex_node->getOperator() == SQLOps::kOR && rex_node->size() > 20) {
    detectNonSupportedNode("Detect heavy IN-clause having more than 20 values");
    return;
  }
  for (size_t i = 0; i < rex_node->size(); ++i) {
    if (rex_node->getOperand(i)) {
      RelRexDagVisitor::visit(rex_node->getOperand(i));
    }
  }
}

Here is the call graph for this function:

Member Data Documentation

bool QueryPlanDagChecker::detect_non_supported_node_

private

Definition at line 66 of file QueryPlanDagChecker.h.

Referenced by detectNonSupportedNode(), getCheckResult(), and reset().

const std::unordered_set<std::string> QueryPlanDagChecker::non_supported_functions_

private

Definition at line 68 of file QueryPlanDagChecker.h.

Referenced by visit().

std::string QueryPlanDagChecker::non_supported_node_tag_

private

Definition at line 67 of file QueryPlanDagChecker.h.

Referenced by detectNonSupportedNode(), getNonSupportedNodeTag(), and reset().

---

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

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