#include "QueryEngine/ExpressionRewrite.h"
#include <algorithm>
#include <boost/locale/conversion.hpp>
#include <unordered_set>
#include "Logger/Logger.h"
#include "Parser/ParserNode.h"
#include "QueryEngine/DeepCopyVisitor.h"
#include "QueryEngine/Execute.h"
#include "QueryEngine/ScalarExprVisitor.h"
#include "QueryEngine/WindowExpressionRewrite.h"
#include "Shared/sqldefs.h"
#include "StringOps/StringOps.h"

Include dependency graph for ExpressionRewrite.cpp:

Classes
class	anonymous_namespace{ExpressionRewrite.cpp}::OrToInVisitor

class	anonymous_namespace{ExpressionRewrite.cpp}::RecursiveOrToInVisitor

class	anonymous_namespace{ExpressionRewrite.cpp}::ArrayElementStringLiteralEncodingVisitor

class	anonymous_namespace{ExpressionRewrite.cpp}::ConstantFoldingVisitor

class	JoinCoveredQualVisitor

Namespaces
	anonymous_namespace{ExpressionRewrite.cpp}

Functions
const Analyzer::Expr *	anonymous_namespace{ExpressionRewrite.cpp}::strip_likelihood (const Analyzer::Expr *expr)

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

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

void	anonymous_namespace{ExpressionRewrite.cpp}::update_input_to_nest_lv (std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, shared::ColumnKey const &column_key, int target_nest_lv)

int	anonymous_namespace{ExpressionRewrite.cpp}::update_input_desc (std::vector< InputDescriptor > &input_descs, shared::ColumnKey const &column_key, int target_nest_lv)

auto	anonymous_namespace{ExpressionRewrite.cpp}::update_input_col_desc (std::list< std::shared_ptr< const InputColDescriptor >> &input_col_desc, shared::ColumnKey const &column_key, int target_nest_lv)

BoundingBoxIntersectJoinTranslationResult	translate_bounding_box_intersect_with_reordering (const std::shared_ptr< Analyzer::Expr > expr, 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, 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 *expr)

bool	self_join_not_covered_by_left_deep_tree (const Analyzer::ColumnVar key_side, const Analyzer::ColumnVar val_side, 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)

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 * 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 ( Analyzer::Expr const * 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 * 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 *	key_side,
		const Analyzer::ColumnVar *	val_side,
		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_bounding_box_intersect_with_reordering	(	const std::shared_ptr< Analyzer::Expr >	expr,
		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,
		const BoundingBoxIntersectJoinRewriteType	rewrite_type,
		Executor const *	executor
	)

Definition at line 857 of file ExpressionRewrite.cpp.

Referenced by convert_bbox_intersect_join().

                               {
   auto collect_table_cardinality = [&executor](const Analyzer::Expr* lhs,
                                                const Analyzer::Expr* rhs) {
     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) {
       return std::make_pair<int64_t, int64_t>(
           get_table_cardinality(lhs_cv->getTableKey(), executor),
           get_table_cardinality(rhs_cv->getTableKey(), executor));
     }
     // 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 bounding box intersection, the join builder will fail.
     std::set<int> lhs_rte_idx;
     lhs->collect_rte_idx(lhs_rte_idx);
     std::set<int> rhs_rte_idx;
     rhs->collect_rte_idx(rhs_rte_idx);
     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);
   };
   bool swap_args = false;
   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) -> std::shared_ptr<Analyzer::BinOper> {
     if (BoundingBoxIntersectJoinSupportedFunction::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 a join hash table for bounding box intersection 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 bounding box intersection, 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 exploit bounding box intersection. 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;
       }
       auto const card_info = collect_table_cardinality(range_join_arg, bin_oper_arg);
       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) {
         // todo (yoonmin) : find the best reordering scheme when a query has multiple
         // range join candidates; it needs a (cost-based) plan enumeration logic
         // in our optimizer
         auto r_cv = dynamic_cast<Analyzer::ColumnVar*>(lhs->getOperand(1));
         auto l_cv = dynamic_cast<Analyzer::ColumnVar*>(lhs->getOperand(0));
         if (r_cv && l_cv && input_descs.size() == 2) {
           // to exploit range hash join, we need to assign point geometry to rhs
           // specifically, we need to propagate the changes made here via various
           // query metadata such as `input_desc`, `input_col_desc` and so on
           // otherwise, we do not try swapping join arguments for safety
           // and we do not try argument swapping if the input query has more two
           // input tables; but it is enough to cover most of immerse use-cases
           auto const r_col_key = r_cv->getColumnKey();
           auto const l_col_key = l_cv->getColumnKey();
           int r_rte_idx = r_cv->get_rte_idx();
           int l_rte_idx = l_cv->get_rte_idx();
           r_cv->set_rte_idx(l_rte_idx);
           l_cv->set_rte_idx(r_rte_idx);
           update_input_to_nest_lv(input_to_nest_level, r_col_key, l_rte_idx);
           update_input_to_nest_lv(input_to_nest_level, l_col_key, r_rte_idx);
           auto const r_input_desc_idx =
               update_input_desc(input_descs, r_col_key, l_rte_idx);
           CHECK_GE(r_input_desc_idx, 0);
           auto const l_input_desc_idx =
               update_input_desc(input_descs, l_col_key, r_rte_idx);
           CHECK_GE(l_input_desc_idx, 0);
           auto r_input_col_desc_it =
               update_input_col_desc(input_col_desc, r_col_key, l_rte_idx);
           CHECK(r_input_col_desc_it != input_col_desc.end());
           auto l_input_col_desc_it =
               update_input_col_desc(input_col_desc, l_col_key, r_rte_idx);
           CHECK(l_input_col_desc_it != input_col_desc.end());
           if (!input_permutation.empty()) {
             auto r_itr =
                 std::find(input_permutation.begin(), input_permutation.end(), r_rte_idx);
             CHECK(r_itr != input_permutation.end());
             auto l_itr =
                 std::find(input_permutation.begin(), input_permutation.end(), l_rte_idx);
             CHECK(l_itr != input_permutation.end());
             std::swap(*r_itr, *l_itr);
           }
           std::swap(input_descs[r_input_desc_idx], input_descs[l_input_desc_idx]);
           std::swap(r_input_col_desc_it, l_input_col_desc_it);
           r_arg = lhs->getOperand(0);
           l_arg = lhs->getOperand(1);
           VLOG(1) << "Swap range join qual's input arguments to exploit hash join "
                      "framework for bounding box intersection";
           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, kBBOX_INTERSECT, kONE, l_arg->deep_copy(), range_expr);
     }
     return nullptr;
   };
 
   /*
    * Currently, our hash join framework for bounding box intersection (bbox-intersect)
    * supports limited set of join quals when 1) the FunctionOperator is listed in the
    * function list, i.e., is_bbox_intersect_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). Depending on the type
    * of the function, we try to convert it to corresponding hash join qual if possible.
    * After rewriting, we create a join operator w/ bbox-intersect which is converted from
    * the original expression and return BoundingBoxIntersectJoinConjunction object which
    * is a pair of 1) the original expr and 2) converted join expr w/ bbox-intersect. Here,
    * returning the original expr means we additionally call its corresponding native
    * function to compute the result accurately (i.e., bbox-intersect hash join operates a
    * kind of filter expression which may include false-positive of the true resultset).
    * Note that ST_IntersectsBox is the only function that does not return the original
    * expr.
    * */
   std::shared_ptr<Analyzer::BinOper> bbox_intersect_oper{nullptr};
   bool needs_to_return_original_expr = false;
   std::string func_name{""};
   if (rewrite_type == BoundingBoxIntersectJoinRewriteType::BBOX_INTERSECT_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 &&
         BoundingBoxIntersectJoinSupportedFunction::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 BoundingBoxIntersectJoinTranslationResult::createEmptyResult();
     }
     DeepCopyVisitor deep_copy_visitor;
     if (func_name == BoundingBoxIntersectJoinSupportedFunction::ST_INTERSECTSBOX_sv) {
       CHECK_GE(func_oper->getArity(), size_t(2));
       // this case returns {empty quals, bbox_intersect join quals} b/c our join key
       // matching logic for this case is the same as the implementation of
       // ST_IntersectsBox function Note that we can build a join hash table for
       // bbox_intersect 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 bbox_intersect, 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);
       bbox_intersect_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kBBOX_INTERSECT, kONE, rewritten_lhs, rewritten_rhs);
     } else if (func_name ==
                BoundingBoxIntersectJoinSupportedFunction::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),
             BoundingBoxIntersectJoinSupportedFunction::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";
         bbox_intersect_oper = convert_to_range_join_oper(
             BoundingBoxIntersectJoinSupportedFunction::ST_DISTANCE_sv,
             distance_oper,
             distance_oper.get(),
             range_oper.get(),
             distance_const_val);
         needs_to_return_original_expr = true;
       }
     } else if (BoundingBoxIntersectJoinSupportedFunction::
                    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 bbox_intersect 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);
 
       bbox_intersect_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kBBOX_INTERSECT, kONE, rewritten_lhs, rewritten_rhs);
       needs_to_return_original_expr = true;
     } else if (BoundingBoxIntersectJoinSupportedFunction::
                    is_point_poly_rewrite_target_func(func_name)) {
       // now, we try to look at one more chance to exploit bbox_intersect 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 hash join framework w/
       // bbox_intersect 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 bbox_intersect_oper (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 bounding box intersection with lhs as "
               << rewritten_lhs->toString() << " and rhs as " << rewritten_rhs->toString();
       bbox_intersect_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kBBOX_INTERSECT, kONE, rewritten_lhs, rewritten_rhs);
       needs_to_return_original_expr = true;
     } else if (BoundingBoxIntersectJoinSupportedFunction::
                    is_poly_point_rewrite_target_func(func_name)) {
       // rest of functions reaching here is poly and point geo join query
       // to use bbox_intersect 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 bbox_intersect, we
         // need to detect and abort the bbox_intersect 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 bounding box intersection conjunction. LHS input type is "
                      "neither a geospatial "
                      "column nor a constructed point"
                   << func_oper->toString();
         return BoundingBoxIntersectJoinTranslationResult::createEmptyResult();
       }
 
       // 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 bounding box intersection conjunction. Cannot build hash table "
                      "over LHS type. "
                      "Check join order."
                   << func_oper->toString();
         return BoundingBoxIntersectJoinTranslationResult::createEmptyResult();
       }
 
       VLOG(1) << "Rewriting " << func_name
               << " to use bounding box intersection with lhs as "
               << rewritten_lhs->toString() << " and rhs as " << rewritten_rhs->toString();
 
       bbox_intersect_oper = makeExpr<Analyzer::BinOper>(
           kBOOLEAN, kBBOX_INTERSECT, kONE, rewritten_lhs, rewritten_rhs);
       if (func_name != BoundingBoxIntersectJoinSupportedFunction::
                            ST_APPROX_OVERLAPS_MULTIPOLYGON_POINT_sv) {
         needs_to_return_original_expr = true;
       }
     }
   } else if (rewrite_type == BoundingBoxIntersectJoinRewriteType::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();
     bbox_intersect_oper = convert_to_range_join_oper(func_name, expr, bin_oper, lhs, rhs);
     needs_to_return_original_expr = true;
   }
   const auto expr_str = !func_name.empty() ? func_name : expr->toString();
   if (bbox_intersect_oper) {
     BoundingBoxIntersectJoinTranslationResult res;
     res.swap_arguments = swap_args;
     BoundingBoxIntersectJoinConjunction bbox_intersect_join_qual;
     bbox_intersect_join_qual.join_quals.push_back(bbox_intersect_oper);
     if (needs_to_return_original_expr) {
       bbox_intersect_join_qual.quals.push_back(expr);
     }
     res.converted_bbox_intersect_join_info = bbox_intersect_join_qual;
     VLOG(1) << "Successfully converted " << expr_str
             << " to use bounding box intersection";
     return res;
   }
   VLOG(1) << "Bounding box intersection not enabled for " << expr_str;
   return BoundingBoxIntersectJoinTranslationResult::createEmptyResult();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Namespaces

Functions

Function Documentation