#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <cstddef>
#include <cstdlib>
#include <deque>
#include <functional>
#include <limits>
#include <map>
#include <mutex>
#include <queue>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <llvm/IR/Function.h>
#include <llvm/IR/Value.h>
#include <llvm/Linker/Linker.h>
#include <llvm/Transforms/Utils/ValueMapper.h>
#include <rapidjson/document.h>
#include "QueryEngine/AggregatedColRange.h"
#include "QueryEngine/BufferCompaction.h"
#include "QueryEngine/CartesianProduct.h"
#include "QueryEngine/CgenState.h"
#include "QueryEngine/CodeCache.h"
#include "QueryEngine/CodeCacheAccessor.h"
#include "QueryEngine/CompilationOptions.h"
#include "QueryEngine/DateTimeUtils.h"
#include "QueryEngine/Descriptors/QueryCompilationDescriptor.h"
#include "QueryEngine/Descriptors/QueryFragmentDescriptor.h"
#include "QueryEngine/ExecutionKernel.h"
#include "QueryEngine/ExternalCacheInvalidators.h"
#include "QueryEngine/GpuSharedMemoryContext.h"
#include "QueryEngine/GroupByAndAggregate.h"
#include "QueryEngine/JoinHashTable/HashJoin.h"
#include "QueryEngine/LoopControlFlow/JoinLoop.h"
#include "QueryEngine/NvidiaKernel.h"
#include "QueryEngine/PlanState.h"
#include "QueryEngine/QueryPlanDagCache.h"
#include "QueryEngine/RelAlgExecutionUnit.h"
#include "QueryEngine/RelAlgTranslator.h"
#include "QueryEngine/ResultSetRecyclerHolder.h"
#include "QueryEngine/StringDictionaryGenerations.h"
#include "QueryEngine/TableGenerations.h"
#include "QueryEngine/TargetMetaInfo.h"
#include "QueryEngine/WindowContext.h"
#include "DataMgr/Chunk/Chunk.h"
#include "Logger/Logger.h"
#include "Shared/DbObjectKeys.h"
#include "Shared/SystemParameters.h"
#include "Shared/funcannotations.h"
#include "Shared/heavyai_shared_mutex.h"
#include "Shared/measure.h"
#include "Shared/thread_count.h"
#include "Shared/toString.h"
#include "StringDictionary/LruCache.hpp"
#include "StringDictionary/StringDictionary.h"
#include "StringDictionary/StringDictionaryProxy.h"
#include "ThriftHandler/CommandLineOptions.h"

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

Classes
class	QuerySessionStatus

class	WatchdogException

class	CompilationRetryNoLazyFetch

class	CompilationRetryNewScanLimit

class	TooManyLiterals

class	CompilationRetryNoCompaction

class	QueryMustRunOnCpu

class	ParseIRError

class	StringConstInResultSet

struct	TableUpdateMetadata

class	UpdateLogForFragment

class	Executor

struct	Executor::JoinHashTableOrError

struct	Executor::GroupColLLVMValue

class	Executor::CgenStateManager

class	Executor::FetchCacheAnchor

struct	Executor::ExecutorMutexHolder

Namespaces
	foreign_storage

Typedefs
using	QueryCompilationDescriptorOwned = std::unique_ptr< QueryCompilationDescriptor >

using	QueryMemoryDescriptorOwned = std::unique_ptr< QueryMemoryDescriptor >

using	QuerySessionId = std::string

using	CurrentQueryStatus = std::pair< QuerySessionId, std::string >

using	InterruptFlagMap = std::map< QuerySessionId, bool >

using	QuerySessionMap = std::map< const QuerySessionId, std::map< std::string, QuerySessionStatus >>

using	RowDataProvider = Fragmenter_Namespace::RowDataProvider

using	ColumnToFragmentsMap = std::map< const ColumnDescriptor *, std::set< int32_t >>

using	TableToFragmentIds = std::map< int32_t, std::set< int32_t >>

using	LLVMValueVector = std::vector< llvm::Value * >

Enumerations
enum	FragmentSkipStatus { SKIPPABLE, NOT_SKIPPABLE, INVALID }

Functions
llvm::Value *	get_arg_by_name (llvm::Function *func, const std::string &name)

uint32_t	log2_bytes (const uint32_t bytes)

const ColumnDescriptor *	get_column_descriptor (const shared::ColumnKey &column_key)

const Analyzer::Expr *	extract_cast_arg (const Analyzer::Expr *expr)

std::string	numeric_type_name (const SQLTypeInfo &ti)

const ColumnDescriptor *	get_column_descriptor_maybe (const shared::ColumnKey &column_key)

const ResultSetPtr &	get_temporary_table (const TemporaryTables *temporary_tables, const int table_id)

const SQLTypeInfo	get_column_type (const int col_id, const int table_id, const ColumnDescriptor cd, const TemporaryTables temporary_tables)

std::ostream &	operator<< (std::ostream &, FetchResult const &)

std::string	get_null_check_suffix (const SQLTypeInfo &lhs_ti, const SQLTypeInfo &rhs_ti)

bool	is_unnest (const Analyzer::Expr *expr)

bool	is_constructed_point (const Analyzer::Expr *expr)

size_t	get_loop_join_size (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)

std::unordered_set< int >	get_available_gpus (const Catalog_Namespace::Catalog &cat)

size_t	get_context_count (const ExecutorDeviceType device_type, const size_t cpu_count, const size_t gpu_count)

RUNTIME_EXPORT void	register_buffer_with_executor_rsm (int64_t exec, int8_t *buffer)

const Analyzer::Expr *	remove_cast_to_int (const Analyzer::Expr *expr)

std::string	toString (const Executor::ExtModuleKinds &kind)

void	foreign_storage::populate_string_dictionary (int32_t table_id, int32_t col_id, int32_t db_id)

Typedef Documentation

using ColumnToFragmentsMap = std::map<const ColumnDescriptor*, std::set<int32_t>>

Definition at line 314 of file Execute.h.

using CurrentQueryStatus = std::pair<QuerySessionId, std::string>

Definition at line 86 of file Execute.h.

using InterruptFlagMap = std::map<QuerySessionId, bool>

Definition at line 87 of file Execute.h.

using LLVMValueVector = std::vector<llvm::Value*>

Definition at line 359 of file Execute.h.

using QueryCompilationDescriptorOwned = std::unique_ptr<QueryCompilationDescriptor>

Definition at line 82 of file Execute.h.

using QueryMemoryDescriptorOwned = std::unique_ptr<QueryMemoryDescriptor>

Definition at line 84 of file Execute.h.

using QuerySessionId = std::string

Definition at line 85 of file Execute.h.

using QuerySessionMap = std::map<const QuerySessionId, std::map<std::string, QuerySessionStatus>>

Definition at line 154 of file Execute.h.

using RowDataProvider = Fragmenter_Namespace::RowDataProvider

Definition at line 313 of file Execute.h.

using TableToFragmentIds = std::map<int32_t, std::set<int32_t>>

Definition at line 315 of file Execute.h.

Enumeration Type Documentation

enum FragmentSkipStatus

Enumerator
SKIPPABLE
NOT_SKIPPABLE
INVALID

Definition at line 163 of file Execute.h.

163 { SKIPPABLE, NOT_SKIPPABLE, INVALID };

NOT_SKIPPABLE

Definition: Execute.h:163

SKIPPABLE

Definition: Execute.h:163

INVALID

Definition: Execute.h:163

Function Documentation

const Analyzer::Expr* extract_cast_arg ( const Analyzer::Expr * expr )

inline

Definition at line 201 of file Execute.h.

References kCAST.

Referenced by CodeGenerator::codegen(), CodeGenerator::createInValuesBitmap(), and anonymous_namespace{ExpressionRewrite.cpp}::OrToInVisitor::visitBinOper().

                                                                       {
   const auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr);
   if (!cast_expr || cast_expr->get_optype() != kCAST) {
     return expr;
   }
   return cast_expr->get_operand();
 }

Here is the caller graph for this function:

llvm::Value* get_arg_by_name	(	llvm::Function *	func,
		const std::string &	name
	)

inline

Definition at line 167 of file Execute.h.

References CHECK, and setup::name.

Referenced by GroupByAndAggregate::codegen(), TargetExprCodegen::codegenAggregate(), CodeGenerator::codegenFunctionOper(), HashJoin::codegenHashTableLoad(), PerfectJoinHashTable::codegenHashTableLoad(), CodeGenerator::codegenHoistedConstantsLoads(), GroupByAndAggregate::codegenOutputSlot(), CodeGenerator::codegenRowId(), GroupByAndAggregate::getAdditionalLiteral(), and Executor::preloadFragOffsets().

                                                                              {
   for (auto& arg : func->args()) {
     if (arg.getName() == name) {
       return &arg;
     }
   }
   CHECK(false);
   return nullptr;
 }

Here is the caller graph for this function:

std::unordered_set<int> get_available_gpus ( const Catalog_Namespace::Catalog & cat )

const ColumnDescriptor* get_column_descriptor ( const shared::ColumnKey & column_key )

inline

Definition at line 192 of file Execute.h.

References CHECK, CHECK_GT, shared::ColumnKey::db_id, Catalog_Namespace::get_metadata_for_column(), and shared::ColumnKey::table_id.

Referenced by CodeGenerator::codegenColVar(), CodeGenerator::codegenGeoColumnVar(), RelAlgExecutor::executeSimpleInsert(), get_column_descriptor_maybe(), Executor::getColLazyFetchInfo(), ColumnFetcher::getOneTableColumnFragment(), spatial_type::NPoints::getOperand(), spatial_type::NRings::getOperand(), spatial_type::NumGeometries::getOperand(), PlanState::isLazyFetchColumn(), RelAlgExecutor::isRowidLookup(), ColumnFetcher::linearizeColumnFragments(), and Executor::skipFragment().

                                        {
   CHECK_GT(column_key.db_id, 0);
   CHECK_GT(column_key.table_id, 0);
   const auto col_desc = Catalog_Namespace::get_metadata_for_column(column_key);
   CHECK(col_desc);
   return col_desc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const ColumnDescriptor* get_column_descriptor_maybe ( const shared::ColumnKey & column_key )

inline

Definition at line 220 of file Execute.h.

References get_column_descriptor(), and shared::ColumnKey::table_id.

Referenced by anonymous_namespace{GroupByAndAggregate.cpp}::expr_is_rowid(), OverlapsJoinHashTable::fetchColumnsForDevice(), PerfectJoinHashTable::fetchColumnsForDevice(), BaselineJoinHashTable::fetchColumnsForDevice(), Executor::getColLazyFetchInfo(), Executor::getColumnDescriptor(), ColumnFetcher::getOneColumnFragment(), Executor::getPhysicalColumnDescriptor(), needs_dictionary_translation(), HashJoin::normalizeColumnPair(), anonymous_namespace{QueryMemoryDescriptor.cpp}::target_expr_proj_indices(), and anonymous_namespace{Execute.cpp}::try_get_column_descriptor().

                                        {
   return column_key.table_id > 0 ? get_column_descriptor(column_key) : nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const SQLTypeInfo get_column_type	(	const int	col_id,
		const int	table_id,
		const ColumnDescriptor *	cd,
		const TemporaryTables *	temporary_tables
	)

inline

Definition at line 233 of file Execute.h.

References CHECK, CHECK_EQ, ColumnDescriptor::columnId, ColumnDescriptor::columnType, get_temporary_table(), and ColumnDescriptor::tableId.

Referenced by ColumnFetcher::getOneTableColumnFragment(), needs_dictionary_translation(), and HashJoin::normalizeColumnPair().

                                                                                   {
   CHECK(cd || temporary_tables);
   if (cd) {
     CHECK_EQ(col_id, cd->columnId);
     CHECK_EQ(table_id, cd->tableId);
     return cd->columnType;
   }
   const auto& temp = get_temporary_table(temporary_tables, table_id);
   return temp->getColType(col_id);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t get_context_count	(	const ExecutorDeviceType	device_type,
		const size_t	cpu_count,
		const size_t	gpu_count
	)

Definition at line 1453 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl().

                                                  {
   return device_type == ExecutorDeviceType::GPU ? gpu_count
                                                 : static_cast<size_t>(cpu_count);
 }

Here is the caller graph for this function:

size_t get_loop_join_size	(	const std::vector< InputTableInfo > &	query_infos,
		const RelAlgExecutionUnit &	ra_exe_unit
	)

Definition at line 1561 of file Execute.cpp.

References CHECK, and RelAlgExecutionUnit::input_descs.

Referenced by anonymous_namespace{IRCodegen.cpp}::check_if_loop_join_is_allowed().

                                                                   {
   const auto inner_table_key = ra_exe_unit.input_descs.back().getTableKey();
 
   std::optional<size_t> inner_table_idx;
   for (size_t i = 0; i < query_infos.size(); ++i) {
     if (query_infos[i].table_key == inner_table_key) {
       inner_table_idx = i;
       break;
     }
   }
   CHECK(inner_table_idx);
   return query_infos[*inner_table_idx].info.getNumTuples();
 }

Here is the caller graph for this function:

std::string get_null_check_suffix	(	const SQLTypeInfo &	lhs_ti,
		const SQLTypeInfo &	rhs_ti
	)

inline

Definition at line 1487 of file Execute.h.

References CHECK, and SQLTypeInfo::get_notnull().

Referenced by CodeGenerator::codegenCmp(), CodeGenerator::codegenDeciDiv(), CodeGenerator::codegenFpArith(), CodeGenerator::codegenIntArith(), and CodeGenerator::codegenStrCmp().

                                                                     {
   if (lhs_ti.get_notnull() && rhs_ti.get_notnull()) {
     return "";
   }
   std::string null_check_suffix{"_nullable"};
   if (lhs_ti.get_notnull()) {
     CHECK(!rhs_ti.get_notnull());
     null_check_suffix += "_rhs";
   } else if (rhs_ti.get_notnull()) {
     CHECK(!lhs_ti.get_notnull());
     null_check_suffix += "_lhs";
   }
   return null_check_suffix;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const ResultSetPtr& get_temporary_table	(	const TemporaryTables *	temporary_tables,
		const int	table_id
	)

inline

Definition at line 225 of file Execute.h.

References CHECK, and CHECK_LT.

Referenced by anonymous_namespace{ExternalExecutor.cpp}::create_table_schema(), RelAlgExecutor::executeDelete(), RelAlgExecutor::executeProject(), RelAlgExecutor::executeUpdate(), get_column_type(), ColumnFetcher::getOneColumnFragment(), and ColumnFetcher::getResultSetColumn().

                                                                    {
   CHECK_LT(table_id, 0);
   const auto it = temporary_tables->find(table_id);
   CHECK(it != temporary_tables->end());
   return it->second;
 }

Here is the caller graph for this function:

bool is_constructed_point ( const Analyzer::Expr * expr )

inline

Definition at line 1508 of file Execute.h.

References Analyzer::UOper::get_operand(), and kCAST.

Referenced by anonymous_namespace{FromTableReordering.cpp}::get_join_qual_cost(), CodeGenerator::hashJoinLhs(), CodeGenerator::needCastForHashJoinLhs(), HashJoin::normalizeColumnPair(), and rewrite_overlaps_conjunction().

                                                            {
   auto uoper = dynamic_cast<const Analyzer::UOper*>(expr);
   auto oper = (uoper && uoper->get_optype() == kCAST) ? uoper->get_operand() : expr;
   auto arr = dynamic_cast<const Analyzer::ArrayExpr*>(oper);
   return (arr && arr->isLocalAlloc() && arr->get_type_info().is_fixlen_array());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_unnest ( const Analyzer::Expr * expr )

inline

Definition at line 1503 of file Execute.h.

References Analyzer::UOper::get_optype(), and kUNNEST.

Referenced by CodeGenerator::codegen(), and CodeGenerator::codegenCmp().

                                                 {
   return dynamic_cast<const Analyzer::UOper*>(expr) &&
          static_cast<const Analyzer::UOper*>(expr)->get_optype() == kUNNEST;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t log2_bytes ( const uint32_t bytes )

inline

Definition at line 177 of file Execute.h.

Referenced by CodeGenerator::codegen(), GroupByAndAggregate::codegenAggArg(), CodeGenerator::codegenFunctionOperCastArgs(), CodeGenerator::codegenGeoArgs(), spatial_type::Centroid::codegenLoads(), spatial_type::Distance::codegenLoads(), spatial_type::AreaPerimeter::codegenLoads(), spatial_type::StartEndPoint::codegenLoads(), spatial_type::PointN::codegenLoads(), spatial_type::NPoints::codegenLoads(), spatial_type::NRings::codegenLoads(), spatial_type::NumGeometries::codegenLoads(), and Executor::groupByColumnCodegen().

                                                  {
   switch (bytes) {
     case 1:
       return 0;
     case 2:
       return 1;
     case 4:
       return 2;
     case 8:
       return 3;
     default:
       abort();
   }
 }

Here is the caller graph for this function:

std::string numeric_type_name ( const SQLTypeInfo & ti )

inline

Definition at line 209 of file Execute.h.

References CHECK, SQLTypeInfo::get_compression(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_type(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timeinterval(), kDOUBLE, kENCODING_DICT, and to_string().

                                                           {
   CHECK(ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
         ti.is_fp() || (ti.is_string() && ti.get_compression() == kENCODING_DICT) ||
         ti.is_timeinterval());
   if (ti.is_integer() || ti.is_decimal() || ti.is_boolean() || ti.is_time() ||
       ti.is_string() || ti.is_timeinterval()) {
     return "int" + std::to_string(ti.get_logical_size() * 8) + "_t";
   }
   return ti.get_type() == kDOUBLE ? "double" : "float";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::ostream& operator<<	(	std::ostream &	,
		FetchResult const &
	)

Definition at line 2910 of file Execute.cpp.

References FetchResult::col_buffers, FetchResult::frag_offsets, FetchResult::num_rows, and shared::printContainer().

                                                                         {
   return os << "col_buffers" << shared::printContainer(fetch_result.col_buffers)
             << " num_rows" << shared::printContainer(fetch_result.num_rows)
             << " frag_offsets" << shared::printContainer(fetch_result.frag_offsets);
 }

Here is the call graph for this function:

RUNTIME_EXPORT void register_buffer_with_executor_rsm	(	int64_t	exec,
		int8_t *	buffer
	)

Definition at line 232 of file ExtensionsIR.cpp.

                                                                                  {
   Executor* exec_ptr = reinterpret_cast<Executor*>(exec);
   if (buffer != nullptr) {
     exec_ptr->getRowSetMemoryOwner()->addVarlenBuffer(buffer);
   }
 }

const Analyzer::Expr* remove_cast_to_int ( const Analyzer::Expr * expr )

Definition at line 606 of file ColumnIR.cpp.

References Analyzer::Expr::get_type_info(), and kCAST.

Referenced by anonymous_namespace{DateTimePlusRewrite.cpp}::get_dt_field(), CodeGenerator::hashJoinLhs(), and CodeGenerator::needCastForHashJoinLhs().

                                                                  {
   const auto uoper = dynamic_cast<const Analyzer::UOper*>(expr);
   if (!uoper || uoper->get_optype() != kCAST) {
     return nullptr;
   }
   const auto& target_ti = uoper->get_type_info();
   if (!target_ti.is_integer()) {
     return nullptr;
   }
   return uoper->get_operand();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string toString ( const Executor::ExtModuleKinds & kind )

inline

Definition at line 1529 of file Execute.h.

References logger::FATAL, LOG, Executor::rt_geos_module, Executor::rt_libdevice_module, Executor::rt_udf_cpu_module, Executor::rt_udf_gpu_module, Executor::template_module, Executor::udf_cpu_module, and Executor::udf_gpu_module.

                                                               {
   switch (kind) {
     case Executor::ExtModuleKinds::template_module:
       return "template_module";
     case Executor::ExtModuleKinds::rt_geos_module:
       return "rt_geos_module";
     case Executor::ExtModuleKinds::rt_libdevice_module:
       return "rt_libdevice_module";
     case Executor::ExtModuleKinds::udf_cpu_module:
       return "udf_cpu_module";
     case Executor::ExtModuleKinds::udf_gpu_module:
       return "udf_gpu_module";
     case Executor::ExtModuleKinds::rt_udf_cpu_module:
       return "rt_udf_cpu_module";
     case Executor::ExtModuleKinds::rt_udf_gpu_module:
       return "rt_udf_gpu_module";
   }
   LOG(FATAL) << "Invalid LLVM module kind.";
   return "";
 }

Classes

Namespaces

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation