_d_b_handler_8h_source.html

 /*

  * Copyright 2022 HEAVY.AI, Inc.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */


 #pragma once


 #include "LeafAggregator.h"


 #ifdef HAVE_PROFILER

 #include <gperftools/heap-profiler.h>

 #endif  // HAVE_PROFILER


 #include "Calcite/Calcite.h"

 #include "Catalog/Catalog.h"

 #include "Fragmenter/InsertOrderFragmenter.h"

 #include "Geospatial/Transforms.h"

 #include "ImportExport/Importer.h"

 #include "ImportExport/RenderGroupAnalyzer.h"

 #include "LockMgr/LockMgr.h"

 #include "Logger/Logger.h"

 #include "Parser/ParserNode.h"

 #include "Parser/ParserWrapper.h"

 #include "Parser/ReservedKeywords.h"

 #include "QueryEngine/CalciteAdapter.h"

 #include "QueryEngine/Descriptors/RelAlgExecutionDescriptor.h"

 #include "QueryEngine/Execute.h"

 #include "QueryEngine/ExtensionFunctionsWhitelist.h"

 #include "QueryEngine/GpuMemUtils.h"

 #include "QueryEngine/JsonAccessors.h"

 #include "QueryEngine/QueryDispatchQueue.h"

 #include "QueryEngine/QueryEngine.h"

 #include "QueryEngine/TableGenerations.h"

 #include "Shared/StringTransform.h"

 #include "Shared/SystemParameters.h"

 #include "Shared/clean_boost_regex.hpp"

 #include "Shared/heavyai_shared_mutex.h"

 #include "Shared/measure.h"

 #include "Shared/scope.h"

 #include "StringDictionary/StringDictionaryClient.h"

 #include "ThriftHandler/ConnectionInfo.h"

 #include "ThriftHandler/QueryState.h"

 #include "ThriftHandler/RenderHandler.h"

 #include "ThriftHandler/SystemValidator.h"


 #include <sys/types.h>

 #include <thrift/server/TServer.h>

 #include <thrift/transport/THttpClient.h>

 #include <thrift/transport/THttpTransport.h>

 #include <thrift/transport/TSocket.h>

 #include <thrift/transport/TTransport.h>

 #include <atomic>

 #include <boost/algorithm/string.hpp>

 #include <boost/algorithm/string/replace.hpp>

 #include <boost/algorithm/string/trim.hpp>

 #include <boost/filesystem.hpp>

 #include <boost/make_shared.hpp>

 #include <boost/noncopyable.hpp>

 #include <boost/none_t.hpp>

 #include <boost/optional.hpp>

 #include <boost/program_options.hpp>

 #include <boost/tokenizer.hpp>

 #include <cmath>

 #include <csignal>

 #include <fstream>

 #include <list>

 #include <map>

 #include <memory>

 #include <mutex>

 #include <random>

 #include <string>

 #include <thread>

 #include <typeinfo>

 #include <unordered_map>


 #include "gen-cpp/Heavy.h"

 #include "gen-cpp/extension_functions_types.h"


 using namespace std::string_literals;


 class HeavyDBAggHandler;

 class HeavyDBLeafHandler;


 // Multiple concurrent requests for the same session can occur.  For that reason, each

 // request briefly takes a lock to make a copy of the appropriate SessionInfo object. Then

 // it releases the lock and uses the copy for the remainder of the request.

 using SessionMap = std::map<TSessionId, std::shared_ptr<Catalog_Namespace::SessionInfo>>;

 using PermissionFuncPtr = bool (*)(const AccessPrivileges&, const TDBObjectPermissions&);

 using query_state::QueryStateProxy;


 namespace dbhandler {

 bool is_info_schema_db(const std::string& db_name);


 void check_not_info_schema_db(const std::string& db_name,

                               bool throw_db_exception = false);

 }  // namespace dbhandler


 class TrackingProcessor : public HeavyProcessor {

  public:

   TrackingProcessor(std::shared_ptr<HeavyIf> handler, const bool check_origin)

       : HeavyProcessor(handler), check_origin_(check_origin) {}


   bool process(std::shared_ptr<::apache::thrift::protocol::TProtocol> in,

                std::shared_ptr<::apache::thrift::protocol::TProtocol> out,

                void* connectionContext) override {

     using namespace ::apache::thrift;


     auto transport = in->getTransport();

     if (transport && check_origin_) {

       static std::mutex processor_mutex;

       std::lock_guard lock(processor_mutex);

       const auto origin_str = transport->getOrigin();

       std::vector<std::string> origins;

       boost::split(origins, origin_str, boost::is_any_of(","));

       if (origins.empty()) {

         TrackingProcessor::client_address = origin_str;

       } else {

         // Take the first origin, which should be the client IP before any intermediate

         // servers (e.g. the web server)

         auto trimmed_origin = origins.front();

         boost::algorithm::trim(trimmed_origin);

         TrackingProcessor::client_address = trimmed_origin;

       }

       if (dynamic_cast<transport::THttpTransport*>(transport.get())) {

         TrackingProcessor::client_protocol = ClientProtocol::HTTP;

       } else if (dynamic_cast<transport::TBufferedTransport*>(transport.get())) {

         TrackingProcessor::client_protocol = ClientProtocol::TCP;

       } else {

         TrackingProcessor::client_protocol = ClientProtocol::Other;

       }

     } else {

       TrackingProcessor::client_address = "";

     }


     return HeavyProcessor::process(in, out, connectionContext);

   }


   static thread_local std::string client_address;

   static thread_local ClientProtocol client_protocol;


  private:

   const bool check_origin_;

 };


 namespace File_Namespace {

 struct DiskCacheConfig;

 }


 class DBHandler : public HeavyIf {

  public:

   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 std::string& udf_filename,

             const std::string& clang_path,

             const std::vector<std::string>& clang_options,

 #ifdef ENABLE_GEOS

             const std::string& libgeos_so_filename,

 #endif

             const File_Namespace::DiskCacheConfig& disk_cache_config,

             const bool is_new_db);

   void initialize(const bool is_new_db);

   ~DBHandler() override;


   static inline size_t max_bytes_for_thrift() { return 2 * 1000 * 1000 * 1000LL; }


   // Important ****

   //         This block must be keep in sync with mapd.thrift and HAHandler.h

   //         Please keep in same order for easy check and cut and paste

   // Important ****


   void krb5_connect(TKrb5Session& session,

                     const std::string& token,

                     const std::string& dbname) override;

   // connection, admin

   void connect(TSessionId& session,

                const std::string& username,

                const std::string& passwd,

                const std::string& dbname) override;

   void disconnect(const TSessionId& session) override;

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

   void clone_session(TSessionId& session2, const TSessionId& session1) override;

   void get_server_status(TServerStatus& _return, const TSessionId& session) override;

   void get_status(std::vector<TServerStatus>& _return,

                   const TSessionId& session) override;

   void get_hardware_info(TClusterHardwareInfo& _return,

                          const TSessionId& session) override;


   bool hasTableAccessPrivileges(const TableDescriptor* td,

                                 const Catalog_Namespace::SessionInfo& session_info);

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

   void get_tables_for_database(std::vector<std::string>& _return,

                                const TSessionId& session,

                                const std::string& database_name) override;

   void get_physical_tables(std::vector<std::string>& _return,

                            const TSessionId& session) override;

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

   void get_tables_meta(std::vector<TTableMeta>& _return,

                        const TSessionId& session) override;

   void get_table_details(TTableDetails& _return,

                          const TSessionId& session,

                          const std::string& table_name) override;

   void get_table_details_for_database(TTableDetails& _return,

                                       const TSessionId& session,

                                       const std::string& table_name,

                                       const std::string& database_name) override;

   void get_internal_table_details(TTableDetails& _return,

                                   const TSessionId& session,

                                   const std::string& table_name,

                                   const bool include_system_columns) override;

   void get_internal_table_details_for_database(TTableDetails& _return,

                                                const TSessionId& session,

                                                const std::string& table_name,

                                                const std::string& database_name) override;

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

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


   void get_version(std::string& _return) override;

   void start_heap_profile(const TSessionId& session) override;

   void stop_heap_profile(const TSessionId& session) override;

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

   void get_memory(std::vector<TNodeMemoryInfo>& _return,

                   const TSessionId& session,

                   const std::string& memory_level) override;

   void clear_cpu_memory(const TSessionId& session) override;

   void clear_gpu_memory(const TSessionId& session) override;

   void clearRenderMemory(const TSessionId& session);  // it's not declared on thrifth

                                                       // and on persisten leaf client

   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) override;

   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) override;

   void set_table_epoch(const TSessionId& session,

                        const int db_id,

                        const int table_id,

                        const int new_epoch) override;

   void set_table_epoch_by_name(const TSessionId& session,

                                const std::string& table_name,

                                const int new_epoch) override;

   int32_t get_table_epoch(const TSessionId& session,

                           const int32_t db_id,

                           const int32_t table_id) override;

   int32_t get_table_epoch_by_name(const TSessionId& session,

                                   const std::string& table_name) override;

   void get_table_epochs(std::vector<TTableEpochInfo>& _return,

                         const TSessionId& session,

                         const int32_t db_id,

                         const int32_t table_id) override;

   void set_table_epochs(const TSessionId& session,

                         const int32_t db_id,

                         const std::vector<TTableEpochInfo>& table_epochs) override;


   void get_session_info(TSessionInfo& _return, const TSessionId& session) override;


   void set_leaf_info(const TSessionId& session, const TLeafInfo& info) override;


   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,

                    lockmgr::LockedTableDescriptors& locks);

   // query, render

   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) override;

   void get_completion_hints(std::vector<TCompletionHint>& hints,

                             const TSessionId& session,

                             const std::string& sql,

                             const int cursor) override;

   // TODO(miyu): merge the following two data frame APIs.

   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) override;

   void sql_execute_gdf(TDataFrame& _return,

                        const TSessionId& session,

                        const std::string& query,

                        const int32_t device_id,

                        const int32_t first_n) override;

   void deallocate_df(const TSessionId& session,

                      const TDataFrame& df,

                      const TDeviceType::type device_type,

                      const int32_t device_id) override;

   void interrupt(const TSessionId& query_session,

                  const TSessionId& interrupt_session) override;

   void sql_validate(TRowDescriptor& _return,

                     const TSessionId& session,

                     const std::string& query) override;

   TExecuteMode::type getExecutionMode(const TSessionId& session);

   void set_execution_mode(const TSessionId& session,

                           const TExecuteMode::type mode) override;

   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) override;

   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) override;


   // custom expressions

   int32_t create_custom_expression(const TSessionId& session,

                                    const TCustomExpression& custom_expression) override;

   void get_custom_expressions(std::vector<TCustomExpression>& _return,

                               const TSessionId& session) override;

   void update_custom_expression(const TSessionId& session,

                                 const int32_t id,

                                 const std::string& expression_json) override;

   void delete_custom_expressions(const TSessionId& session,

                                  const std::vector<int32_t>& custom_expression_ids,

                                  const bool do_soft_delete) override;


   // dashboards

   void get_dashboard(TDashboard& _return,

                      const TSessionId& session,

                      const int32_t dashboard_id) override;

   void get_dashboards(std::vector<TDashboard>& _return,

                       const TSessionId& session) override;

   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) override;

   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) override;

   void delete_dashboard(const TSessionId& session, const int32_t dashboard_id) override;

   void share_dashboards(const TSessionId& session,

                         const std::vector<int32_t>& dashboard_ids,

                         const std::vector<std::string>& groups,

                         const TDashboardPermissions& permissions) override;

   void delete_dashboards(const TSessionId& session,

                          const std::vector<int32_t>& dashboard_ids) override;

   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) override;

   void unshare_dashboards(const TSessionId& session,

                           const std::vector<int32_t>& dashboard_ids,

                           const std::vector<std::string>& groups,

                           const TDashboardPermissions& permissions) override;

   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) override;

   void get_dashboard_grantees(std::vector<TDashboardGrantees>& _return,

                               const TSessionId& session,

                               const int32_t dashboard_id) override;


   void get_link_view(TFrontendView& _return,

                      const TSessionId& session,

                      const std::string& link) override;

   void create_link(std::string& _return,

                    const TSessionId& session,

                    const std::string& view_state,

                    const std::string& view_metadata) override;

   // import

   void load_table_binary(const TSessionId& session,

                          const std::string& table_name,

                          const std::vector<TRow>& rows,

                          const std::vector<std::string>& column_names) override;


   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) override;

   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) override;

   void load_table_binary_arrow(const TSessionId& session,

                                const std::string& table_name,

                                const std::string& arrow_stream,

                                const bool use_column_names) override;


   void load_table(const TSessionId& session,

                   const std::string& table_name,

                   const std::vector<TStringRow>& rows,

                   const std::vector<std::string>& column_names) override;

   void detect_column_types(TDetectResult& _return,

                            const TSessionId& session,

                            const std::string& file_name,

                            const TCopyParams& copy_params) override;

   void create_table(const TSessionId& session,

                     const std::string& table_name,

                     const TRowDescriptor& row_desc,

                     const TCreateParams& create_params) override;

   void import_table(const TSessionId& session,

                     const std::string& table_name,

                     const std::string& file_name,

                     const TCopyParams& copy_params) override;

   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) override;

   void import_table_status(TImportStatus& _return,

                            const TSessionId& session,

                            const std::string& import_id) override;

   void get_first_geo_file_in_archive(std::string& _return,

                                      const TSessionId& session,

                                      const std::string& archive_path,

                                      const TCopyParams& copy_params) override;

   void get_all_files_in_archive(std::vector<std::string>& _return,

                                 const TSessionId& session,

                                 const std::string& archive_path,

                                 const TCopyParams& copy_params) override;

   void get_layers_in_geo_file(std::vector<TGeoFileLayerInfo>& _return,

                               const TSessionId& session,

                               const std::string& file_name,

                               const TCopyParams& copy_params) override;

   // distributed

   int64_t query_get_outer_fragment_count(const TSessionId& session,

                                          const std::string& select_query) override;


   void check_table_consistency(TTableMeta& _return,

                                const TSessionId& session,

                                const int32_t table_id) override;

   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) override;

   void execute_query_step(TStepResult& _return,

                           const TPendingQuery& pending_query,

                           const TSubqueryId subquery_id,

                           const std::string& start_time_str) override;

   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) override;


   void start_render_query(TPendingRenderQuery& _return,

                           const TSessionId& session,

                           const int64_t widget_id,

                           const int16_t node_idx,

                           const std::string& vega_json) override;

   void execute_next_render_step(TRenderStepResult& _return,

                                 const TPendingRenderQuery& pending_render,

                                 const TRenderAggDataMap& merged_data) override;


   void insert_data(const TSessionId& session, const TInsertData& insert_data) override;

   void insert_chunks(const TSessionId& session,

                      const TInsertChunks& insert_chunks) override;

   void checkpoint(const TSessionId& session, const int32_t table_id) override;

   // DB Object Privileges

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

   bool has_role(const TSessionId& sessionId,

                 const std::string& granteeName,

                 const std::string& roleName) override;

   bool has_object_privilege(const TSessionId& sessionId,

                             const std::string& granteeName,

                             const std::string& objectName,

                             const TDBObjectType::type object_type,

                             const TDBObjectPermissions& permissions) override;

   void get_db_objects_for_grantee(std::vector<TDBObject>& _return,

                                   const TSessionId& session,

                                   const std::string& roleName) override;

   void get_db_object_privs(std::vector<TDBObject>& _return,

                            const TSessionId& session,

                            const std::string& objectName,

                            const TDBObjectType::type type) override;

   void get_all_roles_for_user(std::vector<std::string>& _return,

                               const TSessionId& session,

                               const std::string& granteeName) override;

   void get_all_effective_roles_for_user(std::vector<std::string>& _return,

                                         const TSessionId& session,

                                         const std::string& granteeName) override;

   std::vector<std::string> get_valid_groups(const TSessionId& session,

                                             int32_t dashboard_id,

                                             std::vector<std::string> groups);

   // licensing

   void set_license_key(TLicenseInfo& _return,

                        const TSessionId& session,

                        const std::string& key,

                        const std::string& nonce) override;

   void get_license_claims(TLicenseInfo& _return,

                           const TSessionId& session,

                           const std::string& nonce) override;

   // user-defined functions

   /*

     Returns a mapping of device (CPU, GPU) parameters (name, LLVM IR

     triplet, features, etc)

    */

   void get_device_parameters(std::map<std::string, std::string>& _return,

                              const TSessionId& session) override;


   /*

     Register Runtime Extension Functions (UDFs, UDTFs) with given

     signatures. The extension functions implementations are given in a

     mapping of a device and the corresponding LLVM/NVVM IR string.

    */


   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) override;


   /*

     Returns a list of User-Defined Function names available

    */

   void get_function_names(std::vector<std::string>& _return,

                           const TSessionId& session) override;


   /*

     Returns a list of runtime User-Defined Function names available

    */

   void get_runtime_function_names(std::vector<std::string>& _return,

                                   const TSessionId& session) override;


   /*

     Returns a list of runtime User-Defined Function names available

    */

   void get_function_details(std::vector<TUserDefinedFunction>& _return,

                             const TSessionId& session,

                             const std::vector<std::string>& udf_names) override;


   /*

     Returns a list of User-Defined Table Function names available

    */

   void get_table_function_names(std::vector<std::string>& _return,

                                 const TSessionId& session) override;


   /*

     Returns a list of runtime User-Defined Table Function names available

    */

   void get_runtime_table_function_names(std::vector<std::string>& _return,

                                         const TSessionId& session) override;


   /*

     Returns a list of User-Defined Table Function details

    */

   void get_table_function_details(std::vector<TUserDefinedTableFunction>& _return,

                                   const TSessionId& session,

                                   const std::vector<std::string>& udtf_names) override;


   // end of sync block for HAHandler and mapd.thrift


   void shutdown();

   void emergency_shutdown();


   TSessionId getInvalidSessionId() const;


   void internal_connect(TSessionId& session,

                         const std::string& username,

                         const std::string& dbname);


   bool isAggregator() const;


   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_;

   heavyai::shared_mutex sessions_mutex_;

   std::mutex render_mutex_;

   int64_t start_time_;

   const AuthMetadata& authMetadata_;

   SystemParameters& system_parameters_;

   std::shared_ptr<QueryEngine> query_engine_;

   std::unique_ptr<RenderHandler> render_handler_;

   std::unique_ptr<HeavyDBAggHandler> agg_handler_;

   std::unique_ptr<HeavyDBLeafHandler> leaf_handler_;

   std::shared_ptr<Calcite> calcite_;

   const bool legacy_syntax_;


   std::unique_ptr<QueryDispatchQueue> dispatch_queue_;


   template <typename... ARGS>

   std::shared_ptr<query_state::QueryState> create_query_state(ARGS&&... args) {

     return query_states_.create(std::forward<ARGS>(args)...);

   }


   // Exactly one immutable SessionInfo copy should be taken by a typical request.

   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);


   // Visible for use in tests.

   void resizeDispatchQueue(size_t queue_size);


  protected:

   // Returns empty std::shared_ptr if !check_license && session.empty().

   std::shared_ptr<Catalog_Namespace::SessionInfo> get_session_ptr(

       const TSessionId& session_id);


   ConnectionInfo getConnectionInfo() const;


  private:

   std::atomic<bool> initialized_{false};

   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,

                        heavyai::unique_lock<heavyai::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&,

                        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);


   // Use get_session_copy() or get_session_copy_ptr() instead of get_const_session_ptr()

   // unless you know what you are doing. If you need to save a SessionInfo beyond the

   // present Thrift call, then the safe way to do this is by saving the return value of

   // get_const_session_ptr() as a std::weak_ptr.

   // Returns empty std::shared_ptr if session.empty().

   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);

   static void value_to_thrift_column(const TargetValue& tv,

                                      const SQLTypeInfo& ti,

                                      TColumn& column);

   static TDatum value_to_thrift(const TargetValue& tv, const SQLTypeInfo& ti);


   std::pair<TPlanResult, lockmgr::LockedTableDescriptors> parse_to_ra(

       QueryStateProxy,

       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);


   static void convertData(TQueryResult& _return,

                           ExecutionResult& result,

                           const QueryStateProxy& query_state_proxy,

                           const bool column_format,

                           const int32_t first_n,

                           const int32_t at_most_n);


   void sql_execute_impl(ExecutionResult& _return,

                         QueryStateProxy,

                         const bool column_format,

                         const ExecutorDeviceType executor_device_type,

                         const int32_t first_n,

                         const int32_t at_most_n,

                         const bool use_calcite,

                         lockmgr::LockedTableDescriptors& locks);


   bool user_can_access_table(const Catalog_Namespace::SessionInfo&,

                              const TableDescriptor* td,

                              const AccessPrivileges acess_priv);


   void execute_distributed_copy_statement(

       Parser::CopyTableStmt*,

       const Catalog_Namespace::SessionInfo& session_info);


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


   std::vector<PushedDownFilterInfo> execute_rel_alg(

       ExecutionResult& _return,

       QueryStateProxy,

       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,

       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);


   static void convertExplain(TQueryResult& _return,

                              const ResultSet& results,

                              const bool column_format);

   static void convertResult(TQueryResult& _return,

                             const ResultSet& results,

                             const bool column_format);


   static 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);


   // Use ExecutionResult to populate a TQueryResult

   //    calls convertRows, but after some setup using session_info

   void convertResultSet(ExecutionResult& result,

                         const Catalog_Namespace::SessionInfo& session_info,

                         const std::string& query_state_str,

                         TQueryResult& _return);


   static void createSimpleResult(TQueryResult& _return,

                                  const ResultSet& results,

                                  const bool column_format,

                                  const std::string label);


   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);


   static bool has_database_permission(const AccessPrivileges& privs,

                                       const TDBObjectPermissions& permissions);

   static bool has_table_permission(const AccessPrivileges& privs,

                                    const TDBObjectPermissions& permission);

   static bool has_dashboard_permission(const AccessPrivileges& privs,

                                        const TDBObjectPermissions& permissions);

   static bool has_view_permission(const AccessPrivileges& privs,

                                   const TDBObjectPermissions& permissions);

   static bool has_server_permission(const AccessPrivileges& privs,

                                     const TDBObjectPermissions& permissions);

   // For the provided upper case column names `uc_column_names`, return

   // the tables from `table_names` which contain at least one of them.

   // Used to rank the TABLE auto-completion hints by the columns

   // specified in the projection.

   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);


   query_state::QueryStates query_states_;

   SessionMap sessions_;


   bool super_user_rights_;           // default is "false"; setting to "true"

                                      // ignores passwd checks in "connect(..)"

                                      // method

   const int idle_session_duration_;  // max duration of idle session

   const int max_session_duration_;   // max duration of session


   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_;

 #ifdef ENABLE_GEOS

   const std::string& libgeos_so_filename_;

 #endif

   const File_Namespace::DiskCacheConfig& disk_cache_config_;

   const std::string& udf_filename_;

   const std::string& clang_path_;

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


   struct DeferredCopyFromState {

     std::string table;

     std::string file_name;

     import_export::CopyParams copy_params;

     std::string partitions;

   };


   struct DeferredCopyFromSessions {

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

     std::mutex deferred_copy_from_mutex;


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

       std::lock_guard<std::mutex> map_lock(deferred_copy_from_mutex);

       auto itr = was_deferred_copy_from.find(session_id);

       if (itr == was_deferred_copy_from.end()) {

         return std::nullopt;

       }

       return itr->second;

     }


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

       std::lock_guard<std::mutex> map_lock(deferred_copy_from_mutex);

       const auto ret = was_deferred_copy_from.insert(std::make_pair(session_id, state));

       CHECK(ret.second);

     }


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

       std::lock_guard<std::mutex> map_lock(deferred_copy_from_mutex);

       was_deferred_copy_from.erase(session_id);

     }

   };

   DeferredCopyFromSessions deferred_copy_from_sessions;


   // Only for IPC device memory deallocation

   mutable std::mutex handle_to_dev_ptr_mutex_;

   mutable std::unordered_map<std::string, std::string> ipc_handle_to_dev_ptr_;


   friend void run_warmup_queries(std::shared_ptr<DBHandler> handler,

                                  std::string base_path,

                                  std::string query_file_path);


   friend class RenderHandler::Impl;

   friend class HeavyDBAggHandler;

   friend class HeavyDBLeafHandler;


   std::map<const std::string, const PermissionFuncPtr> 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}};


   void check_and_invalidate_sessions(Parser::DDLStmt* ddl);


   template <typename STMT_TYPE>

   void invalidate_sessions(std::string& name, STMT_TYPE* stmt) {

     using namespace Parser;

     auto is_match = [&](auto session_it) {

       if (ShouldInvalidateSessionsByDB<STMT_TYPE>()) {

         return boost::iequals(name,

                               session_it->second->getCatalog().getCurrentDB().dbName);

       } else if (ShouldInvalidateSessionsByUser<STMT_TYPE>()) {

         return boost::iequals(name, session_it->second->get_currentUser().userName);

       }

       return false;

     };

     auto check_and_remove_sessions = [&]() {

       for (auto it = sessions_.begin(); it != sessions_.end();) {

         if (is_match(it)) {

           it = sessions_.erase(it);

         } else {

           ++it;

         }

       }

     };

     check_and_remove_sessions();

   }


   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);


   // getQueries returns a set of queries queued in the DB

   //    that belongs to the same DB in the caller's session


   ExecutionResult getQueries(

       std::shared_ptr<Catalog_Namespace::SessionInfo const> session_ptr);


   void get_queries_info(std::vector<TQueryInfo>& _return,

                         const TSessionId& session) override;


   // this function passes the interrupt request to the DB executor

   void interruptQuery(const Catalog_Namespace::SessionInfo& session_info,

                       const std::string& target_session);


   void alterSystemClear(const std::string& sesson_id,

                         ExecutionResult& result,

                         const std::string& cache_type,

                         int64_t& execution_time_ms);


   void alterSession(const std::string& sesson_id,

                     ExecutionResult& result,

                     const std::pair<std::string, std::string>& session_parameter,

                     int64_t& execution_time_ms);


   // render group assignment


   enum class AssignRenderGroupsMode { kNone, kAssign, kCleanUp };


   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;


   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>;

   RenderGroupAnalyzerSessionMap render_group_assignment_map_;

   std::mutex render_group_assignment_mutex_;

   heavyai::shared_mutex custom_expressions_mutex_;


   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);

 };

heavyai::lock_guard
std::lock_guard< T > lock_guard
Definition: heavyai_shared_mutex.h:37

DBHandler::DeferredCopyFromSessions
Definition: DBHandler.h:985

RenderHandler.h

ParserWrapper.h
Classes used to wrap parser calls for calcite redirection.

DBHandler::AssignRenderGroupsMode
AssignRenderGroupsMode
Definition: DBHandler.h:1089

DBHandler::string_leaves_
std::vector< LeafHostInfo > string_leaves_
Definition: DBHandler.h:627

Catalog_Namespace::anonymous_namespace{SysCatalog.cpp}::get_users
auto get_users(SysCatalog &syscat, std::unique_ptr< SqliteConnector > &sqliteConnector, const int32_t dbId=-1)
Definition: SysCatalog.cpp:1628

DBHandler::clang_options_
const std::vector< std::string > & clang_options_
Definition: DBHandler.h:976

DBHandler::import_path_
boost::filesystem::path import_path_
Definition: DBHandler.h:629

DBHandler::dispatch_queue_
std::unique_ptr< QueryDispatchQueue > dispatch_queue_
Definition: DBHandler.h:651

lockmgr::LockedTableDescriptors
std::vector< std::unique_ptr< lockmgr::AbstractLockContainer< const TableDescriptor * >>> LockedTableDescriptors
Definition: LockMgr.h:271

DBHandler::RenderGroupAssignmentTableMap
std::unordered_map< std::string, RenderGroupAssignmentColumnMap > RenderGroupAssignmentTableMap
Definition: DBHandler.h:1104

run_benchmark_import.label
label
Definition: run_benchmark_import.py:259

ClientProtocol
ClientProtocol
Definition: ConnectionInfo.h:23

StringDictionaryClient.h

QueryDispatchQueue.h

HeavyDBLeafHandler
Definition: DistributedHandler.h:48

DBHandler::udf_filename_
const std::string & udf_filename_
Definition: DBHandler.h:974

cat
std::string cat(Ts &&...args)
Definition: StringTransform.h:41

run_benchmark_import.args
tuple args
Definition: run_benchmark_import.py:247

DBHandler::DeferredCopyFromState::table
std::string table
Definition: DBHandler.h:979

DBHandler::render_oom_retry_threshold_
const int render_oom_retry_threshold_
Definition: DBHandler.h:964

Catalog_Namespace::Catalog
class for a per-database catalog. also includes metadata for the current database and the current use...
Definition: Catalog.h:132

run_warmup_queries
void run_warmup_queries(std::shared_ptr< DBHandler > handler, std::string base_path, std::string query_file_path)
Definition: HeavyDB.cpp:206

DBHandler::handle_to_dev_ptr_mutex_
std::mutex handle_to_dev_ptr_mutex_
Definition: DBHandler.h:1012

Transforms.h

DBHandler::DeferredCopyFromSessions::deferred_copy_from_mutex
std::mutex deferred_copy_from_mutex
Definition: DBHandler.h:987

DBHandler::create_query_state
std::shared_ptr< query_state::QueryState > create_query_state(ARGS &&...args)
Definition: DBHandler.h:654

File_Namespace::DiskCacheConfig
Definition: CachingFileMgr.h:41

TrackingProcessor::client_address
static thread_local std::string client_address
Definition: DBHandler.h:155

ExecutorDeviceType
ExecutorDeviceType
Definition: CompilationOptions.h:25

DBHandler::render_group_assignment_mutex_
std::mutex render_group_assignment_mutex_
Definition: DBHandler.h:1108

DBHandler::DeferredCopyFromSessions::add
void add(const std::string &session_id, const DeferredCopyFromState &state)
Definition: DBHandler.h:998

query_state::QueryStates
Definition: QueryState.h:187

Parser::anonymous_namespace{ParserNode.cpp}::user_can_access_table
bool user_can_access_table(const Catalog_Namespace::SessionInfo &session_info, const TableDescriptor *td, const AccessPrivileges access_priv)
Definition: ParserNode.cpp:4580

PermissionFuncPtr
bool(*)(const AccessPrivileges &, const TDBObjectPermissions &) PermissionFuncPtr
Definition: DBHandler.h:105

LockMgr.h

bench_batch_streaming_ingest.create_table
def create_table
Definition: bench_batch_streaming_ingest.py:31

Catalog_Namespace::SessionInfo
Definition: SessionInfo.h:46

SystemParameters
Definition: SystemParameters.h:27

TrackingProcessor::client_protocol
static thread_local ClientProtocol client_protocol
Definition: DBHandler.h:156

DBHandler::leaf_aggregator_
LeafAggregator leaf_aggregator_
Definition: DBHandler.h:625

bench_system_tables.create_dashboard
def create_dashboard
Definition: bench_system_tables.py:44

InsertOrderFragmenter.h

Parser::DDLStmt
Definition: ParserNode.h:760

heavydb.connection.connect
def connect
Definition: connection.py:51

query_state::StdLog
Definition: QueryState.h:262

AccessPrivileges
Definition: DBObject.h:132

DBHandler::RenderGroupAnalyzerSessionMap
std::unordered_map< TSessionId, RenderGroupAssignmentTableMap > RenderGroupAnalyzerSessionMap
Definition: DBHandler.h:1106

DBHandler::renderer_vulkan_timeout_
const unsigned renderer_vulkan_timeout_
Definition: DBHandler.h:962

DBHandler::base_data_path_
const std::string base_data_path_
Definition: DBHandler.h:628

DBHandler::jit_debug_
const bool jit_debug_
Definition: DBHandler.h:633

foreign_storage::write_lock
heavyai::unique_lock< heavyai::shared_mutex > write_lock
Definition: ForeignStorageCache.cpp:30

TrackingProcessor::check_origin_
const bool check_origin_
Definition: DBHandler.h:159

DBHandler::render_mem_bytes_
const size_t render_mem_bytes_
Definition: DBHandler.h:968

DBHandler::DeferredCopyFromState
Definition: DBHandler.h:978

Importer.h

SessionMap
std::map< TSessionId, std::shared_ptr< Catalog_Namespace::SessionInfo >> SessionMap
Definition: DBHandler.h:104

Parser::CopyTableStmt
Definition: ParserNode.h:1517

RelAlgExecutionDescriptor.h

DBHandler::deferred_copy_from_sessions
DeferredCopyFromSessions deferred_copy_from_sessions
Definition: DBHandler.h:1009

ExplainInfo
Definition: ParserWrapper.h:30

DBHandler::DeferredCopyFromState::partitions
std::string partitions
Definition: DBHandler.h:982

split
std::vector< std::string > split(std::string_view str, std::string_view delim, std::optional< size_t > maxsplit)
split apart a string into a vector of substrings
Definition: StringTransform.cpp:144

DBHandler::start_time_
int64_t start_time_
Definition: DBHandler.h:641

DBHandler::renderer_use_ppll_polys_
const bool renderer_use_ppll_polys_
Definition: DBHandler.h:960

DBHandler::DeferredCopyFromState::copy_params
import_export::CopyParams copy_params
Definition: DBHandler.h:981

DashboardDescriptor
Definition: DashboardDescriptor.h:32

Catalog.h
This file contains the class specification and related data structures for Catalog.

TrackingProcessor
Definition: DBHandler.h:115

DBHandler::render_mutex_
std::mutex render_mutex_
Definition: DBHandler.h:640

DBHandler::max_bytes_for_thrift
static size_t max_bytes_for_thrift()
Definition: DBHandler.h:203

DBHandler::query_states_
query_state::QueryStates query_states_
Definition: DBHandler.h:950

ExtensionFunctionsWhitelist.h
Supported runtime functions management and retrieval.

ExecutionResult
Definition: RelAlgExecutionDescriptor.h:29

DBHandler::reserved_gpu_mem_
const size_t reserved_gpu_mem_
Definition: DBHandler.h:966

import_export::CopyParams
Definition: CopyParams.h:43

DBHandler::DeferredCopyFromSessions::operator()
std::optional< DeferredCopyFromState > operator()(const std::string &session_id)
Definition: DBHandler.h:989

heavydb.connection.ConnectionInfo
tuple ConnectionInfo
Definition: connection.py:21

ParserNode.h
Classes representing a parse tree.

ReservedKeywords.h

DBHandler::render_compositor_use_last_gpu_
const bool render_compositor_use_last_gpu_
Definition: DBHandler.h:967

SystemValidator.h

dbhandler::check_not_info_schema_db
void check_not_info_schema_db(const std::string &db_name, bool throw_db_exception)
Definition: DBHandler.cpp:4620

GetTablesType
GetTablesType
Definition: Catalog.h:63

DBHandler::max_session_duration_
const int max_session_duration_
Definition: DBHandler.h:957

DBHandler::executor_device_type_
ExecutorDeviceType executor_device_type_
Definition: DBHandler.h:630

Logger.h

DBHandler::db_leaves_
std::vector< LeafHostInfo > db_leaves_
Definition: DBHandler.h:626

DBHandler::disk_cache_config_
const File_Namespace::DiskCacheConfig & disk_cache_config_
Definition: DBHandler.h:973

scope.h

DBHandler::clang_path_
const std::string & clang_path_
Definition: DBHandler.h:975

clean_boost_regex.hpp

heavyai::unique_lock
std::unique_lock< T > unique_lock
Definition: heavyai_shared_mutex.h:39

DBHandler::render_handler_
std::unique_ptr< RenderHandler > render_handler_
Definition: DBHandler.h:645

JsonAccessors.h
Checked json field retrieval.

Parser::ShouldInvalidateSessionsByDB
Definition: ParserNode.h:2261

DBHandler::query_engine_
std::shared_ptr< QueryEngine > query_engine_
Definition: DBHandler.h:644

StringTransform.h

DBHandler::system_parameters_
SystemParameters & system_parameters_
Definition: DBHandler.h:643

DBHandler::num_reader_threads_
const size_t num_reader_threads_
Definition: DBHandler.h:969

AuthMetadata
Definition: AuthMetadata.h:21

ColumnDescriptor
specifies the content in-memory of a row in the column metadata table
Definition: ColumnDescriptor.h:33

measure.h

DBHandler::enable_auto_clear_render_mem_
const bool enable_auto_clear_render_mem_
Definition: DBHandler.h:963

DBHandler::renderer_prefer_igpu_
const bool renderer_prefer_igpu_
Definition: DBHandler.h:961

get_device_parameters
std::map< std::string, std::string > get_device_parameters(bool cpu_only)
Definition: NativeCodegen.cpp:910

LeafAggregator.h

dbhandler::is_info_schema_db
bool is_info_schema_db(const std::string &db_name)
Definition: DBHandler.cpp:4615

DBHandler::allow_loop_joins_
const bool allow_loop_joins_
Definition: DBHandler.h:637

QueryState.h

DBHandler::sessions_mutex_
heavyai::shared_mutex sessions_mutex_
Definition: DBHandler.h:639

DBHandler::agg_handler_
std::unique_ptr< HeavyDBAggHandler > agg_handler_
Definition: DBHandler.h:646

DBHandler::custom_expressions_mutex_
heavyai::shared_mutex custom_expressions_mutex_
Definition: DBHandler.h:1109

Execute.h

DBHandler::enable_rendering_
const bool enable_rendering_
Definition: DBHandler.h:959

DBHandler::DeferredCopyFromSessions::was_deferred_copy_from
std::unordered_map< std::string, DeferredCopyFromState > was_deferred_copy_from
Definition: DBHandler.h:986

DBHandler::intel_jit_profile_
const bool intel_jit_profile_
Definition: DBHandler.h:634

DBHandler::super_user_rights_
bool super_user_rights_
Definition: DBHandler.h:953

ConnectionInfo.h

RenderGroupAnalyzer.h

Catalog_Namespace::UserMetadata
Definition: SysCatalog.h:68

DBHandler::calcite_
std::shared_ptr< Calcite > calcite_
Definition: DBHandler.h:648

logger::shutdown
void shutdown()
Definition: Logger.cpp:344

QueryEngine.h

DBHandler::data_mgr_
std::shared_ptr< Data_Namespace::DataMgr > data_mgr_
Definition: DBHandler.h:623

DBHandler::read_only_
const bool read_only_
Definition: DBHandler.h:636

TrackingProcessor::process
bool process(std::shared_ptr<::apache::thrift::protocol::TProtocol > in, std::shared_ptr<::apache::thrift::protocol::TProtocol > out, void *connectionContext) override
Definition: DBHandler.h:120

ClientProtocol::HTTP

SystemParameters.h

CalciteAdapter.h

DBHandler::legacy_syntax_
const bool legacy_syntax_
Definition: DBHandler.h:649

GpuMemUtils.h

Parser::ShouldInvalidateSessionsByUser
Definition: ParserNode.h:2263

RenderHandler::Impl
Definition: RenderHandler.cpp:26

TableGenerations.h

DBHandler::DeferredCopyFromState::file_name
std::string file_name
Definition: DBHandler.h:980

DBHandler::leaf_handler_
std::unique_ptr< HeavyDBLeafHandler > leaf_handler_
Definition: DBHandler.h:647

CHECK
#define CHECK(condition)
Definition: Logger.h:222

logger::query_id
QueryId query_id()
Definition: Logger.cpp:473

SQLTypeInfo
Definition: sqltypes.h:270

DBHandler::idle_session_duration_
const int idle_session_duration_
Definition: DBHandler.h:956

DBHandler
Definition: DBHandler.h:166

HeavyDBAggHandler
Definition: DistributedHandler.h:28

DBHandler::ipc_handle_to_dev_ptr_
std::unordered_map< std::string, std::string > ipc_handle_to_dev_ptr_
Definition: DBHandler.h:1013

LeafAggregator
Definition: LeafAggregator.h:36

DBHandler::render_group_assignment_map_
RenderGroupAnalyzerSessionMap render_group_assignment_map_
Definition: DBHandler.h:1107

ClientProtocol::TCP

DBHandler::max_concurrent_render_sessions_
const size_t max_concurrent_render_sessions_
Definition: DBHandler.h:965

TargetValue
boost::variant< ScalarTargetValue, ArrayTargetValue, GeoTargetValue, GeoTargetValuePtr > TargetValue
Definition: TargetValue.h:165

DBHandler::allow_multifrag_
bool allow_multifrag_
Definition: DBHandler.h:635

TableDescriptor
Definition: TableDescriptor.h:43

setup.name
string name
Definition: setup.in.py:72

heavyai::shared_mutex
std::shared_timed_mutex shared_mutex
Definition: heavyai_shared_mutex.h:31

DBHandler::authMetadata_
const AuthMetadata & authMetadata_
Definition: DBHandler.h:642

Calcite.h

TrackingProcessor::TrackingProcessor
TrackingProcessor(std::shared_ptr< HeavyIf > handler, const bool check_origin)
Definition: DBHandler.h:117

DBHandler::invalidate_sessions
void invalidate_sessions(std::string &name, STMT_TYPE *stmt)
Definition: DBHandler.h:1033

DBHandler::cpu_mode_only_
bool cpu_mode_only_
Definition: DBHandler.h:638

DBHandler::random_gen_
std::default_random_engine random_gen_
Definition: DBHandler.h:631

DBHandler::sessions_
SessionMap sessions_
Definition: DBHandler.h:951

heavyai_shared_mutex.h

DBHandler::session_id_dist_
std::uniform_int_distribution< int64_t > session_id_dist_
Definition: DBHandler.h:632

run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

run_benchmark_import.result
dictionary result
Definition: run_benchmark_import.py:441

ClientProtocol::Other

query_state::QueryStateProxy
Definition: QueryState.h:173