Class DBHandler¶

class DBHandler : public OmniSciIf¶

Public Functions

DBHandler(const std::vector<LeafHostInfo> &db_leaves, const std::vector<LeafHostInfo> &string_leaves, const std::string &base_data_path, const bool allow_multifrag, const bool jit_debug, const bool intel_jit_profile, const bool read_only, const bool allow_loop_joins, const bool enable_rendering, const bool renderer_use_ppll_polys, const bool renderer_prefer_igpu, const unsigned renderer_vulkan_timeout_ms, const bool enable_auto_clear_render_mem, const int render_oom_retry_threshold, const size_t render_mem_bytes, const size_t max_concurrent_render_sessions, const size_t reserved_gpu_mem, const bool render_compositor_use_last_gpu, const size_t num_reader_threads, const AuthMetadata &authMetadata, SystemParameters &system_parameters, const bool legacy_syntax, const int idle_session_duration, const int max_session_duration, const bool enable_runtime_udf_registration, const std::string &udf_filename, const std::string &clang_path, const std::vector<std::string> &clang_options, const File_Namespace::DiskCacheConfig &disk_cache_config, const bool is_new_db)¶

void initialize(const bool is_new_db)¶

~DBHandler()¶

void krb5_connect(TKrb5Session &session, const std::string &token, const std::string &dbname)¶

void connect(TSessionId &session, const std::string &username, const std::string &passwd, const std::string &dbname)¶

void disconnect(const TSessionId &session)¶

void switch_database(const TSessionId &session, const std::string &dbname)¶

void clone_session(TSessionId &session2, const TSessionId &session1)¶

void get_server_status(TServerStatus &_return, const TSessionId &session)¶

void get_status(std::vector<TServerStatus> &_return, const TSessionId &session)¶

void get_hardware_info(TClusterHardwareInfo &_return, const TSessionId &session)¶

bool hasTableAccessPrivileges(const TableDescriptor *td, const Catalog_Namespace::SessionInfo &session_info)¶

void get_tables(std::vector<std::string> &_return, const TSessionId &session)¶

void get_tables_for_database(std::vector<std::string> &_return, const TSessionId &session, const std::string &database_name)¶

void get_physical_tables(std::vector<std::string> &_return, const TSessionId &session)¶

void get_views(std::vector<std::string> &_return, const TSessionId &session)¶

void get_tables_meta(std::vector<TTableMeta> &_return, const TSessionId &session)¶

void get_table_details(TTableDetails &_return, const TSessionId &session, const std::string &table_name)¶

void get_table_details_for_database(TTableDetails &_return, const TSessionId &session, const std::string &table_name, const std::string &database_name)¶

void get_internal_table_details(TTableDetails &_return, const TSessionId &session, const std::string &table_name, const bool include_system_columns)¶

void get_internal_table_details_for_database(TTableDetails &_return, const TSessionId &session, const std::string &table_name, const std::string &database_name)¶

void get_users(std::vector<std::string> &_return, const TSessionId &session)¶

void get_databases(std::vector<TDBInfo> &_return, const TSessionId &session)¶

void get_version(std::string &_return)¶

void start_heap_profile(const TSessionId &session)¶

void stop_heap_profile(const TSessionId &session)¶

void get_heap_profile(std::string &_return, const TSessionId &session)¶

void get_memory(std::vector<TNodeMemoryInfo> &_return, const TSessionId &session, const std::string &memory_level)¶

void clear_cpu_memory(const TSessionId &session)¶

void clear_gpu_memory(const TSessionId &session)¶

void clearRenderMemory(const TSessionId &session)¶

void set_cur_session(const TSessionId &parent_session, const TSessionId &leaf_session, const std::string &start_time_str, const std::string &label, bool for_running_query_kernel)¶

void invalidate_cur_session(const TSessionId &parent_session, const TSessionId &leaf_session, const std::string &start_time_str, const std::string &label, bool for_running_query_kernel)¶

void set_table_epoch(const TSessionId &session, const int db_id, const int table_id, const int new_epoch)¶

void set_table_epoch_by_name(const TSessionId &session, const std::string &table_name, const int new_epoch)¶

int32_t get_table_epoch(const TSessionId &session, const int32_t db_id, const int32_t table_id)¶

int32_t get_table_epoch_by_name(const TSessionId &session, const std::string &table_name)¶

void get_table_epochs(std::vector<TTableEpochInfo> &_return, const TSessionId &session, const int32_t db_id, const int32_t table_id)¶

void set_table_epochs(const TSessionId &session, const int32_t db_id, const std::vector<TTableEpochInfo> &table_epochs)¶

void get_session_info(TSessionInfo &_return, const TSessionId &session)¶

void set_leaf_info(const TSessionId &session, const TLeafInfo &info)¶

void sql_execute(ExecutionResult &_return, const TSessionId &session, const std::string &query, const bool column_format, const int32_t first_n, const int32_t at_most_n)¶

void sql_execute(TQueryResult &_return, const TSessionId &session, const std::string &query, const bool column_format, const std::string &nonce, const int32_t first_n, const int32_t at_most_n)¶

void get_completion_hints(std::vector<TCompletionHint> &hints, const TSessionId &session, const std::string &sql, const int cursor)¶

void sql_execute_df(TDataFrame &_return, const TSessionId &session, const std::string &query, const TDeviceType::type device_type, const int32_t device_id, const int32_t first_n, const TArrowTransport::type transport_method)¶

void sql_execute_gdf(TDataFrame &_return, const TSessionId &session, const std::string &query, const int32_t device_id, const int32_t first_n)¶

void deallocate_df(const TSessionId &session, const TDataFrame &df, const TDeviceType::type device_type, const int32_t device_id)¶

void interrupt(const TSessionId &query_session, const TSessionId &interrupt_session)¶

void sql_validate(TRowDescriptor &_return, const TSessionId &session, const std::string &query)¶

void set_execution_mode(const TSessionId &session, const TExecuteMode::type mode)¶

void render_vega(TRenderResult &_return, const TSessionId &session, const int64_t widget_id, const std::string &vega_json, const int32_t compression_level, const std::string &nonce)¶

void get_result_row_for_pixel(TPixelTableRowResult &_return, const TSessionId &session, const int64_t widget_id, const TPixel &pixel, const std::map<std::string, std::vector<std::string>> &table_col_names, const bool column_format, const int32_t pixel_radius, const std::string &nonce)¶

int32_t create_custom_expression(const TSessionId &session, const TCustomExpression &custom_expression)¶

void get_custom_expressions(std::vector<TCustomExpression> &_return, const TSessionId &session)¶

void update_custom_expression(const TSessionId &session, const int32_t id, const std::string &expression_json)¶

void delete_custom_expressions(const TSessionId &session, const std::vector<int32_t> &custom_expression_ids, const bool do_soft_delete)¶

void get_dashboard(TDashboard &_return, const TSessionId &session, const int32_t dashboard_id)¶

void get_dashboards(std::vector<TDashboard> &_return, const TSessionId &session)¶

int32_t create_dashboard(const TSessionId &session, const std::string &dashboard_name, const std::string &dashboard_state, const std::string &image_hash, const std::string &dashboard_metadata)¶

void replace_dashboard(const TSessionId &session, const int32_t dashboard_id, const std::string &dashboard_name, const std::string &dashboard_owner, const std::string &dashboard_state, const std::string &image_hash, const std::string &dashboard_metadata)¶

void delete_dashboard(const TSessionId &session, const int32_t dashboard_id)¶

void share_dashboards(const TSessionId &session, const std::vector<int32_t> &dashboard_ids, const std::vector<std::string> &groups, const TDashboardPermissions &permissions)¶

void delete_dashboards(const TSessionId &session, const std::vector<int32_t> &dashboard_ids)¶

void share_dashboard(const TSessionId &session, const int32_t dashboard_id, const std::vector<std::string> &groups, const std::vector<std::string> &objects, const TDashboardPermissions &permissions, const bool grant_role)¶

void unshare_dashboards(const TSessionId &session, const std::vector<int32_t> &dashboard_ids, const std::vector<std::string> &groups, const TDashboardPermissions &permissions)¶

void unshare_dashboard(const TSessionId &session, const int32_t dashboard_id, const std::vector<std::string> &groups, const std::vector<std::string> &objects, const TDashboardPermissions &permissions)¶

void get_dashboard_grantees(std::vector<TDashboardGrantees> &_return, const TSessionId &session, const int32_t dashboard_id)¶

void get_link_view(TFrontendView &_return, const TSessionId &session, const std::string &link)¶

void create_link(std::string &_return, const TSessionId &session, const std::string &view_state, const std::string &view_metadata)¶

void load_table_binary(const TSessionId &session, const std::string &table_name, const std::vector<TRow> &rows, const std::vector<std::string> &column_names)¶

void load_table_binary_columnar(const TSessionId &session, const std::string &table_name, const std::vector<TColumn> &cols, const std::vector<std::string> &column_names)¶

void load_table_binary_columnar_polys(const TSessionId &session, const std::string &table_name, const std::vector<TColumn> &cols, const std::vector<std::string> &column_names, const bool assign_render_groups)¶

void load_table_binary_arrow(const TSessionId &session, const std::string &table_name, const std::string &arrow_stream, const bool use_column_names)¶

void load_table(const TSessionId &session, const std::string &table_name, const std::vector<TStringRow> &rows, const std::vector<std::string> &column_names)¶

void detect_column_types(TDetectResult &_return, const TSessionId &session, const std::string &file_name, const TCopyParams &copy_params)¶

void create_table(const TSessionId &session, const std::string &table_name, const TRowDescriptor &row_desc, const TFileType::type file_type, const TCreateParams &create_params)¶

void import_table(const TSessionId &session, const std::string &table_name, const std::string &file_name, const TCopyParams &copy_params)¶

void import_geo_table(const TSessionId &session, const std::string &table_name, const std::string &file_name, const TCopyParams &copy_params, const TRowDescriptor &row_desc, const TCreateParams &create_params)¶

void import_table_status(TImportStatus &_return, const TSessionId &session, const std::string &import_id)¶

void get_first_geo_file_in_archive(std::string &_return, const TSessionId &session, const std::string &archive_path, const TCopyParams &copy_params)¶

void get_all_files_in_archive(std::vector<std::string> &_return, const TSessionId &session, const std::string &archive_path, const TCopyParams &copy_params)¶

void get_layers_in_geo_file(std::vector<TGeoFileLayerInfo> &_return, const TSessionId &session, const std::string &file_name, const TCopyParams &copy_params)¶

int64_t query_get_outer_fragment_count(const TSessionId &session, const std::string &select_query)¶

void check_table_consistency(TTableMeta &_return, const TSessionId &session, const int32_t table_id)¶

void start_query(TPendingQuery &_return, const TSessionId &leaf_session, const TSessionId &parent_session, const std::string &query_ra, const std::string &start_time_str, const bool just_explain, const std::vector<int64_t> &outer_fragment_indices)¶

void execute_query_step(TStepResult &_return, const TPendingQuery &pending_query, const TSubqueryId subquery_id, const std::string &start_time_str)¶

void broadcast_serialized_rows(const TSerializedRows &serialized_rows, const TRowDescriptor &row_desc, const TQueryId query_id, const TSubqueryId subquery_id, const bool is_final_subquery_result)¶

void start_render_query(TPendingRenderQuery &_return, const TSessionId &session, const int64_t widget_id, const int16_t node_idx, const std::string &vega_json)¶

void execute_next_render_step(TRenderStepResult &_return, const TPendingRenderQuery &pending_render, const TRenderAggDataMap &merged_data)¶

void insert_data(const TSessionId &session, const TInsertData &insert_data)¶

void insert_chunks(const TSessionId &session, const TInsertChunks &insert_chunks)¶

void checkpoint(const TSessionId &session, const int32_t table_id)¶

void get_roles(std::vector<std::string> &_return, const TSessionId &session)¶

bool has_role(const TSessionId &sessionId, const std::string &granteeName, const std::string &roleName)¶

bool has_object_privilege(const TSessionId &sessionId, const std::string &granteeName, const std::string &objectName, const TDBObjectType::type object_type, const TDBObjectPermissions &permissions)¶

void get_db_objects_for_grantee(std::vector<TDBObject> &_return, const TSessionId &session, const std::string &roleName)¶

void get_db_object_privs(std::vector<TDBObject> &_return, const TSessionId &session, const std::string &objectName, const TDBObjectType::type type)¶

void get_all_roles_for_user(std::vector<std::string> &_return, const TSessionId &session, const std::string &granteeName)¶

void get_all_effective_roles_for_user(std::vector<std::string> &_return, const TSessionId &session, const std::string &granteeName)¶

std::vector<std::string> get_valid_groups(const TSessionId &session, int32_t dashboard_id, std::vector<std::string> groups)¶

void set_license_key(TLicenseInfo &_return, const TSessionId &session, const std::string &key, const std::string &nonce)¶

void get_license_claims(TLicenseInfo &_return, const TSessionId &session, const std::string &nonce)¶

void get_device_parameters(std::map<std::string, std::string> &_return, const TSessionId &session)¶

void register_runtime_extension_functions(const TSessionId &session, const std::vector<TUserDefinedFunction> &udfs, const std::vector<TUserDefinedTableFunction> &udtfs, const std::map<std::string, std::string> &device_ir_map)¶

void shutdown()¶

void emergency_shutdown()¶

TSessionId getInvalidSessionId() const¶

void internal_connect(TSessionId &session, const std::string &username, const std::string &dbname)¶

bool isAggregator() const¶

template<typename ...ARGS> std::shared_ptr<query_state::QueryState> create_query_state(ARGS&&... args)¶

Catalog_Namespace::SessionInfo get_session_copy(const TSessionId &session)¶

std::shared_ptr<Catalog_Namespace::SessionInfo> get_session_copy_ptr(const TSessionId &session)¶

void get_tables_meta_impl(std::vector<TTableMeta> &_return, QueryStateProxy query_state_proxy, const Catalog_Namespace::SessionInfo &session_info, const bool with_table_locks = true)¶

void resizeDispatchQueue(size_t queue_size)¶

template<> SessionMap::iterator get_session_it_unsafe(const TSessionId &session, mapd_shared_lock<mapd_shared_mutex> &read_lock)¶

template<> SessionMap::iterator get_session_it_unsafe(const TSessionId &session, mapd_unique_lock<mapd_shared_mutex> &write_lock)¶

template<> void expire_idle_sessions_unsafe(mapd_unique_lock<mapd_shared_mutex> &write_lock)¶

Public Members

std::shared_ptr<Data_Namespace::DataMgr> data_mgr_¶

LeafAggregator leaf_aggregator_¶

std::vector<LeafHostInfo> db_leaves_¶

std::vector<LeafHostInfo> string_leaves_¶

const std::string base_data_path_¶

boost::filesystem::path import_path_¶

ExecutorDeviceType executor_device_type_¶

std::default_random_engine random_gen_¶

std::uniform_int_distribution<int64_t> session_id_dist_¶

const bool jit_debug_¶

const bool intel_jit_profile_¶

bool allow_multifrag_¶

const bool read_only_¶

const bool allow_loop_joins_¶

bool cpu_mode_only_¶

mapd_shared_mutex sessions_mutex_¶

std::mutex render_mutex_¶

int64_t start_time_¶

const AuthMetadata &authMetadata_¶

SystemParameters &system_parameters_¶

std::unique_ptr<RenderHandler> render_handler_¶

std::unique_ptr<MapDAggHandler> agg_handler_¶

std::unique_ptr<MapDLeafHandler> leaf_handler_¶

std::shared_ptr<Calcite> calcite_¶

const bool legacy_syntax_¶

std::unique_ptr<QueryDispatchQueue> dispatch_queue_¶

Public Static Functions

static size_t max_bytes_for_thrift()¶

void parser_with_error_handler(const std::string &query_str, std::list<std::unique_ptr<Parser::Stmt>> &parse_trees)¶

Protected Functions

std::shared_ptr<Catalog_Namespace::SessionInfo> get_session_ptr(const TSessionId &session_id)¶

ConnectionInfo getConnectionInfo() const¶

Private Types

enum AssignRenderGroupsMode¶

Values:

kNone¶

kAssign¶

kCleanUp¶

using RenderGroupAssignmentColumnMap = std::unordered_map<std::string, std::unique_ptr<import_export::RenderGroupAnalyzer>>¶

using RenderGroupAssignmentTableMap = std::unordered_map<std::string, RenderGroupAssignmentColumnMap>¶

using RenderGroupAnalyzerSessionMap = std::unordered_map<TSessionId, RenderGroupAssignmentTableMap>¶

Private Functions

std::shared_ptr<Catalog_Namespace::SessionInfo> create_new_session(TSessionId &session, const std::string &dbname, const Catalog_Namespace::UserMetadata &user_meta, std::shared_ptr<Catalog_Namespace::Catalog> cat)¶

void connect_impl(TSessionId &session, const std::string &passwd, const std::string &dbname, const Catalog_Namespace::UserMetadata &user_meta, std::shared_ptr<Catalog_Namespace::Catalog> cat, query_state::StdLog &stdlog)¶

void disconnect_impl(const SessionMap::iterator &session_it, mapd_unique_lock<mapd_shared_mutex> &write_lock)¶

void check_table_load_privileges(const TSessionId &session, const std::string &table_name)¶

void check_table_load_privileges(const Catalog_Namespace::SessionInfo &session_info, const std::string &table_name)¶

void get_tables_impl(std::vector<std::string> &table_names, const Catalog_Namespace::SessionInfo &session_info, const GetTablesType get_tables_type, const std::string &database_name = {})¶

void get_table_details_impl(TTableDetails &_return, query_state::StdLog &stdlog, const std::string &table_name, const bool get_system, const bool get_physical, const std::string &database_name = {})¶

void getAllRolesForUserImpl(std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr, std::vector<std::string> &roles, const TSessionId &sessionId, const std::string &granteeName, bool effective)¶

void check_read_only(const std::string &str)¶

void check_session_exp_unsafe(const SessionMap::iterator &session_it)¶

void validateGroups(const std::vector<std::string> &groups)¶

void validateDashboardIdsForSharing(const Catalog_Namespace::SessionInfo &session_info, const std::vector<int32_t> &dashboard_ids)¶

void shareOrUnshareDashboards(const TSessionId &session, const std::vector<int32_t> &dashboard_ids, const std::vector<std::string> &groups, const TDashboardPermissions &permissions, const bool do_share)¶

std::shared_ptr<const Catalog_Namespace::SessionInfo> get_const_session_ptr(const TSessionId &session)¶

template<typename SESSION_MAP_LOCK> SessionMap::iterator get_session_it_unsafe(const TSessionId &session, SESSION_MAP_LOCK &lock)¶

template<typename SESSION_MAP_LOCK> void expire_idle_sessions_unsafe(SESSION_MAP_LOCK &lock)¶

std::pair<TPlanResult, lockmgr::LockedTableDescriptors> parse_to_ra(QueryStateProxy query_state_proxy, const std::string &query_str, const std::vector<TFilterPushDownInfo> &filter_push_down_info, const bool acquire_locks, const SystemParameters &system_parameters, bool check_privileges = true)¶

void sql_execute_local(TQueryResult &_return, const QueryStateProxy &query_state_proxy, const std::shared_ptr<Catalog_Namespace::SessionInfo> session_ptr, const std::string &query_str, const bool column_format, const std::string &nonce, const int32_t first_n, const int32_t at_most_n, const bool use_calcite)¶

int64_t process_deferred_copy_from(const TSessionId &session_id)¶

void sql_execute_impl(ExecutionResult &_return, QueryStateProxy query_state_proxy, const bool column_format, const ExecutorDeviceType executor_device_type, const int32_t first_n, const int32_t at_most_n, const bool use_calcite)¶

bool user_can_access_table(const Catalog_Namespace::SessionInfo &session_info, const TableDescriptor *td, const AccessPrivileges acess_priv)¶

void execute_distributed_copy_statement(Parser::CopyTableStmt *copy_stmt, const Catalog_Namespace::SessionInfo &session_info)¶

TQueryResult validate_rel_alg(const std::string &query_ra, QueryStateProxy query_state_proxy)¶

std::vector<PushedDownFilterInfo> execute_rel_alg(ExecutionResult &_return, QueryStateProxy query_state_proxy, const std::string &query_ra, const bool column_format, const ExecutorDeviceType executor_device_type, const int32_t first_n, const int32_t at_most_n, const bool just_validate, const bool find_push_down_candidates, const ExplainInfo &explain_info, const std::optional<size_t> executor_index = std::nullopt) const¶

void execute_rel_alg_with_filter_push_down(ExecutionResult &_return, QueryStateProxy query_state_proxy, std::string &query_ra, const bool column_format, const ExecutorDeviceType executor_device_type, const int32_t first_n, const int32_t at_most_n, const bool just_explain, const bool just_calcite_explain, const std::vector<PushedDownFilterInfo> &filter_push_down_requests)¶

void executeDdl(TQueryResult &_return, const std::string &query_ra, std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)¶

void executeDdl(ExecutionResult &_return, const std::string &query_ra, std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)¶

TColumnType populateThriftColumnType(const Catalog_Namespace::Catalog *cat, const ColumnDescriptor *cd)¶

TRowDescriptor fixup_row_descriptor(const TRowDescriptor &row_desc, const Catalog_Namespace::Catalog &cat)¶

void set_execution_mode_nolock(Catalog_Namespace::SessionInfo *session_ptr, const TExecuteMode::type mode)¶

char unescape_char(std::string str)¶

import_export::CopyParams thrift_to_copyparams(const TCopyParams &cp)¶

TCopyParams copyparams_to_thrift(const import_export::CopyParams &cp)¶

void check_geospatial_files(const boost::filesystem::path file_path, const import_export::CopyParams &copy_params)¶

void render_rel_alg(TRenderResult &_return, const std::string &query_ra, const std::string &query_str, const Catalog_Namespace::SessionInfo &session_info, const std::string &render_type, const bool is_projection_query)¶

TColumnType create_geo_column(const TDatumType::type type, const std::string &name, const bool is_array)¶

void convertResultSet(ExecutionResult &result, const Catalog_Namespace::SessionInfo &session_info, const std::string &query_state_str, TQueryResult &_return)¶

std::vector<TargetMetaInfo> getTargetMetaInfo(const std::vector<std::shared_ptr<Analyzer::TargetEntry>> &targets) const¶

std::vector<std::string> getTargetNames(const std::vector<TargetMetaInfo> &targets) const¶

std::vector<std::string> getTargetNames(const std::vector<std::shared_ptr<Analyzer::TargetEntry>> &targets) const¶

void get_completion_hints_unsorted(std::vector<TCompletionHint> &hints, std::vector<std::string> &visible_tables, query_state::StdLog &stdlog, const std::string &sql, const int cursor)¶

void get_token_based_completions(std::vector<TCompletionHint> &hints, query_state::StdLog &stdlog, std::vector<std::string> &visible_tables, const std::string &sql, const int cursor)¶

std::unordered_map<std::string, std::unordered_set<std::string>> fill_column_names_by_table(std::vector<std::string> &table_names, query_state::StdLog &stdlog)¶

TDashboard get_dashboard_impl(const std::shared_ptr<Catalog_Namespace::SessionInfo const> &session_ptr, Catalog_Namespace::UserMetadata &user_meta, const DashboardDescriptor *dash, const bool populate_state = true)¶

std::unordered_set<std::string> get_uc_compatible_table_names_by_column(const std::unordered_set<std::string> &uc_column_names, std::vector<std::string> &table_names, query_state::StdLog &stdlog)¶

std::unique_ptr<lockmgr::AbstractLockContainer<const TableDescriptor *>> prepare_loader_generic(const Catalog_Namespace::SessionInfo &session_info, const std::string &table_name, size_t num_cols, std::unique_ptr<import_export::Loader> *loader, std::vector<std::unique_ptr<import_export::TypedImportBuffer>> *import_buffers, const std::vector<std::string> &column_names, std::string load_type)¶

void fillGeoColumns(const TSessionId &session, const Catalog_Namespace::Catalog &catalog, std::vector<std::unique_ptr<import_export::TypedImportBuffer>> &import_buffers, const ColumnDescriptor *cd, size_t &col_idx, size_t num_rows, const std::string &table_name, bool assign_render_groups)¶

void fillMissingBuffers(const TSessionId &session, const Catalog_Namespace::Catalog &catalog, std::vector<std::unique_ptr<import_export::TypedImportBuffer>> &import_buffers, const std::list<const ColumnDescriptor *> &cds, const std::vector<int> &desc_id_to_column_id, size_t num_rows, const std::string &table_name, bool assign_render_groups)¶

void check_and_invalidate_sessions(Parser::DDLStmt *ddl)¶

template<typename STMT_TYPE> void invalidate_sessions(std::string &name, STMT_TYPE *stmt)¶

std::string const createInMemoryCalciteSession(const std::shared_ptr<Catalog_Namespace::Catalog> &catalog_ptr)¶

bool isInMemoryCalciteSession(const Catalog_Namespace::UserMetadata user_meta)¶

void removeInMemoryCalciteSession(const std::string &session_id)¶

ExecutionResult getUserSessions(std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)¶

ExecutionResult getQueries(std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr)¶

void get_queries_info(std::vector<TQueryInfo> &_return, const TSessionId &session)¶

void interruptQuery(const Catalog_Namespace::SessionInfo &session_info, const std::string &target_session)¶

void loadTableBinaryColumnarInternal(const TSessionId &session, const std::string &table_name, const std::vector<TColumn> &cols, const std::vector<std::string> &column_names, const AssignRenderGroupsMode assign_render_groups_mode)¶

TRole::type getServerRole() const¶

void importGeoTableGlobFilterSort(const TSessionId &session, const std::string &table_name, const std::string &file_name, const import_export::CopyParams &copy_params, const TRowDescriptor &row_desc, const TCreateParams &create_params)¶

void importGeoTableSingle(const TSessionId &session, const std::string &table_name, const std::string &file_name, const import_export::CopyParams &copy_params, const TRowDescriptor &row_desc, const TCreateParams &create_params)¶

Private Members

std::atomic<bool> initialized_ = {false}¶

query_state::QueryStates query_states_¶

SessionMap sessions_¶

bool super_user_rights_¶

const int idle_session_duration_¶

const int max_session_duration_¶

const bool runtime_udf_registration_enabled_¶

const bool enable_rendering_¶

const bool renderer_use_ppll_polys_¶

const bool renderer_prefer_igpu_¶

const unsigned renderer_vulkan_timeout_¶

const bool enable_auto_clear_render_mem_¶

const int render_oom_retry_threshold_¶

const size_t max_concurrent_render_sessions_¶

const size_t reserved_gpu_mem_¶

const bool render_compositor_use_last_gpu_¶

const size_t render_mem_bytes_¶

const size_t num_reader_threads_¶

const File_Namespace::DiskCacheConfig &disk_cache_config_¶

const std::string &udf_filename_¶

const std::string &clang_path_¶

const std::vector<std::string> &clang_options_¶

DeferredCopyFromSessions deferred_copy_from_sessions¶

std::mutex handle_to_dev_ptr_mutex_¶

std::unordered_map<std::string, std::string> ipc_handle_to_dev_ptr_¶

std::map<const std::string, const PermissionFuncPtr> DBHandler::permissionFuncMap_= { {"database"s, has_database_permission}, {"dashboard"s, has_dashboard_permission}, {"table"s, has_table_permission}, {"view"s, has_view_permission}, {"server"s, has_server_permission}}

RenderGroupAnalyzerSessionMap render_group_assignment_map_¶

std::mutex render_group_assignment_mutex_¶

mapd_shared_mutex custom_expressions_mutex_¶

Private Static Functions

void value_to_thrift_column(const TargetValue &tv, const SQLTypeInfo &ti, TColumn &column)¶

TDatum value_to_thrift(const TargetValue &tv, const SQLTypeInfo &ti)¶

void convertData(TQueryResult &_return, ExecutionResult &result, const QueryStateProxy &query_state_proxy, const std::string &query_str, const bool column_format, const int32_t first_n, const int32_t at_most_n)¶

void convertExplain(TQueryResult &_return, const ResultSet &results, const bool column_format)¶

void convertResult(TQueryResult &_return, const ResultSet &results, const bool column_format)¶

void convertRows(TQueryResult &_return, QueryStateProxy query_state_proxy, const std::vector<TargetMetaInfo> &targets, const ResultSet &results, const bool column_format, const int32_t first_n, const int32_t at_most_n)¶

void createSimpleResult(TQueryResult &_return, const ResultSet &results, const bool column_format, const std::string label)¶

bool has_database_permission(const AccessPrivileges &privs, const TDBObjectPermissions &permissions)¶

bool has_table_permission(const AccessPrivileges &privs, const TDBObjectPermissions &permission)¶

bool has_dashboard_permission(const AccessPrivileges &privs, const TDBObjectPermissions &permissions)¶

bool has_view_permission(const AccessPrivileges &privs, const TDBObjectPermissions &permissions)¶

bool has_server_permission(const AccessPrivileges &privs, const TDBObjectPermissions &permissions)¶

Friends

friend DBHandler::RenderHandler::Impl

friend DBHandler::MapDAggHandler

friend DBHandler::MapDLeafHandler

void run_warmup_queries(std::shared_ptr<DBHandler> handler, std::string base_path, std::string query_file_path)¶

struct DeferredCopyFromSessions¶

Public Functions

std::optional<DeferredCopyFromState> operator()(const std::string &session_id)¶

void add(const std::string &session_id, const DeferredCopyFromState &state)¶

void remove(const std::string &session_id)¶

Public Members

std::unordered_map<std::string, DeferredCopyFromState> was_deferred_copy_from¶

std::mutex deferred_copy_from_mutex¶

struct DeferredCopyFromState¶

Public Members

std::string table¶

std::string file_name¶

import_export::CopyParams copy_params¶

std::string partitions¶