#include <QueryRunner.h>

Inheritance diagram for QueryRunner::QueryRunner:

Collaboration diagram for QueryRunner::QueryRunner:

Public Member Functions
std::shared_ptr < Catalog_Namespace::SessionInfo >	getSession () const

void	addSessionId (const std::string &session_id, ExecutorDeviceType device_type=ExecutorDeviceType::GPU)

void	clearSessionId ()

std::shared_ptr < Catalog_Namespace::Catalog >	getCatalog () const

std::shared_ptr< Calcite >	getCalcite () const

std::shared_ptr< Executor >	getExecutor () const

Catalog_Namespace::UserMetadata &	getUserMetadata () const

bool	gpusPresent () const

virtual void	clearGpuMemory () const

virtual void	clearCpuMemory () const

std::vector< MemoryInfo >	getMemoryInfo (const Data_Namespace::MemoryLevel memory_level) const

BufferPoolStats	getBufferPoolStats (const Data_Namespace::MemoryLevel memory_level, const bool current_db_only) const

virtual std::unique_ptr < Parser::Stmt >	createStatement (const std::string &)

virtual void	runDDLStatement (const std::string &)

virtual void	validateDDLStatement (const std::string &)

virtual std::shared_ptr < ResultSet >	runSQL (const std::string &query_str, CompilationOptions co, ExecutionOptions eo)

virtual std::shared_ptr < ExecutionResult >	runSelectQuery (const std::string &query_str, CompilationOptions co, ExecutionOptions eo)

virtual std::shared_ptr < ResultSet >	runSQL (const std::string &query_str, const ExecutorDeviceType device_type, const bool hoist_literals=true, const bool allow_loop_joins=true)

virtual std::shared_ptr < ExecutionResult >	runSelectQuery (const std::string &query_str, const ExecutorDeviceType device_type, const bool hoist_literals, const bool allow_loop_joins, const bool just_explain=false)

virtual std::shared_ptr < ResultSet >	runSQLWithAllowingInterrupt (const std::string &query_str, const std::string &session_id, const ExecutorDeviceType device_type, const double running_query_check_freq=0.9, const unsigned pending_query_check_freq=1000)

virtual std::vector < std::shared_ptr< ResultSet > >	runMultipleStatements (const std::string &, const ExecutorDeviceType)

virtual void	runImport (Parser::CopyTableStmt *import_stmt)

virtual std::unique_ptr < import_export::Loader >	getLoader (const TableDescriptor *td) const

RegisteredQueryHint	getParsedQueryHint (const std::string &)

std::optional < std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > >	getParsedQueryHints (const std::string &query_str)

std::shared_ptr< const RelAlgNode >	getRootNodeFromParsedQuery (const std::string &query_str)

std::optional < RegisteredQueryHint >	getParsedGlobalQueryHints (const std::string &query_str)

RaExecutionSequence	getRaExecutionSequence (const std::string &query_str)

virtual std::shared_ptr < ResultSet >	getCalcitePlan (const std::string &query_str, bool enable_watchdog, bool as_json_str) const

std::tuple< QueryPlanHash, std::shared_ptr< HashTable > , std::optional < HashtableCacheMetaInfo > >	getCachedHashtableWithoutCacheKey (std::set< size_t > &visited, CacheItemType hash_table_type, DeviceIdentifier device_identifier)

std::shared_ptr< CacheItemMetric >	getCacheItemMetric (QueryPlanHash cache_key, CacheItemType hash_table_type, DeviceIdentifier device_identifier)

size_t	getNumberOfCachedItem (CacheItemStatus item_status, CacheItemType hash_table_type, bool with_overlaps_tuning_param=false) const

void	resizeDispatchQueue (const size_t num_executors)

QueryPlanDagInfo	getQueryInfoForDataRecyclerTest (const std::string &)

std::shared_ptr< RelAlgTranslator >	getRelAlgTranslator (const std::string &, Executor *)

ExtractedQueryPlanDag	extractQueryPlanDag (const std::string &)

std::unique_ptr< RelAlgDag >	getRelAlgDag (const std::string &)

	QueryRunner (std::unique_ptr< Catalog_Namespace::SessionInfo > session)

virtual	~QueryRunner ()=default

void	setExplainType (const ExecutorExplainType explain_type)

Static Public Member Functions
static QueryRunner *	init (const char *db_path, const std::string &udf_filename="", const size_t max_gpu_mem=0, const int reserved_gpu_mem=256<< 20)

static QueryRunner *	init (const File_Namespace::DiskCacheConfig disk_cache_config, const char db_path, const std::vector< LeafHostInfo > &string_servers={}, const std::vector< LeafHostInfo > &leaf_servers={})

static QueryRunner *	init (const char *db_path, const std::vector< LeafHostInfo > &string_servers, const std::vector< LeafHostInfo > &leaf_servers)

static QueryRunner *	init (const char db_path, const std::string &user, const std::string &pass, const std::string &db_name, const std::vector< LeafHostInfo > &string_servers, const std::vector< LeafHostInfo > &leaf_servers, const std::string &udf_filename="", bool uses_gpus=true, const size_t max_gpu_mem=0, const int reserved_gpu_mem=256<< 20, const bool create_user=false, const bool create_db=false, const File_Namespace::DiskCacheConfig config=nullptr)

static QueryRunner *	init (std::unique_ptr< Catalog_Namespace::SessionInfo > &session)

static QueryRunner *	get ()

static void	reset ()

static ExecutionOptions	defaultExecutionOptionsForRunSQL (bool allow_loop_joins=true, bool just_explain=false)

template<typename... Ts>
static std::shared_ptr < query_state::QueryState >	create_query_state (Ts &&...args)

Static Public Attributes
static query_state::QueryStates	query_states_

Protected Member Functions
	QueryRunner (const char db_path, const std::string &user, const std::string &pass, const std::string &db_name, const std::vector< LeafHostInfo > &string_servers, const std::vector< LeafHostInfo > &leaf_servers, const std::string &udf_filename, bool uses_gpus, const size_t max_gpu_mem, const int reserved_gpu_mem, const bool create_user, const bool create_db, const File_Namespace::DiskCacheConfig disk_cache_config=nullptr)

Protected Attributes
ExecutorExplainType	explain_type_ = ExecutorExplainType::Default

Catalog_Namespace::DBMetadata	db_metadata_

std::shared_ptr < Catalog_Namespace::SessionInfo >	session_info_

std::unique_ptr < QueryDispatchQueue >	dispatch_queue_

std::shared_ptr< QueryEngine >	query_engine_

Static Protected Attributes
static std::unique_ptr < QueryRunner >	qr_instance_ = nullptr

Detailed Description

Definition at line 139 of file QueryRunner.h.

Constructor & Destructor Documentation

QueryRunner::QueryRunner::QueryRunner ( std::unique_ptr< Catalog_Namespace::SessionInfo > session )

Referenced by init().

Here is the caller graph for this function:

virtual QueryRunner::QueryRunner::~QueryRunner ( )

virtualdefault

QueryRunner::QueryRunner::QueryRunner	(	const char *	db_path,
		const std::string &	user,
		const std::string &	pass,
		const std::string &	db_name,
		const std::vector< LeafHostInfo > &	string_servers,
		const std::vector< LeafHostInfo > &	leaf_servers,
		const std::string &	udf_filename,
		bool	uses_gpus,
		const size_t	max_gpu_mem,
		const int	reserved_gpu_mem,
		const bool	create_user,
		const bool	create_db,
		const File_Namespace::DiskCacheConfig *	disk_cache_config = `nullptr`
	)

protected

Definition at line 153 of file QueryRunner.cpp.

References ExtensionFunctionsWhitelist::add(), ExtensionFunctionsWhitelist::addUdfs(), SystemParameters::aggregator, anonymous_namespace{QueryRunner.cpp}::calcite_shutdown_handler(), CALCITEPORT, cat(), CHECK, QueryEngine::createInstance(), db_metadata_, Catalog_Namespace::DBMetadata::dbOwner, File_Namespace::fsi, g_base_path, anonymous_namespace{QueryRunner.cpp}::g_calcite, g_read_only, g_serialize_temp_tables, table_functions::TableFunctionsFactory::get_table_funcs(), GPU, SystemParameters::gpu_buffer_mem_bytes, table_functions::TableFunctionsFactory::init(), Catalog_Namespace::SysCatalog::instance(), Catalog_Namespace::UserMetadata::isSuper, shared::kCatalogDirectoryName, shared::kDataDirectoryName, shared::kDefaultDbName, shared::kDefaultDiskCacheDirName, Catalog_Namespace::UserMetadata::passwd_hash, query_engine_, session_info_, logger::set_once_fatal_func(), anonymous_namespace{QueryRunner.cpp}::setup_signal_handler(), ThriftSerializers::to_thrift(), and Catalog_Namespace::UserMetadata::userId.

     : dispatch_queue_(std::make_unique<QueryDispatchQueue>(1)) {
   g_serialize_temp_tables = true;
   boost::filesystem::path base_path{db_path};
   CHECK(boost::filesystem::exists(base_path));
   auto system_db_file =
       base_path / shared::kCatalogDirectoryName / shared::kDefaultDbName;
   CHECK(boost::filesystem::exists(system_db_file));
   auto data_dir = base_path / shared::kDataDirectoryName;
   File_Namespace::DiskCacheConfig disk_cache_config{
       (base_path / shared::kDefaultDiskCacheDirName).string(),
       File_Namespace::DiskCacheLevel::fsi};
   if (cache_config) {
     disk_cache_config = *cache_config;
   }
   Catalog_Namespace::UserMetadata user;
 
   setup_signal_handler();
   logger::set_once_fatal_func(&calcite_shutdown_handler);
   g_calcite =
       std::make_shared<Calcite>(-1, CALCITEPORT, db_path, 1024, 5000, true, udf_filename);
   ExtensionFunctionsWhitelist::add(g_calcite->getExtensionFunctionWhitelist());
   if (!udf_filename.empty()) {
     ExtensionFunctionsWhitelist::addUdfs(g_calcite->getUserDefinedFunctionWhitelist());
   }
 
   table_functions::TableFunctionsFactory::init();
   auto udtfs = ThriftSerializers::to_thrift(
       table_functions::TableFunctionsFactory::get_table_funcs(/*is_runtime=*/false));
   std::vector<TUserDefinedFunction> udfs = {};
   g_calcite->setRuntimeExtensionFunctions(udfs, udtfs, /*is_runtime=*/false);
 
   std::unique_ptr<CudaMgr_Namespace::CudaMgr> cuda_mgr;
 #ifdef HAVE_CUDA
   if (uses_gpus) {
     cuda_mgr = std::make_unique<CudaMgr_Namespace::CudaMgr>(-1, 0);
   }
 #else
   uses_gpus = false;
 #endif
   SystemParameters mapd_params;
   mapd_params.gpu_buffer_mem_bytes = max_gpu_mem;
   mapd_params.aggregator = !leaf_servers.empty();
 
   auto& sys_cat = Catalog_Namespace::SysCatalog::instance();
 
   g_base_path = base_path.string();
 
   if (!sys_cat.isInitialized()) {
     auto data_mgr = std::make_shared<Data_Namespace::DataMgr>(data_dir.string(),
                                                               mapd_params,
                                                               std::move(cuda_mgr),
                                                               uses_gpus,
                                                               reserved_gpu_mem,
                                                               0,
                                                               disk_cache_config);
     sys_cat.init(g_base_path,
                  data_mgr,
                  {},
                  g_calcite,
                  false,
                  mapd_params.aggregator,
                  string_servers);
   }
 
   query_engine_ =
       QueryEngine::createInstance(sys_cat.getDataMgr().getCudaMgr(), !uses_gpus);
 
   if (create_user) {
     if (!sys_cat.getMetadataForUser(user_name, user)) {
       sys_cat.createUser(
           user_name,
           UserAlterations{
               passwd, /*is_super=*/false, /*default_db=*/"", /*can_login=*/true},
           g_read_only);
     }
   }
   CHECK(sys_cat.getMetadataForUser(user_name, user));
   CHECK(bcrypt_checkpw(passwd.c_str(), user.passwd_hash.c_str()) == 0);
 
   if (create_db) {
     if (!sys_cat.getMetadataForDB(db_name, db_metadata_)) {
       sys_cat.createDatabase(db_name, user.userId);
     }
   }
   CHECK(sys_cat.getMetadataForDB(db_name, db_metadata_));
   CHECK(user.isSuper || (user.userId == db_metadata_.dbOwner));
   auto cat = sys_cat.getCatalog(db_metadata_, create_db);
   CHECK(cat);
   session_info_ = std::make_unique<Catalog_Namespace::SessionInfo>(
       cat, user, ExecutorDeviceType::GPU, "");
 }

Here is the call graph for this function:

Member Function Documentation

void QueryRunner::QueryRunner::addSessionId	(	const std::string &	session_id,
		ExecutorDeviceType	device_type = `ExecutorDeviceType::GPU`
	)

inline

Definition at line 194 of file QueryRunner.h.

References session_info_.

                                                                             {
     auto user_info = session_info_->get_currentUser();
     session_info_ = std::make_unique<Catalog_Namespace::SessionInfo>(
         session_info_->get_catalog_ptr(), user_info, device_type, session_id);
   }

void QueryRunner::QueryRunner::clearCpuMemory ( ) const

virtual

Definition at line 286 of file QueryRunner.cpp.

References CHECK, Executor::clearMemory(), Data_Namespace::CPU_LEVEL, and Catalog_Namespace::SysCatalog::instance().

                                        {
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   Executor::clearMemory(Data_Namespace::MemoryLevel::CPU_LEVEL);
 }

Here is the call graph for this function:

void QueryRunner::QueryRunner::clearGpuMemory ( ) const

virtual

Definition at line 281 of file QueryRunner.cpp.

References CHECK, Executor::clearMemory(), Data_Namespace::GPU_LEVEL, and Catalog_Namespace::SysCatalog::instance().

                                        {
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   Executor::clearMemory(Data_Namespace::MemoryLevel::GPU_LEVEL);
 }

Here is the call graph for this function:

void QueryRunner::QueryRunner::clearSessionId ( )

inline

Definition at line 201 of file QueryRunner.h.

References session_info_.

201 { session_info_ = nullptr; }

QueryRunner::QueryRunner::session_info_

std::shared_ptr< Catalog_Namespace::SessionInfo > session_info_

Definition: QueryRunner.h:330

template<typename... Ts>

static std::shared_ptr<query_state::QueryState> QueryRunner::QueryRunner::create_query_state ( Ts &&... args )

inlinestatic

Definition at line 303 of file QueryRunner.h.

References run_benchmark_import::args, query_state::QueryStates::create(), and query_states_.

Referenced by createStatement(), getCalcitePlan(), getExecutor(), getParsedGlobalQueryHints(), getParsedQueryHint(), getParsedQueryHints(), getQueryInfoForDataRecyclerTest(), getRaExecutionSequence(), getRelAlgDag(), getRelAlgTranslator(), getRootNodeFromParsedQuery(), runDDLStatement(), runSelectQuery(), runSQLWithAllowingInterrupt(), and validateDDLStatement().

                                                                                {
     return query_states_.create(std::forward<Ts>(args)...);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< Parser::Stmt > QueryRunner::QueryRunner::createStatement ( const std::string & stmt_str_in )

virtual

Definition at line 533 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), Parser::create_stmt_for_json(), g_enable_watchdog, Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, STDLOG, and UNREACHABLE.

                                   {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
 
   std::string stmt_str = stmt_str_in;
   // First remove special chars
   boost::algorithm::trim_left_if(stmt_str, boost::algorithm::is_any_of("\n"));
   // Then remove spaces
   boost::algorithm::trim_left(stmt_str);
 
   ParserWrapper pw{stmt_str};
 
   auto query_state = create_query_state(session_info_, stmt_str);
   auto stdlog = STDLOG(query_state);
 
   if (pw.is_ddl) {
     const auto& cat = session_info_->getCatalog();
     auto calcite_mgr = cat.getCalciteMgr();
     const auto calciteQueryParsingOption =
         calcite_mgr->getCalciteQueryParsingOption(true, false, true);
     const auto calciteOptimizationOption =
         calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
     const auto query_json = calcite_mgr
                                 ->process(query_state->createQueryStateProxy(),
                                           pg_shim(stmt_str),
                                           calciteQueryParsingOption,
                                           calciteOptimizationOption)
                                 .plan_result;
     return Parser::create_stmt_for_json(query_json);
   }
 
   // simply fail here as non-Calcite parsing is about to be removed
   UNREACHABLE();
   return nullptr;
 }

Here is the call graph for this function:

ExecutionOptions QueryRunner::QueryRunner::defaultExecutionOptionsForRunSQL	(	bool	allow_loop_joins = `true`,
		bool	just_explain = `false`
	)

static

Definition at line 639 of file QueryRunner.cpp.

References g_enable_columnar_output, and g_gpu_mem_limit_percent.

Referenced by runSelectQuery(), and runSQL().

                                                                                   {
   return {g_enable_columnar_output,
           false,
           true,
           just_explain,
           allow_loop_joins,
           false,
           false,
           false,
           false,
           10000,
           false,
           false,
           g_gpu_mem_limit_percent,
           false,
           1000,
           false};
 }

Here is the caller graph for this function:

ExtractedQueryPlanDag QueryRunner::QueryRunner::extractQueryPlanDag ( const std::string & query_str )

Definition at line 967 of file QueryRunner.cpp.

References QueryPlanDagExtractor::extractQueryPlanDag(), Executor::getExecutor(), getQueryInfoForDataRecyclerTest(), and Executor::UNITARY_EXECUTOR_ID.

                                                                                  {
   auto query_dag_info = getQueryInfoForDataRecyclerTest(query_str);
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID).get();
   auto extracted_dag_info = QueryPlanDagExtractor::extractQueryPlanDag(
       query_dag_info.root_node.get(), executor);
   return extracted_dag_info;
 }

Here is the call graph for this function:

static QueryRunner* QueryRunner::QueryRunner::get ( )

inlinestatic

Definition at line 181 of file QueryRunner.h.

References qr_instance_.

                             {
     if (!qr_instance_) {
       throw std::runtime_error("QueryRunner must be initialized before calling get().");
     }
     return qr_instance_.get();
   }

BufferPoolStats QueryRunner::QueryRunner::getBufferPoolStats	(	const Data_Namespace::MemoryLevel	memory_level,
		const bool	current_db_only
	)		const

Definition at line 297 of file QueryRunner.cpp.

References CHECK, CHECK_EQ, Data_Namespace::CPU_LEVEL, db_metadata_, Catalog_Namespace::DBMetadata::dbId, Buffer_Namespace::FREE, Catalog_Namespace::SysCatalog::instance(), and session_info_.

                                       {
   // Only works single-node for now
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   const std::vector<MemoryInfo> memory_infos =
       session_info_->getCatalog().getDataMgr().getMemoryInfo(memory_level);
   if (memory_level == Data_Namespace::MemoryLevel::CPU_LEVEL) {
     CHECK_EQ(memory_infos.size(), static_cast<size_t>(1));
   }
   std::set<std::vector<int32_t>> chunk_keys;
   std::set<std::vector<int32_t>> table_keys;
   std::set<std::vector<int32_t>> column_keys;
   std::set<std::vector<int32_t>> fragment_keys;
   size_t total_num_buffers{
       0};  // can be greater than chunk keys set size due to table replication
   size_t total_num_bytes{0};
   for (auto& pool_memory_info : memory_infos) {
     const std::vector<MemoryData>& memory_data = pool_memory_info.nodeMemoryData;
     for (auto& memory_datum : memory_data) {
       total_num_buffers++;
       const auto& chunk_key = memory_datum.chunk_key;
       if (memory_datum.memStatus == Buffer_Namespace::MemStatus::FREE ||
           chunk_key.size() < 4) {
         continue;
       }
       if (current_db_only) {
         if (chunk_key[0] != db_metadata_.dbId) {
           continue;
         }
       }
       total_num_bytes += (memory_datum.numPages * pool_memory_info.pageSize);
       table_keys.insert({chunk_key[0], chunk_key[1]});
       column_keys.insert({chunk_key[0], chunk_key[1], chunk_key[2]});
       fragment_keys.insert({chunk_key[0], chunk_key[1], chunk_key[3]});
       chunk_keys.insert(chunk_key);
     }
   }
   return {total_num_buffers,
           total_num_bytes,
           table_keys.size(),
           column_keys.size(),
           fragment_keys.size(),
           chunk_keys.size()};
 }

Here is the call graph for this function:

std::tuple< QueryPlanHash, std::shared_ptr< HashTable >, std::optional< HashtableCacheMetaInfo > > QueryRunner::QueryRunner::getCachedHashtableWithoutCacheKey	(	std::set< size_t > &	visited,
		CacheItemType	hash_table_type,
		DeviceIdentifier	device_identifier
	)

Definition at line 1027 of file QueryRunner.cpp.

References BASELINE_HT, CHECK, OverlapsJoinHashTable::getHashTableCache(), PerfectJoinHashTable::getHashTableCache(), BaselineJoinHashTable::getHashTableCache(), OVERLAPS_HT, PERFECT_HT, and UNREACHABLE.

                                                                                    {
   HashtableRecycler* hash_table_cache{nullptr};
   switch (hash_table_type) {
     case CacheItemType::PERFECT_HT: {
       hash_table_cache = PerfectJoinHashTable::getHashTableCache();
       break;
     }
     case CacheItemType::BASELINE_HT: {
       hash_table_cache = BaselineJoinHashTable::getHashTableCache();
       break;
     }
     case CacheItemType::OVERLAPS_HT: {
       hash_table_cache = OverlapsJoinHashTable::getHashTableCache();
       break;
     }
     default: {
       UNREACHABLE();
       break;
     }
   }
   CHECK(hash_table_cache);
   return hash_table_cache->getCachedHashtableWithoutCacheKey(
       visited, hash_table_type, device_identifier);
 }

Here is the call graph for this function:

std::shared_ptr< CacheItemMetric > QueryRunner::QueryRunner::getCacheItemMetric	(	QueryPlanHash	cache_key,
		CacheItemType	hash_table_type,
		DeviceIdentifier	device_identifier
	)

Definition at line 1054 of file QueryRunner.cpp.

References BASELINE_HT, CHECK, OverlapsJoinHashTable::getHashTableCache(), PerfectJoinHashTable::getHashTableCache(), BaselineJoinHashTable::getHashTableCache(), OVERLAPS_HT, PERFECT_HT, and UNREACHABLE.

                                         {
   HashtableRecycler* hash_table_cache{nullptr};
   switch (hash_table_type) {
     case CacheItemType::PERFECT_HT: {
       hash_table_cache = PerfectJoinHashTable::getHashTableCache();
       break;
     }
     case CacheItemType::BASELINE_HT: {
       hash_table_cache = BaselineJoinHashTable::getHashTableCache();
       break;
     }
     case CacheItemType::OVERLAPS_HT: {
       hash_table_cache = OverlapsJoinHashTable::getHashTableCache();
       break;
     }
     default: {
       UNREACHABLE();
       break;
     }
   }
   CHECK(hash_table_cache);
   return hash_table_cache->getCachedItemMetric(
       hash_table_type, device_identifier, cache_key);
 }

Here is the call graph for this function:

std::shared_ptr< Calcite > QueryRunner::QueryRunner::getCalcite ( ) const

Definition at line 271 of file QueryRunner.cpp.

References anonymous_namespace{QueryRunner.cpp}::g_calcite.

                                                      {
   // TODO: Embed Calcite shared_ptr ownership in QueryRunner
   return g_calcite;
 }

std::shared_ptr< ResultSet > QueryRunner::QueryRunner::getCalcitePlan	(	const std::string &	query_str,
		bool	enable_watchdog,
		bool	as_json_str
	)		const

virtual

Definition at line 853 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), dispatch_queue_, g_enable_calcite_view_optimize, Executor::getExecutor(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), run_benchmark_import::result, session_info_, STDLOG, and logger::thread_local_ids().

                                                                                {
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   CHECK(session_info_);
   const auto& cat = session_info_->getCatalog();
   auto query_state = create_query_state(session_info_, query_str);
   auto stdlog = STDLOG(query_state);
 
   std::shared_ptr<ResultSet> result;
   auto query_launch_task = std::make_shared<QueryDispatchQueue::Task>(
       [&cat,
        &query_str,
        &enable_watchdog,
        &as_json_str,
        &query_state,
        &result,
        parent_thread_local_ids = logger::thread_local_ids()](const size_t worker_id) {
         logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
         auto executor = Executor::getExecutor(worker_id);
         auto calcite_mgr = cat.getCalciteMgr();
         const auto calciteQueryParsingOption =
             calcite_mgr->getCalciteQueryParsingOption(true, as_json_str, false);
         const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
             g_enable_calcite_view_optimize, enable_watchdog, {}, false);
         const auto query_ra = calcite_mgr
                                   ->process(query_state->createQueryStateProxy(),
                                             pg_shim(query_str),
                                             calciteQueryParsingOption,
                                             calciteOptimizationOption)
                                   .plan_result;
         result = std::make_shared<ResultSet>(query_ra);
         return result;
       });
   CHECK(dispatch_queue_);
   dispatch_queue_->submit(query_launch_task, /*is_update_delete=*/false);
   auto result_future = query_launch_task->get_future();
   result_future.get();
   CHECK(result);
   return result;
 }

Here is the call graph for this function:

std::shared_ptr< Catalog_Namespace::Catalog > QueryRunner::QueryRunner::getCatalog ( ) const

Definition at line 266 of file QueryRunner.cpp.

References CHECK, and session_info_.

Referenced by getLoader().

                                                                       {
   CHECK(session_info_);
   return session_info_->get_catalog_ptr();
 }

Here is the caller graph for this function:

std::shared_ptr< Executor > QueryRunner::QueryRunner::getExecutor ( ) const

Definition at line 659 of file QueryRunner.cpp.

References CHECK, create_query_state(), Executor::getExecutor(), Catalog_Namespace::SysCatalog::instance(), session_info_, STDLOG, and Executor::UNITARY_EXECUTOR_ID.

                                                        {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, "");
   auto stdlog = STDLOG(query_state);
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   return executor;
 }

Here is the call graph for this function:

std::unique_ptr< import_export::Loader > QueryRunner::QueryRunner::getLoader ( const TableDescriptor * td ) const

virtual

Definition at line 781 of file QueryRunner.cpp.

References cat(), and getCatalog().

                                      {
   auto cat = getCatalog();
   return std::make_unique<import_export::Loader>(*cat, td);
 }

Here is the call graph for this function:

std::vector< MemoryInfo > QueryRunner::QueryRunner::getMemoryInfo ( const Data_Namespace::MemoryLevel memory_level ) const

Definition at line 291 of file QueryRunner.cpp.

References CHECK, Catalog_Namespace::SysCatalog::instance(), and session_info_.

                                                         {
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   return session_info_->getCatalog().getDataMgr().getMemoryInfo(memory_level);
 }

Here is the call graph for this function:

size_t QueryRunner::QueryRunner::getNumberOfCachedItem	(	CacheItemStatus	item_status,
		CacheItemType	hash_table_type,
		bool	with_overlaps_tuning_param = `false`
	)		const

Definition at line 1082 of file QueryRunner.cpp.

References QueryRunner::ALL, BASELINE_HT, CHECK, CHECK_EQ, QueryRunner::CLEAN_ONLY, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER, QueryRunner::DIRTY_ONLY, OverlapsJoinHashTable::getHashTableCache(), PerfectJoinHashTable::getHashTableCache(), BaselineJoinHashTable::getHashTableCache(), OverlapsJoinHashTable::getOverlapsTuningParamCache(), OVERLAPS_AUTO_TUNER_PARAM, OVERLAPS_HT, PERFECT_HT, and UNREACHABLE.

                                                                                  {
   auto get_num_cached_auto_tuner_param = [&item_status]() {
     auto auto_tuner_cache = OverlapsJoinHashTable::getOverlapsTuningParamCache();
     CHECK(auto_tuner_cache);
     switch (item_status) {
       case CacheItemStatus::ALL: {
         return auto_tuner_cache->getCurrentNumCachedItems(
             CacheItemType::OVERLAPS_AUTO_TUNER_PARAM,
             DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
       }
       case CacheItemStatus::CLEAN_ONLY: {
         return auto_tuner_cache->getCurrentNumCleanCachedItems(
             CacheItemType::OVERLAPS_AUTO_TUNER_PARAM,
             DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
       }
       case CacheItemStatus::DIRTY_ONLY: {
         return auto_tuner_cache->getCurrentNumDirtyCachedItems(
             CacheItemType::OVERLAPS_AUTO_TUNER_PARAM,
             DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
       }
       default: {
         UNREACHABLE();
         return static_cast<size_t>(0);
       }
     }
   };
 
   auto get_num_cached_hashtable =
       [&item_status,
        &hash_table_type,
        &with_overlaps_tuning_param,
        &get_num_cached_auto_tuner_param](HashtableRecycler* hash_table_cache) {
         switch (item_status) {
           case CacheItemStatus::ALL: {
             if (with_overlaps_tuning_param) {
               // we assume additional consideration of turing param cache is only valid
               // for overlaps join hashtable
               CHECK_EQ(hash_table_type, CacheItemType::OVERLAPS_HT);
               return hash_table_cache->getCurrentNumCachedItems(
                          hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER) +
                      get_num_cached_auto_tuner_param();
             }
             return hash_table_cache->getCurrentNumCachedItems(
                 hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
           }
           case CacheItemStatus::CLEAN_ONLY: {
             if (with_overlaps_tuning_param) {
               CHECK_EQ(hash_table_type, CacheItemType::OVERLAPS_HT);
               return hash_table_cache->getCurrentNumCleanCachedItems(
                          hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER) +
                      get_num_cached_auto_tuner_param();
             }
             return hash_table_cache->getCurrentNumCleanCachedItems(
                 hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
           }
           case CacheItemStatus::DIRTY_ONLY: {
             if (with_overlaps_tuning_param) {
               CHECK_EQ(hash_table_type, CacheItemType::OVERLAPS_HT);
               return hash_table_cache->getCurrentNumDirtyCachedItems(
                          hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER) +
                      get_num_cached_auto_tuner_param();
             }
             return hash_table_cache->getCurrentNumDirtyCachedItems(
                 hash_table_type, DataRecyclerUtil::CPU_DEVICE_IDENTIFIER);
           }
           default: {
             UNREACHABLE();
             return static_cast<size_t>(0);
           }
         }
       };
 
   switch (hash_table_type) {
     case CacheItemType::PERFECT_HT: {
       auto hash_table_cache = PerfectJoinHashTable::getHashTableCache();
       CHECK(hash_table_cache);
       return get_num_cached_hashtable(hash_table_cache);
     }
     case CacheItemType::BASELINE_HT: {
       auto hash_table_cache = BaselineJoinHashTable::getHashTableCache();
       CHECK(hash_table_cache);
       return get_num_cached_hashtable(hash_table_cache);
     }
     case CacheItemType::OVERLAPS_HT: {
       auto hash_table_cache = OverlapsJoinHashTable::getHashTableCache();
       CHECK(hash_table_cache);
       return get_num_cached_hashtable(hash_table_cache);
     }
     case CacheItemType::OVERLAPS_AUTO_TUNER_PARAM: {
       return get_num_cached_auto_tuner_param();
     }
     default: {
       UNREACHABLE();
       return 0;
     }
   }
   return 0;
 }

Here is the call graph for this function:

std::optional< RegisteredQueryHint > QueryRunner::QueryRunner::getParsedGlobalQueryHints ( const std::string & query_str )

Definition at line 413 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getGlobalQueryHint(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

                                 {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
   return ra_executor.getGlobalQueryHint();
 }

Here is the call graph for this function:

RegisteredQueryHint QueryRunner::QueryRunner::getParsedQueryHint ( const std::string & query_str )

Definition at line 343 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), RegisteredQueryHint::defaults(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getParsedQueryHint(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

                                                                               {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
 
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
   auto query_hints =
       ra_executor.getParsedQueryHint(ra_executor.getRootRelAlgNodeShPtr().get());
   return query_hints ? *query_hints : RegisteredQueryHint::defaults();
 }

Here is the call graph for this function:

std::optional< std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > > QueryRunner::QueryRunner::getParsedQueryHints ( const std::string & query_str )

Definition at line 392 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getParsedQueryHints(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

                                                            {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
   return ra_executor.getParsedQueryHints();
 }

Here is the call graph for this function:

QueryPlanDagInfo QueryRunner::QueryRunner::getQueryInfoForDataRecyclerTest ( const std::string & query_str )

Definition at line 505 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getRootRelAlgNodeShPtr(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

Referenced by extractQueryPlanDag().

                                 {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra);
   // note that we assume the test for data recycler that needs to have join_info
   // does not contain any ORDER BY clause; this is necessary to create work_unit
   // without actually performing the query
   auto root_node_shared_ptr = ra_executor.getRootRelAlgNodeShPtr();
   auto join_info = ra_executor.getJoinInfo(root_node_shared_ptr.get());
   auto relAlgTranslator = ra_executor.getRelAlgTranslator(root_node_shared_ptr.get());
   return {root_node_shared_ptr, join_info.first, join_info.second, relAlgTranslator};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

RaExecutionSequence QueryRunner::QueryRunner::getRaExecutionSequence ( const std::string & query_str )

Definition at line 435 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getRaExecutionSequence(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

                                                                                   {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
   return ra_executor.getRaExecutionSequence(ra_executor.getRootRelAlgNodeShPtr().get(),
                                             executor.get());
 }

Here is the call graph for this function:

std::unique_ptr< RelAlgDag > QueryRunner::QueryRunner::getRelAlgDag ( const std::string & query_str )

Definition at line 975 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), ExecutionOptions::defaults(), dispatch_queue_, g_enable_calcite_view_optimize, g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getOwnedRelAlgDag(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, STDLOG, and logger::thread_local_ids().

                                                                              {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto stdlog = STDLOG(query_state);
   auto& cat = session_info_->getCatalog();
 
   std::unique_ptr<RelAlgDag> rel_alg_dag;
   auto query_launch_task = std::make_shared<QueryDispatchQueue::Task>(
       [&cat,
        &query_str,
        &query_state,
        &rel_alg_dag,
        parent_thread_local_ids = logger::thread_local_ids()](const size_t worker_id) {
         logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
         auto executor = Executor::getExecutor(worker_id);
         auto eo = ExecutionOptions::defaults();
         auto calcite_mgr = cat.getCalciteMgr();
         const auto calciteQueryParsingOption =
             calcite_mgr->getCalciteQueryParsingOption(true, false, true);
         const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
             g_enable_calcite_view_optimize, g_enable_watchdog, {}, false);
         const auto query_ra = calcite_mgr
                                   ->process(query_state->createQueryStateProxy(),
                                             pg_shim(query_str),
                                             calciteQueryParsingOption,
                                             calciteOptimizationOption)
                                   .plan_result;
         auto ra_executor = RelAlgExecutor(executor.get(), query_ra);
         rel_alg_dag = ra_executor.getOwnedRelAlgDag();
       });
   CHECK(dispatch_queue_);
   dispatch_queue_->submit(query_launch_task, /*is_update_delete=*/false);
   auto result_future = query_launch_task->get_future();
   result_future.get();
   CHECK(rel_alg_dag);
   return rel_alg_dag;
 }

Here is the call graph for this function:

std::shared_ptr< RelAlgTranslator > QueryRunner::QueryRunner::getRelAlgTranslator	(	const std::string &	query_str,
		Executor *	executor
	)

Definition at line 482 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Catalog_Namespace::SysCatalog::instance(), pg_shim(), and session_info_.

                         {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor, query_ra);
   auto root_node_shared_ptr = ra_executor.getRootRelAlgNodeShPtr();
   return ra_executor.getRelAlgTranslator(root_node_shared_ptr.get());
 }

Here is the call graph for this function:

std::shared_ptr< const RelAlgNode > QueryRunner::QueryRunner::getRootNodeFromParsedQuery ( const std::string & query_str )

Definition at line 367 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, Executor::getExecutor(), RelAlgExecutor::getRootRelAlgNodeShPtr(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and Executor::UNITARY_EXECUTOR_ID.

                                 {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto& cat = session_info_->getCatalog();
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
 
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   const auto query_ra = calcite_mgr
                             ->process(query_state->createQueryStateProxy(),
                                       pg_shim(query_str),
                                       calciteQueryParsingOption,
                                       calciteOptimizationOption)
                             .plan_result;
   auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
   return ra_executor.getRootRelAlgNodeShPtr();
 }

Here is the call graph for this function:

std::shared_ptr<Catalog_Namespace::SessionInfo> QueryRunner::QueryRunner::getSession ( ) const

inline

Definition at line 190 of file QueryRunner.h.

References session_info_.

                                                                  {
     return session_info_;
   }

Catalog_Namespace::UserMetadata& QueryRunner::QueryRunner::getUserMetadata ( ) const

bool QueryRunner::QueryRunner::gpusPresent ( ) const

Definition at line 276 of file QueryRunner.cpp.

References CHECK, and session_info_.

                                     {
   CHECK(session_info_);
   return session_info_->getCatalog().getDataMgr().gpusPresent();
 }

QueryRunner * QueryRunner::QueryRunner::init	(	const char *	db_path,
		const std::string &	udf_filename = `""`,
		const size_t	max_gpu_mem = `0`,
		const int	reserved_gpu_mem = `256 << 20`
	)

static

Definition at line 84 of file QueryRunner.cpp.

References logger::init(), shared::kDefaultDbName, and shared::kRootUsername.

                                                            {
   return QueryRunner::init(db_path,
                            shared::kRootUsername,
                            "HyperInteractive",
                            shared::kDefaultDbName,
                            {},
                            {},
                            udf_filename,
                            true,
                            max_gpu_mem,
                            reserved_gpu_mem);
 }

Here is the call graph for this function:

QueryRunner * QueryRunner::QueryRunner::init	(	const File_Namespace::DiskCacheConfig *	disk_cache_config,
		const char *	db_path,
		const std::vector< LeafHostInfo > &	string_servers = `{}`,
		const std::vector< LeafHostInfo > &	leaf_servers = `{}`
	)

static

Definition at line 100 of file QueryRunner.cpp.

References logger::init(), shared::kDefaultDbName, and shared::kRootUsername.

                                                                             {
   return QueryRunner::init(db_path,
                            shared::kRootUsername,
                            "HyperInteractive",
                            shared::kDefaultDbName,
                            string_servers,
                            leaf_servers,
                            "",
                            true,
                            0,
                            256 << 20,
                            false,
                            false,
                            disk_cache_config);
 }

Here is the call graph for this function:

static QueryRunner* QueryRunner::QueryRunner::init	(	const char *	db_path,
		const std::vector< LeafHostInfo > &	string_servers,
		const std::vector< LeafHostInfo > &	leaf_servers
	)

inlinestatic

Definition at line 151 of file QueryRunner.h.

References logger::init(), shared::kDefaultDbName, and shared::kRootUsername.

                                                                         {
     return QueryRunner::init(db_path,
                              shared::kRootUsername,
                              "HyperInteractive",
                              shared::kDefaultDbName,
                              string_servers,
                              leaf_servers);
   }

Here is the call graph for this function:

QueryRunner * QueryRunner::QueryRunner::init	(	const char *	db_path,
		const std::string &	user,
		const std::string &	pass,
		const std::string &	db_name,
		const std::vector< LeafHostInfo > &	string_servers,
		const std::vector< LeafHostInfo > &	leaf_servers,
		const std::string &	udf_filename = `""`,
		bool	uses_gpus = `true`,
		const size_t	max_gpu_mem = `0`,
		const int	reserved_gpu_mem = `256 << 20`,
		const bool	create_user = `false`,
		const bool	create_db = `false`,
		const File_Namespace::DiskCacheConfig *	config = `nullptr`
	)

static

Definition at line 119 of file QueryRunner.cpp.

References CHECK, ddl_utils::FilePathWhitelist::clear(), logger::FATAL, ddl_utils::FilePathWhitelist::initialize(), and LOG_IF.

                                                                                        {
   // Whitelist root path for tests by default
   ddl_utils::FilePathWhitelist::clear();
   ddl_utils::FilePathWhitelist::initialize(db_path, "[\"/\"]", "[\"/\"]");
   LOG_IF(FATAL, !leaf_servers.empty()) << "Distributed test runner not supported.";
   CHECK(leaf_servers.empty());
   qr_instance_.reset(new QueryRunner(db_path,
                                      user,
                                      pass,
                                      db_name,
                                      string_servers,
                                      leaf_servers,
                                      udf_filename,
                                      uses_gpus,
                                      max_gpu_mem,
                                      reserved_gpu_mem,
                                      create_user,
                                      create_db,
                                      disk_cache_config));
   return qr_instance_.get();
 }

Here is the call graph for this function:

static QueryRunner* QueryRunner::QueryRunner::init ( std::unique_ptr< Catalog_Namespace::SessionInfo > & session )

inlinestatic

Definition at line 176 of file QueryRunner.h.

References qr_instance_, and QueryRunner().

                                                                                  {
     qr_instance_.reset(new QueryRunner(std::move(session)));
     return qr_instance_.get();
   }

Here is the call graph for this function:

void QueryRunner::QueryRunner::reset ( )

static

Definition at line 1183 of file QueryRunner.cpp.

References anonymous_namespace{QueryRunner.cpp}::calcite_shutdown_handler(), and qr_instance_.

                         {
   qr_instance_->query_engine_.reset();
   qr_instance_.reset(nullptr);
   calcite_shutdown_handler();
 }

Here is the call graph for this function:

void QueryRunner::QueryRunner::resizeDispatchQueue ( const size_t num_executors )

Definition at line 258 of file QueryRunner.cpp.

References dispatch_queue_.

                                                                 {
   dispatch_queue_ = std::make_unique<QueryDispatchQueue>(num_executors);
 }

void QueryRunner::QueryRunner::runDDLStatement ( const std::string & stmt_str_in )

virtual

Definition at line 570 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), DdlCommandExecutor::execute(), g_enable_watchdog, ParserWrapper::Insert, Catalog_Namespace::SysCatalog::instance(), pg_shim(), session_info_, and STDLOG.

Referenced by QueryRunner::ImportDriver::importGeoTable(), runMultipleStatements(), and runSQL().

                                                               {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
 
   std::string stmt_str = stmt_str_in;
   // First remove special chars
   boost::algorithm::trim_left_if(stmt_str, boost::algorithm::is_any_of("\n"));
   // Then remove spaces
   boost::algorithm::trim_left(stmt_str);
 
   ParserWrapper pw{stmt_str};
 
   auto query_state = create_query_state(session_info_, stmt_str);
   auto stdlog = STDLOG(query_state);
 
   if (pw.is_ddl || pw.getDMLType() == ParserWrapper::DMLType::Insert) {
     auto& cat = session_info_->getCatalog();
     auto calcite_mgr = cat.getCalciteMgr();
     const auto calciteQueryParsingOption =
         calcite_mgr->getCalciteQueryParsingOption(true, false, true);
     const auto calciteOptimizationOption =
         calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
     const auto query_ra = calcite_mgr
                               ->process(query_state->createQueryStateProxy(),
                                         pg_shim(stmt_str),
                                         calciteQueryParsingOption,
                                         calciteOptimizationOption)
                               .plan_result;
     if (pw.getDMLType() == ParserWrapper::DMLType::Insert) {
       rapidjson::Document ddl_query;
       ddl_query.Parse(query_ra);
       CHECK(ddl_query.HasMember("payload"));
       CHECK(ddl_query["payload"].IsObject());
       auto stmt = Parser::InsertValuesStmt(ddl_query["payload"].GetObject());
       stmt.execute(*session_info_, false /* read only */);
       return;
     }
     DdlCommandExecutor executor = DdlCommandExecutor(query_ra, session_info_);
     executor.execute(false /* read only */);
     return;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void QueryRunner::QueryRunner::runImport ( Parser::CopyTableStmt * import_stmt )

virtual

Definition at line 776 of file QueryRunner.cpp.

References CHECK, Parser::CopyTableStmt::execute(), and session_info_.

                                                             {
   CHECK(import_stmt);
   import_stmt->execute(*session_info_, false /* read only */);
 }

Here is the call graph for this function:

std::vector< std::shared_ptr< ResultSet > > QueryRunner::QueryRunner::runMultipleStatements	(	const std::string &	sql,
		const ExecutorDeviceType	dt
	)

virtual

Definition at line 752 of file QueryRunner.cpp.

References field(), ParserWrapper::Insert, runDDLStatement(), runSQL(), split(), and strip().

                                  {
   std::vector<std::shared_ptr<ResultSet>> results;
   // TODO: Need to properly handle escaped semicolons instead of doing a naive split().
   auto fields = split(sql, ";");
   for (const auto& field : fields) {
     auto text = strip(field) + ";";
     if (text == ";") {
       continue;
     }
 
     ParserWrapper pw{text};
     if (pw.is_ddl || pw.getDMLType() == ParserWrapper::DMLType::Insert) {
       runDDLStatement(text);
       results.push_back(nullptr);
     } else {
       // is not DDL, then assume it's DML and try to execute
       results.push_back(runSQL(text, dt, true, true));
     }
   }
   return results;
 }

Here is the call graph for this function:

std::shared_ptr< ExecutionResult > QueryRunner::QueryRunner::runSelectQuery	(	const std::string &	query_str,
		CompilationOptions	co,
		ExecutionOptions	eo
	)

virtual

Definition at line 895 of file QueryRunner.cpp.

References ExecutionOptions::allow_loop_joins, cat(), CHECK, create_query_state(), CompilationOptions::defaults(), CompilationOptions::device_type, dispatch_queue_, explain_type_, g_enable_calcite_view_optimize, g_enable_filter_push_down, g_enable_watchdog, Executor::getExecutor(), CompilationOptions::hoist_literals, Catalog_Namespace::SysCatalog::instance(), ExecutionOptions::just_explain, pg_shim(), run_benchmark_import::result, QueryRunner::anonymous_namespace{QueryRunner.cpp}::run_select_query_with_filter_push_down(), session_info_, STDLOG, and logger::thread_local_ids().

Referenced by runSelectQuery(), and runSQL().

                                                                                   {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto query_state = create_query_state(session_info_, query_str);
   auto stdlog = STDLOG(query_state);
   if (g_enable_filter_push_down) {
     return run_select_query_with_filter_push_down(query_state->createQueryStateProxy(),
                                                   co.device_type,
                                                   co.hoist_literals,
                                                   eo.allow_loop_joins,
                                                   eo.just_explain,
                                                   explain_type_,
                                                   g_enable_filter_push_down);
   }
 
   auto& cat = session_info_->getCatalog();
 
   std::shared_ptr<ExecutionResult> result;
   auto query_launch_task = std::make_shared<QueryDispatchQueue::Task>(
       [&cat,
        &query_str,
        &co,
        explain_type = this->explain_type_,
        &eo,
        &query_state,
        &result,
        parent_thread_local_ids = logger::thread_local_ids()](const size_t worker_id) {
         logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
         auto executor = Executor::getExecutor(worker_id);
         // TODO The next line should be deleted since it overwrites co, but then
         // NycTaxiTest.RunSelectsEncodingDictWhereGreater fails due to co not getting
         // reset to its default values.
         co = CompilationOptions::defaults(co.device_type);
         co.explain_type = explain_type;
         auto calcite_mgr = cat.getCalciteMgr();
         const auto calciteQueryParsingOption =
             calcite_mgr->getCalciteQueryParsingOption(true, false, true);
         const auto calciteOptimizationOption = calcite_mgr->getCalciteOptimizationOption(
             g_enable_calcite_view_optimize, g_enable_watchdog, {}, false);
         const auto query_ra = calcite_mgr
                                   ->process(query_state->createQueryStateProxy(),
                                             pg_shim(query_str),
                                             calciteQueryParsingOption,
                                             calciteOptimizationOption)
                                   .plan_result;
         auto ra_executor = RelAlgExecutor(executor.get(), query_ra);
         result = std::make_shared<ExecutionResult>(
             ra_executor.executeRelAlgQuery(co, eo, false, nullptr));
       });
   CHECK(dispatch_queue_);
   dispatch_queue_->submit(query_launch_task, /*is_update_delete=*/false);
   auto result_future = query_launch_task->get_future();
   result_future.get();
   CHECK(result);
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< ExecutionResult > QueryRunner::QueryRunner::runSelectQuery	(	const std::string &	query_str,
		const ExecutorDeviceType	device_type,
		const bool	hoist_literals,
		const bool	allow_loop_joins,
		const bool	just_explain = `false`
	)

virtual

Definition at line 954 of file QueryRunner.cpp.

References defaultExecutionOptionsForRunSQL(), CompilationOptions::defaults(), and runSelectQuery().

                              {
   auto co = CompilationOptions::defaults(device_type);
   co.hoist_literals = hoist_literals;
   return runSelectQuery(query_str,
                         std::move(co),
                         defaultExecutionOptionsForRunSQL(allow_loop_joins, just_explain));
 }

Here is the call graph for this function:

std::shared_ptr< ResultSet > QueryRunner::QueryRunner::runSQL	(	const std::string &	query_str,
		CompilationOptions	co,
		ExecutionOptions	eo
	)

virtual

Definition at line 613 of file QueryRunner.cpp.

References CHECK, ParserWrapper::Insert, Catalog_Namespace::SysCatalog::instance(), runDDLStatement(), runSelectQuery(), session_info_, and VLOG.

Referenced by runMultipleStatements(), and runSQL().

                                                                     {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
 
   ParserWrapper pw{query_str};
   if (pw.getDMLType() == ParserWrapper::DMLType::Insert) {
     runDDLStatement(query_str);
     return nullptr;
   }
   const auto execution_result = runSelectQuery(query_str, std::move(co), std::move(eo));
   VLOG(1) << session_info_->getCatalog().getDataMgr().getSystemMemoryUsage();
   return execution_result->getRows();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< ResultSet > QueryRunner::QueryRunner::runSQL	(	const std::string &	query_str,
		const ExecutorDeviceType	device_type,
		const bool	hoist_literals = `true`,
		const bool	allow_loop_joins = `true`
	)

virtual

Definition at line 629 of file QueryRunner.cpp.

References defaultExecutionOptionsForRunSQL(), CompilationOptions::defaults(), and runSQL().

                                                                             {
   auto co = CompilationOptions::defaults(device_type);
   co.hoist_literals = hoist_literals;
   return runSQL(
       query_str, std::move(co), defaultExecutionOptionsForRunSQL(allow_loop_joins));
 }

Here is the call graph for this function:

std::shared_ptr< ResultSet > QueryRunner::QueryRunner::runSQLWithAllowingInterrupt	(	const std::string &	query_str,
		const std::string &	session_id,
		const ExecutorDeviceType	device_type,
		const double	running_query_check_freq = `0.9`,
		const unsigned	pending_query_check_freq = `1000`
	)

virtual

Definition at line 668 of file QueryRunner.cpp.

References calcite_lock, cat(), CHECK, create_query_state(), CompilationOptions::defaults(), dispatch_queue_, g_enable_columnar_output, g_enable_watchdog, g_gpu_mem_limit_percent, Executor::getExecutor(), Catalog_Namespace::SysCatalog::instance(), pg_shim(), run_benchmark_import::result, session_info_, STDLOG, logger::thread_local_ids(), and Executor::UNITARY_EXECUTOR_ID.

                                              {
   CHECK(session_info_);
   CHECK(!Catalog_Namespace::SysCatalog::instance().isAggregator());
   auto current_user = session_info_->get_currentUser();
   auto session_info = std::make_shared<Catalog_Namespace::SessionInfo>(
       session_info_->get_catalog_ptr(), current_user, device_type, session_id);
   auto query_state = create_query_state(session_info, query_str);
   auto stdlog = STDLOG(query_state);
   auto& cat = query_state->getConstSessionInfo()->getCatalog();
   std::string query_ra{""};
 
   std::shared_ptr<ExecutionResult> result;
   auto query_launch_task = std::make_shared<QueryDispatchQueue::Task>(
       [&cat,
        &query_ra,
        &device_type,
        &query_state,
        &result,
        &running_query_check_freq,
        &pending_query_check_freq,
        parent_thread_local_ids = logger::thread_local_ids()](const size_t worker_id) {
         logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
         auto executor = Executor::getExecutor(worker_id);
         CompilationOptions co = CompilationOptions::defaults(device_type);
 
         ExecutionOptions eo = {g_enable_columnar_output,
                                false,
                                true,
                                false,
                                true,
                                false,
                                false,
                                false,
                                false,
                                10000,
                                false,
                                false,
                                g_gpu_mem_limit_percent,
                                true,
                                running_query_check_freq,
                                pending_query_check_freq,
                                false};
         {
           // async query initiation for interrupt test
           // incurs data race warning in TSAN since
           // calcite_mgr is shared across multiple query threads
           // so here we lock the manager during query parsing
           std::lock_guard<std::mutex> calcite_lock_guard(calcite_lock);
           auto calcite_mgr = cat.getCalciteMgr();
           const auto calciteQueryParsingOption =
               calcite_mgr->getCalciteQueryParsingOption(true, false, true);
           const auto calciteOptimizationOption =
               calcite_mgr->getCalciteOptimizationOption(
                   false, g_enable_watchdog, {}, false);
           query_ra = calcite_mgr
                          ->process(query_state->createQueryStateProxy(),
                                    pg_shim(query_state->getQueryStr()),
                                    calciteQueryParsingOption,
                                    calciteOptimizationOption)
                          .plan_result;
         }
         auto ra_executor = RelAlgExecutor(executor.get(), query_ra, query_state);
         result = std::make_shared<ExecutionResult>(
             ra_executor.executeRelAlgQuery(co, eo, false, nullptr));
       });
   auto executor = Executor::getExecutor(Executor::UNITARY_EXECUTOR_ID);
   executor->enrollQuerySession(session_id,
                                query_str,
                                query_state->getQuerySubmittedTime(),
                                Executor::UNITARY_EXECUTOR_ID,
                                QuerySessionStatus::QueryStatus::PENDING_QUEUE);
   CHECK(dispatch_queue_);
   dispatch_queue_->submit(query_launch_task, /*is_update_delete=*/false);
   auto result_future = query_launch_task->get_future();
   result_future.get();
   CHECK(result);
   return result->getRows();
 }

Here is the call graph for this function:

void QueryRunner::QueryRunner::setExplainType ( const ExecutorExplainType explain_type )

inline

Definition at line 307 of file QueryRunner.h.

References explain_type_.

                                                               {
     explain_type_ = explain_type;
   }

void QueryRunner::QueryRunner::validateDDLStatement ( const std::string & stmt_str_in )

virtual

Definition at line 458 of file QueryRunner.cpp.

References cat(), CHECK, create_query_state(), g_enable_watchdog, pg_shim(), session_info_, and STDLOG.

                                                                    {
   CHECK(session_info_);
 
   std::string stmt_str = stmt_str_in;
   // First remove special chars
   boost::algorithm::trim_left_if(stmt_str, boost::algorithm::is_any_of("\n"));
   // Then remove spaces
   boost::algorithm::trim_left(stmt_str);
 
   auto query_state = create_query_state(session_info_, stmt_str);
   auto stdlog = STDLOG(query_state);
 
   auto& cat = session_info_->getCatalog();
   auto calcite_mgr = cat.getCalciteMgr();
   const auto calciteQueryParsingOption =
       calcite_mgr->getCalciteQueryParsingOption(true, false, true);
   const auto calciteOptimizationOption =
       calcite_mgr->getCalciteOptimizationOption(false, g_enable_watchdog, {}, false);
   calcite_mgr->process(query_state->createQueryStateProxy(),
                        pg_shim(stmt_str),
                        calciteQueryParsingOption,
                        calciteOptimizationOption);
 }

Here is the call graph for this function:

Member Data Documentation

Catalog_Namespace::DBMetadata QueryRunner::QueryRunner::db_metadata_

protected

Definition at line 329 of file QueryRunner.h.

Referenced by getBufferPoolStats(), and QueryRunner().

std::unique_ptr<QueryDispatchQueue> QueryRunner::QueryRunner::dispatch_queue_

protected

Definition at line 331 of file QueryRunner.h.

Referenced by getCalcitePlan(), getRelAlgDag(), resizeDispatchQueue(), runSelectQuery(), and runSQLWithAllowingInterrupt().

ExecutorExplainType QueryRunner::QueryRunner::explain_type_ = ExecutorExplainType::Default

protected

Definition at line 327 of file QueryRunner.h.

Referenced by runSelectQuery(), and setExplainType().

std::unique_ptr< QueryRunner > QueryRunner::QueryRunner::qr_instance_ = nullptr

staticprotected

Definition at line 325 of file QueryRunner.h.

Referenced by get(), init(), and reset().

std::shared_ptr<QueryEngine> QueryRunner::QueryRunner::query_engine_

protected

Definition at line 332 of file QueryRunner.h.

Referenced by QueryRunner().

query_state::QueryStates QueryRunner::QueryRunner::query_states_

static

Definition at line 300 of file QueryRunner.h.

Referenced by create_query_state().

std::shared_ptr<Catalog_Namespace::SessionInfo> QueryRunner::QueryRunner::session_info_

protected

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryRunner/QueryRunner.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryRunner/QueryRunner.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation