ExpressionRewrite.h File Reference

#include <llvm/IR/Value.h>
#include <boost/optional.hpp>
#include <list>
#include <memory>
#include <vector>
#include "Analyzer/Analyzer.h"
#include "RelAlgExecutionUnit.h"

Include dependency graph for ExpressionRewrite.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	BoundingBoxIntersectJoinConjunction
struct	BoundingBoxIntersectJoinTranslationInfo
struct	BoundingBoxIntersectJoinTranslationResult
struct	BoundingBoxIntersectJoinSupportedFunction

Namespaces
	Analyzer

Enumerations
enum	BoundingBoxIntersectJoinRewriteType { BoundingBoxIntersectJoinRewriteType::BBOX_INTERSECT_JOIN, BoundingBoxIntersectJoinRewriteType::RANGE_JOIN, BoundingBoxIntersectJoinRewriteType::UNKNOWN }

Functions
Analyzer::ExpressionPtr	rewrite_expr (const Analyzer::Expr *)
Analyzer::ExpressionPtr	rewrite_array_elements (const Analyzer::Expr *)
BoundingBoxIntersectJoinTranslationResult	translate_bbox_intersect_with_reordering (const std::shared_ptr< Analyzer::Expr > expr, std::vector< InputDescriptor > const &input_descs, std::unordered_map< const RelAlgNode *, int > const &input_to_nest_level, std::vector< size_t > const &input_permutation, std::list< std::shared_ptr< const InputColDescriptor >> &input_col_desc, const BoundingBoxIntersectJoinRewriteType rewrite_type, Executor const *executor)
BoundingBoxIntersectJoinTranslationInfo	convert_bbox_intersect_join (JoinQualsPerNestingLevel const &join_quals, std::vector< InputDescriptor > &input_descs, std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, std::vector< size_t > &input_permutation, std::list< std::shared_ptr< const InputColDescriptor >> &input_col_desc, Executor const *executor)
std::list< std::shared_ptr < Analyzer::Expr > >	strip_join_covered_filter_quals (const std::list< std::shared_ptr< Analyzer::Expr >> &quals, const JoinQualsPerNestingLevel &join_quals)
std::shared_ptr< Analyzer::Expr >	fold_expr (const Analyzer::Expr *)
bool	self_join_not_covered_by_left_deep_tree (const Analyzer::ColumnVar *lhs, const Analyzer::ColumnVar *rhs, const int max_rte_covered)
const int	get_max_rte_scan_table (std::unordered_map< int, llvm::Value * > &scan_idx_to_hash_pos)
size_t	get_table_cardinality (shared::TableKey const &table_key, Executor const *executor)

Enumeration Type Documentation

enum BoundingBoxIntersectJoinRewriteType

strong

Enumerator
BBOX_INTERSECT_JOIN
RANGE_JOIN
UNKNOWN

Definition at line 67 of file ExpressionRewrite.h.

                                               {
  BBOX_INTERSECT_JOIN,
  RANGE_JOIN,
  UNKNOWN
};

Function Documentation

BoundingBoxIntersectJoinTranslationInfo convert_bbox_intersect_join	(	JoinQualsPerNestingLevel const &	join_quals,
		std::vector< InputDescriptor > &	input_descs,
		std::unordered_map< const RelAlgNode *, int > &	input_to_nest_level,
		std::vector< size_t > &	input_permutation,
		std::list< std::shared_ptr< const InputColDescriptor >> &	input_col_desc,
		Executor const *	executor
	)

Definition at line 1217 of file ExpressionRewrite.cpp.

References BBOX_INTERSECT_JOIN, BoundingBoxIntersectJoinTranslationResult::converted_bbox_intersect_join_info, g_enable_bbox_intersect_hashjoin, g_enable_distance_rangejoin, Analyzer::FunctionOper::getName(), BoundingBoxIntersectJoinSupportedFunction::is_bbox_intersect_supported_func(), kLE, kLT, RANGE_JOIN, BoundingBoxIntersectJoinTranslationResult::swap_arguments, translate_bounding_box_intersect_with_reordering(), JoinCondition::type, and UNKNOWN.

Referenced by RelAlgExecutor::createCompoundWorkUnit(), and RelAlgExecutor::createProjectWorkUnit().

                              {
  if (!g_enable_bbox_intersect_hashjoin || join_quals.empty()) {
    return {join_quals, false, false};
  }

  JoinQualsPerNestingLevel join_condition_per_nesting_level;
  bool is_reordered{false};
  bool has_bbox_intersect{false};
  for (const auto& join_condition_in : join_quals) {
    JoinCondition join_condition{{}, join_condition_in.type};

    for (const auto& join_qual_expr_in : join_condition_in.quals) {
      bool try_to_rewrite_expr_to_bbox_intersect = false;
      BoundingBoxIntersectJoinRewriteType rewrite_type{
          BoundingBoxIntersectJoinRewriteType::UNKNOWN};
      auto func_oper = dynamic_cast<Analyzer::FunctionOper*>(join_qual_expr_in.get());
      if (func_oper) {
        const auto func_name = func_oper->getName();
        if (BoundingBoxIntersectJoinSupportedFunction::is_bbox_intersect_supported_func(
                func_name)) {
          try_to_rewrite_expr_to_bbox_intersect = true;
          rewrite_type = BoundingBoxIntersectJoinRewriteType::BBOX_INTERSECT_JOIN;
        }
      }
      auto bin_oper = dynamic_cast<Analyzer::BinOper*>(join_qual_expr_in.get());
      if (bin_oper && (bin_oper->get_optype() == kLE || bin_oper->get_optype() == kLT)) {
        auto lhs =
            dynamic_cast<const Analyzer::GeoOperator*>(bin_oper->get_left_operand());
        auto rhs = dynamic_cast<const Analyzer::Constant*>(bin_oper->get_right_operand());
        if (g_enable_distance_rangejoin && lhs && rhs) {
          try_to_rewrite_expr_to_bbox_intersect = true;
          rewrite_type = BoundingBoxIntersectJoinRewriteType::RANGE_JOIN;
        }
      }
      BoundingBoxIntersectJoinTranslationResult translation_res;
      if (try_to_rewrite_expr_to_bbox_intersect) {
        translation_res =
            translate_bounding_box_intersect_with_reordering(join_qual_expr_in,
                                                             input_descs,
                                                             input_to_nest_level,
                                                             input_permutation,
                                                             input_col_desc,
                                                             rewrite_type,
                                                             executor);
      }
      if (translation_res.converted_bbox_intersect_join_info) {
        const auto& bbox_intersect_quals =
            *translation_res.converted_bbox_intersect_join_info;
        has_bbox_intersect = true;
        // Add qual for bounding box intersection
        join_condition.quals.insert(join_condition.quals.end(),
                                    bbox_intersect_quals.join_quals.begin(),
                                    bbox_intersect_quals.join_quals.end());
        // Add original quals
        join_condition.quals.insert(join_condition.quals.end(),
                                    bbox_intersect_quals.quals.begin(),
                                    bbox_intersect_quals.quals.end());
      } else {
        join_condition.quals.push_back(join_qual_expr_in);
      }
      is_reordered |= translation_res.swap_arguments;
    }
    join_condition_per_nesting_level.push_back(join_condition);
  }
  return {join_condition_per_nesting_level, has_bbox_intersect, is_reordered};
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> fold_expr

(

const Analyzer::Expr *

)

Definition at line 1356 of file ExpressionRewrite.cpp.

References kBIGINT, and anonymous_namespace{ExpressionRewrite.cpp}::strip_likelihood().

Referenced by RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::makeJoinQuals(), anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict_maybe(), anonymous_namespace{RelAlgExecutor.cpp}::translate_quals(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources(), anonymous_namespace{RelAlgExecutor.cpp}::translate_targets(), RelAlgTranslator::translateBinaryGeoFunction(), RelAlgTranslator::translateDatePlusMinus(), RelAlgTranslator::translateGeoComparison(), and RelAlgTranslator::translateGeoFunctionArg().

                                                                {
  if (!expr) {
    return nullptr;
  }
  const auto expr_no_likelihood = strip_likelihood(expr);
  ConstantFoldingVisitor visitor;
  auto rewritten_expr = visitor.visit(expr_no_likelihood);
  if (visitor.get_num_overflows() > 0 && rewritten_expr->get_type_info().is_integer() &&
      rewritten_expr->get_type_info().get_type() != kBIGINT) {
    auto rewritten_expr_const =
        std::dynamic_pointer_cast<const Analyzer::Constant>(rewritten_expr);
    if (!rewritten_expr_const) {
      // Integer expression didn't fold completely the first time due to
      // overflows in smaller type subexpressions, trying again with a cast
      const auto& ti = SQLTypeInfo(kBIGINT, false);
      auto bigint_expr_no_likelihood = expr_no_likelihood->deep_copy()->add_cast(ti);
      auto rewritten_expr_take2 = visitor.visit(bigint_expr_no_likelihood.get());
      auto rewritten_expr_take2_const =
          std::dynamic_pointer_cast<Analyzer::Constant>(rewritten_expr_take2);
      if (rewritten_expr_take2_const) {
        // Managed to fold, switch to the new constant
        rewritten_expr = rewritten_expr_take2_const;
      }
    }
  }
  const auto expr_with_likelihood = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
  if (expr_with_likelihood) {
    // Add back likelihood
    return std::make_shared<Analyzer::LikelihoodExpr>(
        rewritten_expr, expr_with_likelihood->get_likelihood());
  }
  return rewritten_expr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int get_max_rte_scan_table

(

std::unordered_map< int, llvm::Value * > &

scan_idx_to_hash_pos

)

Definition at line 1401 of file ExpressionRewrite.cpp.

Referenced by BaselineJoinHashTable::codegenKey(), PerfectJoinHashTable::codegenMatchingSet(), and PerfectJoinHashTable::codegenSlot().

                                                             {
  int ret = INT32_MIN;
  for (auto& kv : scan_idx_to_hash_pos) {
    if (kv.first > ret) {
      ret = kv.first;
    }
  }
  return ret;
}

Here is the caller graph for this function:

size_t get_table_cardinality	(	shared::TableKey const &	table_key,
		Executor const *	executor
	)

Definition at line 1412 of file ExpressionRewrite.cpp.

References CHECK, Catalog_Namespace::get_metadata_for_table(), get_temporary_table(), and shared::TableKey::table_id.

Referenced by anonymous_namespace{FromTableReordering.cpp}::get_join_qual_cost(), and translate_bounding_box_intersect_with_reordering().

                                                       {
  if (table_key.table_id > 0) {
    auto const td = Catalog_Namespace::get_metadata_for_table(table_key);
    CHECK(td);
    CHECK(td->fragmenter);
    return td->fragmenter->getNumRows();
  }
  auto temp_tbl = get_temporary_table(executor->getTemporaryTables(), table_key.table_id);
  return temp_tbl->rowCount();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Analyzer::ExpressionPtr rewrite_array_elements

(

const Analyzer::Expr *

)

Definition at line 775 of file ExpressionRewrite.cpp.

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

                                                                       {
  return ArrayElementStringLiteralEncodingVisitor().visit(expr);
}

Here is the caller graph for this function:

Analyzer::ExpressionPtr rewrite_expr

(

const Analyzer::Expr *

)

Definition at line 779 of file ExpressionRewrite.cpp.

References rewrite_avg_window(), rewrite_sum_window(), and anonymous_namespace{ExpressionRewrite.cpp}::strip_likelihood().

Referenced by RelAlgExecutor::createFilterWorkUnit(), qual_to_conjunctive_form(), qual_to_disjunctive_form(), anonymous_namespace{RelAlgExecutor.cpp}::rewrite_quals(), QueryRewriter::rewriteConstrainedByIn(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources(), anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources_for_update(), and anonymous_namespace{RelAlgExecutor.cpp}::translate_targets().

                                                             {
  const auto sum_window = rewrite_sum_window(expr);
  if (sum_window) {
    return sum_window;
  }
  const auto avg_window = rewrite_avg_window(expr);
  if (avg_window) {
    return avg_window;
  }
  const auto expr_no_likelihood = strip_likelihood(expr);
  // The following check is not strictly needed, but seems silly to transform a
  // simple string comparison to an IN just to codegen the same thing anyway.

  RecursiveOrToInVisitor visitor;
  auto rewritten_expr = visitor.visit(expr_no_likelihood);
  const auto expr_with_likelihood =
      std::dynamic_pointer_cast<const Analyzer::LikelihoodExpr>(rewritten_expr);
  if (expr_with_likelihood) {
    // Add back likelihood
    return std::make_shared<Analyzer::LikelihoodExpr>(
        rewritten_expr, expr_with_likelihood->get_likelihood());
  }
  return rewritten_expr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool self_join_not_covered_by_left_deep_tree	(	const Analyzer::ColumnVar *	lhs,
		const Analyzer::ColumnVar *	rhs,
		const int	max_rte_covered
	)

Definition at line 1390 of file ExpressionRewrite.cpp.

References Analyzer::ColumnVar::get_rte_idx(), and Analyzer::ColumnVar::getTableKey().

Referenced by BaselineJoinHashTable::codegenKey(), PerfectJoinHashTable::codegenMatchingSet(), and PerfectJoinHashTable::codegenSlot().

                                                                        {
  if (key_side->getTableKey() == val_side->getTableKey() &&
      key_side->get_rte_idx() == val_side->get_rte_idx() &&
      key_side->get_rte_idx() > max_rte_covered) {
    return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > strip_join_covered_filter_quals	(	const std::list< std::shared_ptr< Analyzer::Expr >> &	quals,
		const JoinQualsPerNestingLevel &	join_quals
	)

Definition at line 1332 of file ExpressionRewrite.cpp.

References g_strip_join_covered_quals, and ScalarExprVisitor< T >::visit().

Referenced by RelAlgExecutionUnit::createCountAllExecutionUnit().

                                                {
  if (!g_strip_join_covered_quals) {
    return quals;
  }

  if (join_quals.empty()) {
    return quals;
  }

  std::list<std::shared_ptr<Analyzer::Expr>> quals_to_return;

  JoinCoveredQualVisitor visitor(join_quals);
  for (const auto& qual : quals) {
    if (!visitor.visit(qual.get())) {
      // Not a covered qual, don't elide it from the filtered count
      quals_to_return.push_back(qual);
    }
  }

  return quals_to_return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BoundingBoxIntersectJoinTranslationResult translate_bbox_intersect_with_reordering	(	const std::shared_ptr< Analyzer::Expr >	expr,
		std::vector< InputDescriptor > const &	input_descs,
		std::unordered_map< const RelAlgNode *, int > const &	input_to_nest_level,
		std::vector< size_t > const &	input_permutation,
		std::list< std::shared_ptr< const InputColDescriptor >> &	input_col_desc,
		const BoundingBoxIntersectJoinRewriteType	rewrite_type,
		Executor const *	executor
	)