RelAlgExecutor.cpp File Reference

#include "RelAlgExecutor.h"
#include "DataMgr/ForeignStorage/ForeignStorageException.h"
#include "DataMgr/ForeignStorage/FsiChunkUtils.h"
#include "Fragmenter/InsertDataLoader.h"
#include "Parser/ParserNode.h"
#include "QueryEngine/CalciteDeserializerUtils.h"
#include "QueryEngine/CardinalityEstimator.h"
#include "QueryEngine/ColumnFetcher.h"
#include "QueryEngine/EquiJoinCondition.h"
#include "QueryEngine/ErrorHandling.h"
#include "QueryEngine/ExpressionRewrite.h"
#include "QueryEngine/ExtensionFunctionsBinding.h"
#include "QueryEngine/ExternalExecutor.h"
#include "QueryEngine/FromTableReordering.h"
#include "QueryEngine/QueryPhysicalInputsCollector.h"
#include "QueryEngine/QueryPlanDagExtractor.h"
#include "QueryEngine/RangeTableIndexVisitor.h"
#include "QueryEngine/RelAlgDag.h"
#include "QueryEngine/RelAlgTranslator.h"
#include "QueryEngine/RelAlgVisitor.h"
#include "QueryEngine/ResultSetBuilder.h"
#include "QueryEngine/RexVisitor.h"
#include "QueryEngine/TableOptimizer.h"
#include "QueryEngine/Visitors/RelAlgDagViewer.h"
#include "QueryEngine/WindowContext.h"
#include "Shared/TypedDataAccessors.h"
#include "Shared/measure.h"
#include "Shared/misc.h"
#include "Shared/shard_key.h"
#include <boost/algorithm/cxx11/any_of.hpp>
#include <boost/range/adaptor/reversed.hpp>
#include <algorithm>
#include <functional>
#include <numeric>

Include dependency graph for RelAlgExecutor.cpp:

Go to the source code of this file.

Classes
class	RelLeftDeepTreeIdsCollector
struct	TextEncodingCastCounts
class	TextEncodingCastCountVisitor
class	anonymous_namespace{RelAlgExecutor.cpp}::RexUsedInputsVisitor
struct	anonymous_namespace{RelAlgExecutor.cpp}::ErrorInfo

Namespaces
	anonymous_namespace{RelAlgExecutor.cpp}
	anonymous_namespace{RelAlgExecutor.cpp}::anonymous_namespace{RelAlgExecutor.cpp}

Functions
bool	anonymous_namespace{RelAlgExecutor.cpp}::node_is_aggregate (const RelAlgNode *ra)
std::unordered_set< PhysicalInput >	anonymous_namespace{RelAlgExecutor.cpp}::get_physical_inputs_with_spi_col_id (const RelAlgNode *ra)
void	anonymous_namespace{RelAlgExecutor.cpp}::set_parallelism_hints (const RelAlgNode &ra_node)
void	anonymous_namespace{RelAlgExecutor.cpp}::prepare_string_dictionaries (const RelAlgNode &ra_node)
void	anonymous_namespace{RelAlgExecutor.cpp}::prepare_foreign_table_for_execution (const RelAlgNode &ra_node)
void	anonymous_namespace{RelAlgExecutor.cpp}::prepare_for_system_table_execution (const RelAlgNode &ra_node, const CompilationOptions &co)
bool	anonymous_namespace{RelAlgExecutor.cpp}::has_valid_query_plan_dag (const RelAlgNode *node)
void	build_render_targets (RenderInfo &render_info, const std::vector< Analyzer::Expr * > &work_unit_target_exprs, const std::vector< TargetMetaInfo > &targets_meta)
bool	is_validate_or_explain_query (const ExecutionOptions &eo)
TextEncodingCastCounts	get_text_cast_counts (const RelAlgExecutionUnit &ra_exe_unit)
void	anonymous_namespace{RelAlgExecutor.cpp}::check_none_encoded_string_cast_tuple_limit (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
void	anonymous_namespace{RelAlgExecutor.cpp}::check_sort_node_source_constraint (const RelSort *sort)
void	anonymous_namespace{RelAlgExecutor.cpp}::handle_query_hint (RegisteredQueryHint const &query_hints, ExecutionOptions &eo, CompilationOptions &co)
const RelAlgNode *	anonymous_namespace{RelAlgExecutor.cpp}::get_data_sink (const RelAlgNode *ra_node)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelCompound *compound)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelAggregate *aggregate)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelProject *project)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelTableFunction *table_func)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelFilter *filter)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_used_inputs (const RelLogicalUnion *logical_union)
shared::TableKey	anonymous_namespace{RelAlgExecutor.cpp}::table_key_from_ra (const RelAlgNode *ra_node)
std::unordered_map< const RelAlgNode *, int >	anonymous_namespace{RelAlgExecutor.cpp}::get_input_nest_levels (const RelAlgNode *ra_node, const std::vector< size_t > &input_permutation)
std::pair< std::unordered_set < const RexInput * > , std::vector< std::shared_ptr < RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_join_source_used_inputs (const RelAlgNode *ra_node)
void	anonymous_namespace{RelAlgExecutor.cpp}::collect_used_input_desc (std::vector< InputDescriptor > &input_descs, std::unordered_set< std::shared_ptr< const InputColDescriptor >> &input_col_descs_unique, const RelAlgNode *ra_node, const std::unordered_set< const RexInput * > &source_used_inputs, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)
template<class RA >
std::pair< std::vector < InputDescriptor >, std::list < std::shared_ptr< const InputColDescriptor > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_input_desc_impl (const RA *ra_node, const std::unordered_set< const RexInput * > &used_inputs, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const std::vector< size_t > &input_permutation)
template<class RA >
std::tuple< std::vector < InputDescriptor >, std::list < std::shared_ptr< const InputColDescriptor > >, std::vector < std::shared_ptr< RexInput > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_input_desc (const RA *ra_node, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const std::vector< size_t > &input_permutation)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size (const RelCompound *compound)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size (const RelProject *project)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::get_scalar_sources_size (const RelTableFunction *table_func)
const RexScalar *	anonymous_namespace{RelAlgExecutor.cpp}::scalar_at (const size_t i, const RelCompound *compound)
const RexScalar *	anonymous_namespace{RelAlgExecutor.cpp}::scalar_at (const size_t i, const RelProject *project)
const RexScalar *	anonymous_namespace{RelAlgExecutor.cpp}::scalar_at (const size_t i, const RelTableFunction *table_func)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict (const std::shared_ptr< Analyzer::Expr > expr)
void	anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict_maybe (std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::shared_ptr< Analyzer::Expr > &expr)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{RelAlgExecutor.cpp}::cast_dict_to_none (const std::shared_ptr< Analyzer::Expr > &input)
template<class RA >
std::vector< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources (const RA *ra_node, const RelAlgTranslator &translator, const ::ExecutorType executor_type)
template<class RA >
std::vector< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::translate_scalar_sources_for_update (const RA *ra_node, const RelAlgTranslator &translator, int32_t tableId, const Catalog_Namespace::Catalog &cat, const ColumnNameList &colNames, size_t starting_projection_column_idx)
std::list< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs (const RelCompound *compound, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
std::list< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs (const RelAggregate *aggregate, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources)
QualsConjunctiveForm	anonymous_namespace{RelAlgExecutor.cpp}::translate_quals (const RelCompound *compound, const RelAlgTranslator &translator)
void	anonymous_namespace{RelAlgExecutor.cpp}::anonymous_namespace{RelAlgExecutor.cpp}::conditionally_change_arg_to_int_type (size_t target_expr_idx, std::shared_ptr< Analyzer::Expr > &target_expr, std::unordered_map< size_t, SQLTypeInfo > &target_exprs_type_infos)
std::vector< Analyzer::Expr * >	anonymous_namespace{RelAlgExecutor.cpp}::translate_targets (std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned, std::unordered_map< size_t, SQLTypeInfo > &target_exprs_type_infos, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const RelCompound *compound, const RelAlgTranslator &translator, const ExecutorType executor_type)
std::vector< Analyzer::Expr * >	anonymous_namespace{RelAlgExecutor.cpp}::translate_targets (std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned, std::unordered_map< size_t, SQLTypeInfo > &target_exprs_type_infos, const std::vector< std::shared_ptr< Analyzer::Expr >> &scalar_sources, const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const RelAggregate *aggregate, const RelAlgTranslator &translator)
bool	anonymous_namespace{RelAlgExecutor.cpp}::is_count_distinct (const Analyzer::Expr *expr)
bool	anonymous_namespace{RelAlgExecutor.cpp}::is_agg (const Analyzer::Expr *expr)
SQLTypeInfo	anonymous_namespace{RelAlgExecutor.cpp}::get_logical_type_for_expr (const Analyzer::Expr &expr)
template<class RA >
std::vector< TargetMetaInfo >	anonymous_namespace{RelAlgExecutor.cpp}::get_targets_meta (const RA *ra_node, const std::vector< Analyzer::Expr * > &target_exprs)
template<>
std::vector< TargetMetaInfo >	anonymous_namespace{RelAlgExecutor.cpp}::get_targets_meta (const RelFilter *filter, const std::vector< Analyzer::Expr * > &target_exprs)
bool	anonymous_namespace{RelAlgExecutor.cpp}::is_window_execution_unit (const RelAlgExecutionUnit &ra_exe_unit)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{RelAlgExecutor.cpp}::transform_to_inner (const Analyzer::Expr *expr)
bool	sameTypeInfo (std::vector< TargetMetaInfo > const &lhs, std::vector< TargetMetaInfo > const &rhs)
bool	isGeometry (TargetMetaInfo const &target_meta_info)
template<class T >
int64_t	anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str (T *col_data, const std::string &columnName, const SQLTypeInfo &columnType, const Analyzer::Constant *col_cv, const Catalog_Namespace::Catalog &catalog)
template<class T >
int64_t	anonymous_namespace{RelAlgExecutor.cpp}::insert_one_dict_str (T *col_data, const ColumnDescriptor *cd, const Analyzer::Constant *col_cv, const Catalog_Namespace::Catalog &catalog)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::get_limit_value (std::optional< size_t > limit)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::get_scan_limit (const RelAlgNode *ra, std::optional< size_t > limit)
bool	anonymous_namespace{RelAlgExecutor.cpp}::first_oe_is_desc (const std::list< Analyzer::OrderEntry > &order_entries)
size_t	anonymous_namespace{RelAlgExecutor.cpp}::groups_approx_upper_bound (const std::vector< InputTableInfo > &table_infos)
bool	anonymous_namespace{RelAlgExecutor.cpp}::is_projection (const RelAlgExecutionUnit &ra_exe_unit)
bool	anonymous_namespace{RelAlgExecutor.cpp}::can_output_columnar (const RelAlgExecutionUnit &ra_exe_unit, const RenderInfo *render_info, const RelAlgNode *body)
bool	anonymous_namespace{RelAlgExecutor.cpp}::should_output_columnar (const RelAlgExecutionUnit &ra_exe_unit)
bool	anonymous_namespace{RelAlgExecutor.cpp}::compute_output_buffer_size (const RelAlgExecutionUnit &ra_exe_unit)
bool	anonymous_namespace{RelAlgExecutor.cpp}::exe_unit_has_quals (const RelAlgExecutionUnit ra_exe_unit)
RelAlgExecutionUnit	anonymous_namespace{RelAlgExecutor.cpp}::decide_approx_count_distinct_implementation (const RelAlgExecutionUnit &ra_exe_unit_in, const std::vector< InputTableInfo > &table_infos, const Executor *executor, const ExecutorDeviceType device_type_in, std::vector< std::shared_ptr< Analyzer::Expr >> &target_exprs_owned)
bool	anonymous_namespace{RelAlgExecutor.cpp}::can_use_bump_allocator (const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo)
ErrorInfo	anonymous_namespace{RelAlgExecutor.cpp}::getErrorDescription (const int32_t error_code)
JoinType	anonymous_namespace{RelAlgExecutor.cpp}::get_join_type (const RelAlgNode *ra)
std::unique_ptr< const RexOperator >	anonymous_namespace{RelAlgExecutor.cpp}::get_bitwise_equals (const RexScalar *scalar)
std::unique_ptr< const RexOperator >	anonymous_namespace{RelAlgExecutor.cpp}::get_bitwise_equals_conjunction (const RexScalar *scalar)
std::vector< JoinType >	anonymous_namespace{RelAlgExecutor.cpp}::left_deep_join_types (const RelLeftDeepInnerJoin *left_deep_join)
template<class RA >
std::vector< size_t >	anonymous_namespace{RelAlgExecutor.cpp}::do_table_reordering (std::vector< InputDescriptor > &input_descs, std::list< std::shared_ptr< const InputColDescriptor >> &input_col_descs, const JoinQualsPerNestingLevel &left_deep_join_quals, std::unordered_map< const RelAlgNode *, int > &input_to_nest_level, const RA *node, const std::vector< InputTableInfo > &query_infos, const Executor *executor)
std::vector< size_t >	anonymous_namespace{RelAlgExecutor.cpp}::get_left_deep_join_input_sizes (const RelLeftDeepInnerJoin *left_deep_join)
std::list< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::rewrite_quals (const std::list< std::shared_ptr< Analyzer::Expr >> &quals)
std::vector< const RexScalar * >	anonymous_namespace{RelAlgExecutor.cpp}::rex_to_conjunctive_form (const RexScalar *qual_expr)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{RelAlgExecutor.cpp}::build_logical_expression (const std::vector< std::shared_ptr< Analyzer::Expr >> &factors, const SQLOps sql_op)
template<class QualsList >
bool	anonymous_namespace{RelAlgExecutor.cpp}::list_contains_expression (const QualsList &haystack, const std::shared_ptr< Analyzer::Expr > &needle)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{RelAlgExecutor.cpp}::reverse_logical_distribution (const std::shared_ptr< Analyzer::Expr > &expr)
std::vector< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::synthesize_inputs (const RelAlgNode *ra_node, const size_t nest_level, const std::vector< TargetMetaInfo > &in_metainfo, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)
std::vector< Analyzer::Expr * >	anonymous_namespace{RelAlgExecutor.cpp}::get_raw_pointers (std::vector< std::shared_ptr< Analyzer::Expr >> const &input)
std::vector< std::shared_ptr < Analyzer::Expr > >	anonymous_namespace{RelAlgExecutor.cpp}::target_exprs_for_union (RelAlgNode const *input_node)
std::pair< std::vector < TargetMetaInfo > , std::vector< std::shared_ptr < Analyzer::Expr > > >	anonymous_namespace{RelAlgExecutor.cpp}::get_inputs_meta (const RelFilter *filter, const RelAlgTranslator &translator, const std::vector< std::shared_ptr< RexInput >> &inputs_owned, const std::unordered_map< const RelAlgNode *, int > &input_to_nest_level)

Variables
bool	g_skip_intermediate_count {true}
bool	g_enable_interop {false}
bool	g_enable_union {true}
size_t	g_estimator_failure_max_groupby_size {256000000}
bool	g_columnar_large_projections {true}
size_t	g_columnar_large_projections_threshold {1000000}
bool	g_enable_watchdog
size_t	g_watchdog_none_encoded_string_translation_limit
bool	g_enable_bump_allocator
size_t	g_default_max_groups_buffer_entry_guess
bool	g_enable_system_tables

Function Documentation

void build_render_targets	(	RenderInfo &	render_info,
		const std::vector< Analyzer::Expr * > &	work_unit_target_exprs,
		const std::vector< TargetMetaInfo > &	targets_meta
	)

Definition at line 224 of file RelAlgExecutor.cpp.

References CHECK_EQ, and RenderInfo::targets.

Referenced by RelAlgExecutor::executeRelAlgStep(), RelAlgExecutor::executeSort(), and RelAlgExecutor::executeWorkUnit().

                                                                         {
  CHECK_EQ(work_unit_target_exprs.size(), targets_meta.size());
  render_info.targets.clear();
  for (size_t i = 0; i < targets_meta.size(); ++i) {
    render_info.targets.emplace_back(std::make_shared<Analyzer::TargetEntry>(
        targets_meta[i].get_resname(),
        work_unit_target_exprs[i]->get_shared_ptr(),
        false));
  }
}

Here is the caller graph for this function:

TextEncodingCastCounts get_text_cast_counts

(

const RelAlgExecutionUnit &

ra_exe_unit

)

Definition at line 404 of file RelAlgExecutor.cpp.

References RelAlgExecutionUnit::groupby_exprs, RelAlgExecutionUnit::join_quals, RelAlgExecutionUnit::quals, RelAlgExecutionUnit::simple_quals, RelAlgExecutionUnit::target_exprs, TextEncodingCastCounts::text_decoding_casts, TextEncodingCastCounts::text_encoding_casts, and ScalarExprVisitor< T >::visit().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::check_none_encoded_string_cast_tuple_limit().

                                                                                    {
  TextEncodingCastCounts cast_counts;

  auto check_node_for_text_casts = [&cast_counts](
                                       const Analyzer::Expr* expr,
                                       const bool disregard_casts_to_none_encoding) {
    if (!expr) {
      return;
    }
    TextEncodingCastCountVisitor visitor(disregard_casts_to_none_encoding);
    const auto this_node_cast_counts = visitor.visit(expr);
    cast_counts.text_encoding_casts += this_node_cast_counts.text_encoding_casts;
    cast_counts.text_decoding_casts += this_node_cast_counts.text_decoding_casts;
  };

  for (const auto& qual : ra_exe_unit.quals) {
    check_node_for_text_casts(qual.get(), false);
  }
  for (const auto& simple_qual : ra_exe_unit.simple_quals) {
    check_node_for_text_casts(simple_qual.get(), false);
  }
  for (const auto& groupby_expr : ra_exe_unit.groupby_exprs) {
    check_node_for_text_casts(groupby_expr.get(), false);
  }
  for (const auto& target_expr : ra_exe_unit.target_exprs) {
    check_node_for_text_casts(target_expr, false);
  }
  for (const auto& join_condition : ra_exe_unit.join_quals) {
    for (const auto& join_qual : join_condition.quals) {
      // We currently need to not count casts to none-encoded strings for join quals,
      // as analyzer will generate these but our join framework disregards them.
      // Some investigation was done on having analyzer issue the correct inter-string
      // dictionary casts, but this actually causes them to get executed and so the same
      // work gets done twice.
      check_node_for_text_casts(join_qual.get(),
                                true /* disregard_casts_to_none_encoding */);
    }
  }
  return cast_counts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_validate_or_explain_query

(

const ExecutionOptions &

eo

)

Definition at line 237 of file RelAlgExecutor.cpp.

References ExecutionOptions::just_calcite_explain, ExecutionOptions::just_explain, and ExecutionOptions::just_validate.

Referenced by RelAlgExecutor::canUseResultsetCache(), RelAlgExecutor::executeTableFunction(), and RelAlgExecutor::executeWorkUnit().

                                                              {
  return eo.just_validate || eo.just_explain || eo.just_calcite_explain;
}

Here is the caller graph for this function:

bool isGeometry

(

TargetMetaInfo const &

target_meta_info

)

Definition at line 2719 of file RelAlgExecutor.cpp.

References TargetMetaInfo::get_type_info(), and SQLTypeInfo::is_geometry().

Referenced by RelAlgExecutor::executeUnion().

                                                        {
  return target_meta_info.get_type_info().is_geometry();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool sameTypeInfo	(	std::vector< TargetMetaInfo > const &	lhs,
		std::vector< TargetMetaInfo > const &	rhs
	)

Definition at line 2706 of file RelAlgExecutor.cpp.

                                                        {
  if (lhs.size() == rhs.size()) {
    for (size_t i = 0; i < lhs.size(); ++i) {
      if (lhs[i].get_type_info() != rhs[i].get_type_info()) {
        return false;
      }
    }
    return true;
  }
  return false;
}

Variable Documentation

bool g_columnar_large_projections {true}

Definition at line 58 of file RelAlgExecutor.cpp.

Referenced by CommandLineOptions::fillDeveloperOptions(), and anonymous_namespace{RelAlgExecutor.cpp}::should_output_columnar().

size_t g_columnar_large_projections_threshold {1000000}

Definition at line 59 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeWorkUnit(), CommandLineOptions::fillDeveloperOptions(), and anonymous_namespace{RelAlgExecutor.cpp}::should_output_columnar().

size_t g_default_max_groups_buffer_entry_guess

Definition at line 112 of file Execute.cpp.

Referenced by RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createSortInputWorkUnit(), and RelAlgExecutor::createUnionWorkUnit().

bool g_enable_bump_allocator

Definition at line 125 of file Execute.cpp.

bool g_enable_interop {false}

Definition at line 55 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeRelAlgSeq(), and CommandLineOptions::fillOptions().

bool g_enable_system_tables

Definition at line 64 of file SysCatalog.cpp.

bool g_enable_union {true}

Definition at line 56 of file RelAlgExecutor.cpp.

Referenced by CommandLineOptions::fillOptions(), CommandLineOptions::parse_command_line(), and RelLogicalUnion::RelLogicalUnion().

bool g_enable_watchdog

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::check_none_encoded_string_cast_tuple_limit(), CodeGenerator::codegen(), CodeGenerator::codegenQualifierCmp(), Parser::create_stmt_for_query(), QueryRunner::QueryRunner::createStatement(), ShowCreateTableCommand::execute(), Parser::CreateViewStmt::execute(), DBHandler::execute_rel_alg(), anonymous_namespace{RelAlgTranslator.cpp}::fill_dictionary_encoded_in_vals(), anonymous_namespace{RelAlgTranslator.cpp}::fill_integer_in_vals(), anonymous_namespace{RelAlgTranslator.cpp}::get_in_values_expr(), Parser::LocalQueryConnector::getOuterFragmentCount(), QueryRunner::QueryRunner::getParsedGlobalQueryHints(), QueryRunner::QueryRunner::getParsedQueryHint(), QueryRunner::QueryRunner::getParsedQueryHints(), QueryRunner::QueryRunner::getQueryInfoForDataRecyclerTest(), QueryRunner::QueryRunner::getRaExecutionSequence(), QueryRunner::QueryRunner::getRelAlgDag(), QueryRunner::QueryRunner::getRelAlgTranslator(), QueryRunner::QueryRunner::getRootNodeFromParsedQuery(), RelAlgExecutor::handleOutOfMemoryRetry(), anonymous_namespace{GroupByAndAggregate.cpp}::init_count_distinct_descriptors(), GroupByAndAggregate::initQueryMemoryDescriptorImpl(), CommandLineOptions::parse_command_line(), DBHandler::processCalciteRequest(), RelAlgDag::registerQueryHints(), QueryRunner::anonymous_namespace{QueryRunner.cpp}::run_select_query_with_filter_push_down(), QueryRunner::QueryRunner::runDDLStatement(), QueryRunner::QueryRunner::runSelectQuery(), QueryRunner::QueryRunner::runSQLWithAllowingInterrupt(), ResultSet::sort(), RelAlgTranslator::translateInOper(), and QueryRunner::QueryRunner::validateDDLStatement().

size_t g_estimator_failure_max_groupby_size {256000000}

Definition at line 57 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeWorkUnit(), and CommandLineOptions::fillDeveloperOptions().

bool g_skip_intermediate_count {true}

Definition at line 54 of file RelAlgExecutor.cpp.

Referenced by RelAlgExecutor::executeRelAlgStep(), and CommandLineOptions::fillDeveloperOptions().

size_t g_watchdog_none_encoded_string_translation_limit

Definition at line 82 of file Execute.cpp.