#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	OverlapsJoinConjunction

struct	OverlapsJoinSupportedFunction

Namespaces
	Analyzer

Enumerations
enum	OverlapsJoinRewriteType { OverlapsJoinRewriteType::OVERLAPS_JOIN, OverlapsJoinRewriteType::RANGE_JOIN, OverlapsJoinRewriteType::UNKNOWN }

Functions
Analyzer::ExpressionPtr	rewrite_expr (const Analyzer::Expr *)

Analyzer::ExpressionPtr	rewrite_array_elements (const Analyzer::Expr *)

boost::optional < OverlapsJoinConjunction >	rewrite_overlaps_conjunction (const std::shared_ptr< Analyzer::Expr > expr, const std::vector< InputDescriptor > &input_table_info, const OverlapsJoinRewriteType rewrite_type, const Executor *executor)

boost::optional < OverlapsJoinConjunction >	convert_to_range_join_oper (const std::shared_ptr< Analyzer::Expr > expr, const Analyzer::BinOper range_join_expr, const Analyzer::GeoOperator lhs, const Analyzer::Constant *rhs)

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)

Enumeration Type Documentation

enum OverlapsJoinRewriteType

strong

Enumerator
OVERLAPS_JOIN
RANGE_JOIN
UNKNOWN

Definition at line 51 of file ExpressionRewrite.h.

51 { OVERLAPS_JOIN, RANGE_JOIN, UNKNOWN };

OverlapsJoinRewriteType::RANGE_JOIN

OverlapsJoinRewriteType::OVERLAPS_JOIN

OverlapsJoinRewriteType::UNKNOWN

Function Documentation

boost::optional<OverlapsJoinConjunction> convert_to_range_join_oper	(	const std::shared_ptr< Analyzer::Expr >	expr,
		const Analyzer::BinOper *	range_join_expr,
		const Analyzer::GeoOperator *	lhs,
		const Analyzer::Constant *	rhs
	)

Referenced by rewrite_overlaps_conjunction().

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Expr> fold_expr ( const Analyzer::Expr * )

Definition at line 1175 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 1220 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:

Analyzer::ExpressionPtr rewrite_array_elements ( const Analyzer::Expr * )

Definition at line 765 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 769 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:

boost::optional<OverlapsJoinConjunction> rewrite_overlaps_conjunction	(	const std::shared_ptr< Analyzer::Expr >	expr,
		const std::vector< InputDescriptor > &	input_table_info,
		const OverlapsJoinRewriteType	rewrite_type,
		const Executor *	executor
	)

Definition at line 794 of file ExpressionRewrite.cpp.

Referenced by QueryRewriter::rewriteOverlapsJoin().

                               {
   auto collect_table_cardinality =
       [](const Analyzer::Expr* lhs, const Analyzer::Expr* rhs, const Executor* executor) {
         const auto lhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(lhs);
         const auto rhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(rhs);
         if (lhs_cv && rhs_cv) {
           const auto inner_table_metadata = Catalog_Namespace::get_metadata_for_table(
               {lhs_cv->getColumnKey().db_id, lhs_cv->getColumnKey().table_id});
           const auto outer_table_metadata = Catalog_Namespace::get_metadata_for_table(
               {rhs_cv->getColumnKey().db_id, rhs_cv->getColumnKey().table_id});
           if (inner_table_metadata->fragmenter && outer_table_metadata->fragmenter) {
             return std::make_pair<int64_t, int64_t>(
                 inner_table_metadata->fragmenter->getNumRows(),
                 outer_table_metadata->fragmenter->getNumRows());
           }
         }
         // otherwise, return an invalid table cardinality
         return std::make_pair<int64_t, int64_t>(-1, -1);
       };
 
   auto has_invalid_join_col_order = [](const Analyzer::Expr* lhs,
                                        const Analyzer::Expr* rhs) {
     // Check for compatible join ordering. If the join ordering does not match expected
     // ordering for overlaps, the join builder will fail.
     std::set<int> lhs_rte_idx;
     lhs->collect_rte_idx(lhs_rte_idx);
     CHECK(!lhs_rte_idx.empty());
     std::set<int> rhs_rte_idx;
     rhs->collect_rte_idx(rhs_rte_idx);
     CHECK(!rhs_rte_idx.empty());
     auto has_invalid_num_join_cols = lhs_rte_idx.size() > 1 || rhs_rte_idx.size() > 1;
     auto has_invalid_rte_idx = lhs_rte_idx > rhs_rte_idx;
     return std::make_pair(has_invalid_num_join_cols || has_invalid_rte_idx,
                           has_invalid_rte_idx);
   };
 
   auto convert_to_range_join_oper =
       [&](std::string_view func_name,
           const std::shared_ptr<Analyzer::Expr> expr,
           const Analyzer::BinOper* range_join_expr,
           const Analyzer::GeoOperator* lhs,
           const Analyzer::Constant* rhs,
           const Executor* executor) -> std::shared_ptr<Analyzer::BinOper> {
     if (OverlapsJoinSupportedFunction::is_range_join_rewrite_target_func(func_name)) {
       CHECK_EQ(lhs->size(), size_t(2));
       auto l_arg = lhs->getOperand(0);
       // we try to build an overlaps join hash table based on the rhs
       auto r_arg = lhs->getOperand(1);
       const bool is_geography = l_arg->get_type_info().get_subtype() == kGEOGRAPHY ||
                                 r_arg->get_type_info().get_subtype() == kGEOGRAPHY;
       if (is_geography) {
         VLOG(1) << "Range join not yet supported for geodesic distance "
                 << expr->toString();
         return nullptr;
       }
 
       // Check for compatible join ordering. If the join ordering does not match expected
       // ordering for overlaps, the join builder will fail.
       Analyzer::Expr* range_join_arg = r_arg;
       Analyzer::Expr* bin_oper_arg = l_arg;
       auto invalid_range_join_qual =
           has_invalid_join_col_order(bin_oper_arg, range_join_arg);
       if (invalid_range_join_qual.first) {
         LOG(INFO) << "Unable to rewrite " << func_name
                   << " to overlaps conjunction. Cannot build hash table over LHS type. "
                      "Check join order.\n"
                   << range_join_expr->toString();
         return nullptr;
       }
       // swapping rule for range join argument
       //    lhs    | rhs
       // 1. pt     | pt     : swap if |lhs| < |rhs| or has invalid rte values
       // 2. pt     | non-pt : return nullptr
       // 3. non-pt | pt     : return nullptr
       // 4. non-pt | non-pt : return nullptr
       // todo (yoonmin) : improve logic for cases 2 and 3
       bool lhs_is_point{l_arg->get_type_info().get_type() == kPOINT};
       bool rhs_is_point{r_arg->get_type_info().get_type() == kPOINT};
       if (!lhs_is_point || !rhs_is_point) {
         // case 2 ~ 4
         VLOG(1) << "Currently, we only support range hash join for Point-to-Point "
                    "distance query: fallback to a loop join";
         return nullptr;
       }
 
       bool swap_args = false;
       auto const card_info =
           collect_table_cardinality(range_join_arg, bin_oper_arg, executor);
       if (invalid_range_join_qual.second && card_info.first > 0 && lhs_is_point) {
         swap_args = true;
       } else if (card_info.first >= 0 && card_info.first < card_info.second) {
         swap_args = true;
       }
 
       if (swap_args) {
         // to exploit range hash join, we need to assign point geometry to rhs
         r_arg = lhs->getOperand(0);
         l_arg = lhs->getOperand(1);
         VLOG(1) << "Swap range join qual's input arguments to exploit overlaps "
                    "hash join framework";
         invalid_range_join_qual.first = false;
       }
 
       const bool inclusive = range_join_expr->get_optype() == kLE;
       auto range_expr = makeExpr<Analyzer::RangeOper>(
           inclusive, inclusive, r_arg->deep_copy(), rhs->deep_copy());
       VLOG(1) << "Successfully converted to range hash join";
       return makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kOVERLAPS, kONE, l_arg->deep_copy(), range_expr);
     }
     return nullptr;
   };
 
   /*
    * Currently, our overlaps hash join framework supports limited join quals especially
    * when 1) the FunctionOperator is listed in the function list, i.e.,
    * is_overlaps_supported_func, 2) the argument order of the join qual must match the
    * input argument order of the corresponding native function, and 3) input tables match
    * rte index requirement (the column used to build a hash table has larger rte compared
    * with that of probing column) And depending on the type of the function, we try to
    * convert it to corresponding overlaps hash join qual if possible After rewriting, we
    * create an overlaps join operator which is converted from the original expression and
    * return OverlapsJoinConjunction object which is a pair of 1) the original expr and 2)
    * converted overlaps join expr Here, returning the original expr means we additionally
    * call its corresponding native function to compute the result accurately (i.e.,
    * overlaps hash join operates a kind of filter expression which may include
    * false-positive of the true resultset) Note that ST_Overlaps is the only function that
    * does not return the original expr
    * */
   std::shared_ptr<Analyzer::BinOper> overlaps_oper{nullptr};
   bool needs_to_return_original_expr = false;
   std::string func_name{""};
   if (rewrite_type == OverlapsJoinRewriteType::OVERLAPS_JOIN) {
     auto func_oper = dynamic_cast<Analyzer::FunctionOper*>(expr.get());
     CHECK(func_oper);
     func_name = func_oper->getName();
     if (!g_enable_hashjoin_many_to_many &&
         OverlapsJoinSupportedFunction::is_many_to_many_func(func_name)) {
       LOG(WARNING) << "Many-to-many hashjoin support is disabled, unable to rewrite "
                    << func_oper->toString() << " to use accelerated geo join.";
       return boost::none;
     }
     DeepCopyVisitor deep_copy_visitor;
     if (func_name == OverlapsJoinSupportedFunction::ST_OVERLAPS_sv) {
       CHECK_GE(func_oper->getArity(), size_t(2));
       // this case returns {empty quals, overlaps join quals} b/c our join key matching
       // logic for this case is the same as the implementation of ST_Overlaps function
       // Note that we can build an overlaps join hash table regardless of table ordering
       // and the argument order in this case b/c selecting lhs and rhs by arguments 0
       // and 1 always match the rte index requirement (rte_lhs < rte_rhs)
       // so what table ordering we take, the rte index requirement satisfies
       // TODO(adb): we will likely want to actually check for true overlaps, but this
       // works for now
       auto lhs = func_oper->getOwnArg(0);
       auto rewritten_lhs = deep_copy_visitor.visit(lhs.get());
       CHECK(rewritten_lhs);
 
       auto rhs = func_oper->getOwnArg(1);
       auto rewritten_rhs = deep_copy_visitor.visit(rhs.get());
       CHECK(rewritten_rhs);
       overlaps_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kOVERLAPS, kONE, rewritten_lhs, rewritten_rhs);
     } else if (func_name == OverlapsJoinSupportedFunction::ST_DWITHIN_POINT_POINT_sv) {
       CHECK_EQ(func_oper->getArity(), size_t(8));
       const auto lhs = func_oper->getOwnArg(0);
       const auto rhs = func_oper->getOwnArg(1);
       // the correctness of geo args used in the ST_DWithin function is checked by
       // geo translation logic, i.e., RelAlgTranslator::translateTernaryGeoFunction
       const auto distance_const_val =
           dynamic_cast<const Analyzer::Constant*>(func_oper->getArg(7));
       if (lhs && rhs && distance_const_val) {
         std::vector<std::shared_ptr<Analyzer::Expr>> args{lhs, rhs};
         auto range_oper = makeExpr<Analyzer::GeoOperator>(
             SQLTypeInfo(kDOUBLE, 0, 8, true),
             OverlapsJoinSupportedFunction::ST_DISTANCE_sv.data(),
             args,
             std::nullopt);
         auto distance_oper = makeExpr<Analyzer::BinOper>(
             kBOOLEAN, kLE, kONE, range_oper, distance_const_val->deep_copy());
         VLOG(1) << "Rewrite " << func_oper->getName() << " to ST_Distance_Point_Point";
         overlaps_oper =
             convert_to_range_join_oper(OverlapsJoinSupportedFunction::ST_DISTANCE_sv,
                                        distance_oper,
                                        distance_oper.get(),
                                        range_oper.get(),
                                        distance_const_val,
                                        executor);
         needs_to_return_original_expr = true;
       }
     } else if (OverlapsJoinSupportedFunction::is_poly_mpoly_rewrite_target_func(
                    func_name)) {
       // in the five functions fall into this case,
       // ST_Contains is for a pair of polygons, and for ST_Intersect cases they are
       // combo of polygon and multipolygon so what table orders we choose, rte index
       // requirement for overlaps join can be satisfied if we choose lhs and rhs
       // from left-to-right order (i.e., get lhs from the arg-1 instead of arg-3)
       // Note that we choose them from right-to-left argument order in the past
       CHECK_GE(func_oper->getArity(), size_t(4));
       auto lhs = func_oper->getOwnArg(1);
       auto rewritten_lhs = deep_copy_visitor.visit(lhs.get());
       CHECK(rewritten_lhs);
       auto rhs = func_oper->getOwnArg(3);
       auto rewritten_rhs = deep_copy_visitor.visit(rhs.get());
       CHECK(rewritten_rhs);
 
       overlaps_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kOVERLAPS, kONE, rewritten_lhs, rewritten_rhs);
       needs_to_return_original_expr = true;
     } else if (OverlapsJoinSupportedFunction::is_point_poly_rewrite_target_func(
                    func_name)) {
       // now, we try to look at one more chance to exploit overlaps hash join by
       // rewriting the qual as: ST_INTERSECT(POLY, POINT) -> ST_INTERSECT(POINT, POLY)
       // to support efficient evaluation of 1) ST_Intersects_Point_Polygon and
       // 2) ST_Intersects_Point_MultiPolygon based on our overlaps hash join framework
       // here, we have implementation of native functions for both 1) Point-Polygon pair
       // and 2) Polygon-Point pair, but we currently do not support hash table
       // generation on top of point column thus, the goal of this rewriting is to place
       // a non-point geometry to the right-side of the overlaps join operator (to build
       // hash table based on it) iff the inner table is larger than that of non-point
       // geometry (to reduce expensive hash join performance)
       size_t point_arg_idx = 0;
       size_t poly_arg_idx = 2;
       if (func_oper->getOwnArg(point_arg_idx)->get_type_info().get_type() != kPOINT) {
         point_arg_idx = 2;
         poly_arg_idx = 1;
       }
       auto point_cv = func_oper->getOwnArg(point_arg_idx);
       auto poly_cv = func_oper->getOwnArg(poly_arg_idx);
       CHECK_EQ(point_cv->get_type_info().get_type(), kPOINT);
       CHECK_EQ(poly_cv->get_type_info().get_type(), kARRAY);
       auto rewritten_lhs = deep_copy_visitor.visit(point_cv.get());
       CHECK(rewritten_lhs);
       auto rewritten_rhs = deep_copy_visitor.visit(poly_cv.get());
       CHECK(rewritten_rhs);
       VLOG(1) << "Rewriting the " << func_name << " to use overlaps join with lhs as "
               << rewritten_lhs->toString() << " and rhs as " << rewritten_rhs->toString();
       overlaps_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kOVERLAPS, kONE, rewritten_lhs, rewritten_rhs);
       needs_to_return_original_expr = true;
     } else if (OverlapsJoinSupportedFunction::is_poly_point_rewrite_target_func(
                    func_name)) {
       // rest of functions reaching here is poly and point geo join query
       // to use overlaps hash join in this case, poly column must have its rte == 1
       // lhs is the point col_var
       auto lhs = func_oper->getOwnArg(2);
       auto rewritten_lhs = deep_copy_visitor.visit(lhs.get());
       CHECK(rewritten_lhs);
       const auto& lhs_ti = rewritten_lhs->get_type_info();
 
       if (!lhs_ti.is_geometry() && !is_constructed_point(rewritten_lhs.get())) {
         // TODO(adb): If ST_Contains is passed geospatial literals instead of columns,
         // the function will be expanded during translation rather than during code
         // generation. While this scenario does not make sense for the overlaps join, we
         // need to detect and abort the overlaps rewrite. Adding a GeospatialConstant
         // dervied class to the Analyzer may prove to be a better way to handle geo
         // literals, but for now we ensure the LHS type is a geospatial type, which
         // would mean the function has not been expanded to the physical types, yet.
         LOG(INFO) << "Unable to rewrite " << func_name
                   << " to overlaps conjunction. LHS input type is neither a geospatial "
                      "column nor a constructed point"
                   << func_oper->toString();
         return boost::none;
       }
 
       // rhs is coordinates of the poly col
       auto rhs = func_oper->getOwnArg(1);
       auto rewritten_rhs = deep_copy_visitor.visit(rhs.get());
       CHECK(rewritten_rhs);
 
       if (has_invalid_join_col_order(lhs.get(), rhs.get()).first) {
         LOG(INFO) << "Unable to rewrite " << func_name
                   << " to overlaps conjunction. Cannot build hash table over LHS type. "
                      "Check join order."
                   << func_oper->toString();
         return boost::none;
       }
 
       VLOG(1) << "Rewriting " << func_name << " to use overlaps join with lhs as "
               << rewritten_lhs->toString() << " and rhs as " << rewritten_rhs->toString();
 
       overlaps_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kOVERLAPS, kONE, rewritten_lhs, rewritten_rhs);
       if (func_name !=
           OverlapsJoinSupportedFunction::ST_APPROX_OVERLAPS_MULTIPOLYGON_POINT_sv) {
         needs_to_return_original_expr = true;
       }
     }
   } else if (rewrite_type == OverlapsJoinRewriteType::RANGE_JOIN) {
     auto bin_oper = dynamic_cast<Analyzer::BinOper*>(expr.get());
     CHECK(bin_oper);
     auto lhs = dynamic_cast<const Analyzer::GeoOperator*>(bin_oper->get_left_operand());
     CHECK(lhs);
     auto rhs = dynamic_cast<const Analyzer::Constant*>(bin_oper->get_right_operand());
     CHECK(rhs);
     func_name = lhs->getName();
     overlaps_oper =
         convert_to_range_join_oper(func_name, expr, bin_oper, lhs, rhs, executor);
     needs_to_return_original_expr = true;
   }
   const auto expr_str = !func_name.empty() ? func_name : expr->toString();
   if (overlaps_oper) {
     VLOG(1) << "Successfully converted " << expr_str << " to overlaps join";
     if (needs_to_return_original_expr) {
       return OverlapsJoinConjunction{{expr}, {overlaps_oper}};
     } else {
       return OverlapsJoinConjunction{{}, {overlaps_oper}};
     }
   }
   VLOG(1) << "Overlaps join not enabled for " << expr_str;
   return boost::none;
 }

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 1209 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 1151 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:

Classes

Namespaces

Enumerations

Functions

Enumeration Type Documentation

Function Documentation