OmniSciDB  a987f07e93
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CommandLineOptions Class Reference

#include <CommandLineOptions.h>

+ Collaboration diagram for CommandLineOptions:

Public Member Functions

 CommandLineOptions (char const *argv0, bool dist_v5_=false)
 
void fillOptions ()
 
void fillAdvancedOptions ()
 
std::string getNodeIds ()
 
std::vector< std::string > getNodeIdsArray ()
 
boost::optional< int > parse_command_line (int argc, char const *const *argv, const bool should_init_logging=false)
 
void validate ()
 
void validate_base_path ()
 
void init_logging ()
 

Public Attributes

int http_port = 6278
 
int http_binary_port = 6276
 
size_t reserved_gpu_mem = 384 * 1024 * 1024
 
std::string base_path
 
File_Namespace::DiskCacheConfig disk_cache_config
 
std::string cluster_file = {"cluster.conf"}
 
std::string cluster_topology_file = {"cluster_topology.conf"}
 
std::string license_path = {""}
 
std::string encryption_key_store_path = {}
 
bool verbose_logging = false
 
bool jit_debug = false
 
bool intel_jit_profile = false
 
bool allow_multifrag = true
 
bool read_only = false
 
bool allow_loop_joins = false
 
bool enable_legacy_syntax = true
 
bool log_user_origin = true
 
AuthMetadata authMetadata
 
SystemParameters system_parameters
 
bool enable_rendering = false
 
bool enable_auto_clear_render_mem = false
 
int render_oom_retry_threshold = 0
 
size_t render_mem_bytes = 1000000000
 
size_t max_concurrent_render_sessions = 500
 
bool render_compositor_use_last_gpu = true
 
bool renderer_use_ppll_polys = false
 
bool renderer_prefer_igpu = false
 
unsigned renderer_vulkan_timeout_ms = 60000
 
bool renderer_use_parallel_executors = true
 
bool enable_watchdog = true
 
bool enable_dynamic_watchdog = false
 
size_t watchdog_none_encoded_string_translation_limit = 1000000
 
bool enable_runtime_query_interrupt = true
 
bool enable_non_kernel_time_query_interrupt = true
 
bool use_estimator_result_cache = true
 
double running_query_interrupt_freq = 0.1
 
unsigned pending_query_interrupt_freq = 1000
 
unsigned dynamic_watchdog_time_limit = 10000
 
std::string disk_cache_level = ""
 
bool enable_data_recycler = true
 
bool use_hashtable_cache = true
 
size_t hashtable_cache_total_bytes = 4294967296
 
size_t max_cacheable_hashtable_size_bytes = 2147483648
 
bool optimize_cuda_block_and_grid_sizes = false
 
size_t num_reader_threads = 0
 
std::string db_query_file = {""}
 
bool exit_after_warmup = false
 
int idle_session_duration = kMinsPerHour
 
int max_session_duration = kMinsPerMonth
 
std::string udf_file_name = {""}
 
std::string udf_compiler_path = {""}
 
std::vector< std::string > udf_compiler_options
 
std::string allowed_import_paths {}
 
std::string allowed_export_paths {}
 
std::string compressor = std::string(BLOSC_LZ4HC_COMPNAME)
 
po::options_description help_desc
 
po::options_description developer_desc
 
logger::LogOptions log_options_
 
std::string exe_name
 
po::positional_options_description positional_options
 
std::vector< LeafHostInfodb_leaves
 
std::vector< LeafHostInfostring_leaves
 
po::variables_map vm
 
std::string clusterIds_arg
 
const bool dist_v5_
 

Static Public Attributes

static const std::string nodeIds_token = {"node_id"}
 

Private Attributes

bool enable_runtime_udfs = true
 
bool enable_runtime_udf = true
 
bool enable_udf_registration_for_all_users = false
 

Detailed Description

Definition at line 40 of file CommandLineOptions.h.

Constructor & Destructor Documentation

CommandLineOptions::CommandLineOptions ( char const *  argv0,
bool  dist_v5_ = false 
)
inline

Definition at line 42 of file CommandLineOptions.h.

References fillAdvancedOptions(), and fillOptions().

43  : log_options_(argv0), exe_name(argv0), dist_v5_(dist_v5_) {
44  fillOptions();
46  }
logger::LogOptions log_options_

+ Here is the call graph for this function:

Member Function Documentation

void CommandLineOptions::fillAdvancedOptions ( )

Definition at line 624 of file CommandLineOptions.cpp.

References g_allow_invalid_literal_buffer_reads, g_allow_query_step_cpu_retry, g_approx_quantile_buffer, g_approx_quantile_centroids, g_bitmap_memory_limit, g_columnar_large_projections, g_columnar_large_projections_threshold, g_cpu_sub_task_size, g_cpu_threads_override, g_enable_assign_render_groups, g_enable_auto_metadata_update, g_enable_automatic_ir_metadata, g_enable_bump_allocator, g_enable_columnar_output, g_enable_cpu_sub_tasks, g_enable_dev_table_functions, g_enable_direct_columnarization, g_enable_filter_function, g_enable_geo_ops_on_uncompressed_coords, g_enable_http_binary_server, g_enable_idp_temporary_users, g_enable_lazy_fetch, g_enable_left_join_filter_hoisting, g_enable_parallel_window_partition_compute, g_enable_parallel_window_partition_sort, g_enable_seconds_refresh, g_enable_smem_group_by, g_enable_smem_grouped_non_count_agg, g_enable_smem_non_grouped_agg, g_enable_window_functions, g_estimator_failure_max_groupby_size, g_fraction_code_cache_to_evict, g_gpu_smem_threshold, g_large_ndv_multiplier, g_large_ndv_threshold, g_max_log_length, g_max_memory_allocation_size, g_min_memory_allocation_size, g_optimize_row_initialization, g_parallel_top_max, g_parallel_top_min, g_query_engine_cuda_streams, g_skip_intermediate_count, g_streaming_topn_max, g_strip_join_covered_quals, g_use_table_device_offset, g_vacuum_min_selectivity, and g_window_function_aggregation_tree_fanout.

Referenced by CommandLineOptions().

624  {
625  developer_desc.add_options()("dev-options", "Print internal developer options.");
626  developer_desc.add_options()(
627  "enable-calcite-view-optimize",
630  ->implicit_value(true),
631  "Enable additional calcite (query plan) optimizations when a view is part of the "
632  "query.");
633  developer_desc.add_options()(
634  "enable-columnar-output",
635  po::value<bool>(&g_enable_columnar_output)
636  ->default_value(g_enable_columnar_output)
637  ->implicit_value(true),
638  "Enable columnar output for intermediate/final query steps.");
639  developer_desc.add_options()(
640  "enable-left-join-filter-hoisting",
641  po::value<bool>(&g_enable_left_join_filter_hoisting)
642  ->default_value(g_enable_left_join_filter_hoisting)
643  ->implicit_value(true),
644  "Enable hoisting left hand side filters through left joins.");
645  developer_desc.add_options()("optimize-row-init",
646  po::value<bool>(&g_optimize_row_initialization)
647  ->default_value(g_optimize_row_initialization)
648  ->implicit_value(true),
649  "Optimize row initialization.");
650  developer_desc.add_options()("enable-legacy-syntax",
651  po::value<bool>(&enable_legacy_syntax)
652  ->default_value(enable_legacy_syntax)
653  ->implicit_value(true),
654  "Enable legacy syntax.");
655  developer_desc.add_options()(
656  "enable-multifrag",
657  po::value<bool>(&allow_multifrag)
658  ->default_value(allow_multifrag)
659  ->implicit_value(true),
660  "Enable execution over multiple fragments in a single round-trip to GPU.");
661  developer_desc.add_options()("enable-lazy-fetch",
662  po::value<bool>(&g_enable_lazy_fetch)
663  ->default_value(g_enable_lazy_fetch)
664  ->implicit_value(true),
665  "Enable lazy fetch columns in query results.");
666  developer_desc.add_options()(
667  "enable-shared-mem-group-by",
668  po::value<bool>(&g_enable_smem_group_by)
669  ->default_value(g_enable_smem_group_by)
670  ->implicit_value(true),
671  "Enable using GPU shared memory for some GROUP BY queries.");
672  developer_desc.add_options()("num-executors",
673  po::value<int>(&system_parameters.num_executors)
674  ->default_value(system_parameters.num_executors),
675  "Number of executors to run in parallel.");
676  developer_desc.add_options()(
677  "gpu-shared-mem-threshold",
678  po::value<size_t>(&g_gpu_smem_threshold)->default_value(g_gpu_smem_threshold),
679  "GPU shared memory threshold (in bytes). If query requires larger buffers than "
680  "this threshold, we disable those optimizations. 0 (default) means no static cap.");
681  developer_desc.add_options()(
682  "enable-shared-mem-grouped-non-count-agg",
683  po::value<bool>(&g_enable_smem_grouped_non_count_agg)
684  ->default_value(g_enable_smem_grouped_non_count_agg)
685  ->implicit_value(true),
686  "Enable using GPU shared memory for grouped non-count aggregate queries.");
687  developer_desc.add_options()(
688  "enable-shared-mem-non-grouped-agg",
689  po::value<bool>(&g_enable_smem_non_grouped_agg)
690  ->default_value(g_enable_smem_non_grouped_agg)
691  ->implicit_value(true),
692  "Enable using GPU shared memory for non-grouped aggregate queries.");
693  developer_desc.add_options()("enable-direct-columnarization",
694  po::value<bool>(&g_enable_direct_columnarization)
695  ->default_value(g_enable_direct_columnarization)
696  ->implicit_value(true),
697  "Enables/disables a more optimized columnarization method "
698  "for intermediate steps in multi-step queries.");
699  developer_desc.add_options()(
700  "offset-device-by-table-id",
701  po::value<bool>(&g_use_table_device_offset)
702  ->default_value(g_use_table_device_offset)
703  ->implicit_value(true),
704  "Enables/disables offseting the chosen device ID by the table ID for a given "
705  "fragment. This improves balance of fragments across GPUs.");
706  developer_desc.add_options()("enable-window-functions",
707  po::value<bool>(&g_enable_window_functions)
708  ->default_value(g_enable_window_functions)
709  ->implicit_value(true),
710  "Enable window function support.");
711  developer_desc.add_options()(
712  "enable-parallel-window-partition-compute",
715  ->implicit_value(true),
716  "Enable parallel window function partition computation.");
717  developer_desc.add_options()(
718  "enable-parallel-window-partition-sort",
721  ->implicit_value(true),
722  "Enable parallel window function partition sorting.");
723  developer_desc.add_options()(
724  "window-function-frame-aggregation-tree-fanout",
725  po::value<size_t>(&g_window_function_aggregation_tree_fanout)->default_value(8),
726  "A tree fanout for aggregation tree used to compute aggregation over "
727  "window frame");
728  developer_desc.add_options()("enable-dev-table-functions",
729  po::value<bool>(&g_enable_dev_table_functions)
730  ->default_value(g_enable_dev_table_functions)
731  ->implicit_value(true),
732  "Enable dev (test or alpha) table functions. Also "
733  "requires --enable-table-functions to be turned on");
734 
735  developer_desc.add_options()(
736  "enable-geo-ops-on-uncompressed-coords",
739  ->implicit_value(true),
740  "Enable faster geo operations on uncompressed coords");
741  developer_desc.add_options()(
742  "jit-debug-ir",
743  po::value<bool>(&jit_debug)->default_value(jit_debug)->implicit_value(true),
744  "Enable runtime debugger support for the JIT. Note that this flag is "
745  "incompatible "
746  "with the `ENABLE_JIT_DEBUG` build flag. The generated code can be found at "
747  "`/tmp/mapdquery`.");
748  developer_desc.add_options()(
749  "intel-jit-profile",
750  po::value<bool>(&intel_jit_profile)
751  ->default_value(intel_jit_profile)
752  ->implicit_value(true),
753  "Enable runtime support for the JIT code profiling using Intel VTune.");
754  developer_desc.add_options()(
755  "enable-cpu-sub-tasks",
756  po::value<bool>(&g_enable_cpu_sub_tasks)
757  ->default_value(g_enable_cpu_sub_tasks)
758  ->implicit_value(true),
759  "Enable parallel processing of a single data fragment on CPU. This can improve CPU "
760  "load balance and decrease reduction overhead.");
761  developer_desc.add_options()(
762  "cpu-sub-task-size",
763  po::value<size_t>(&g_cpu_sub_task_size)->default_value(g_cpu_sub_task_size),
764  "Set CPU sub-task size in rows.");
765  developer_desc.add_options()(
766  "cpu-threads",
767  po::value<unsigned>(&g_cpu_threads_override)->default_value(g_cpu_threads_override),
768  "Set max CPU concurrent threads. Values <= 0 will use default of 2X the number of "
769  "hardware threads.");
770  developer_desc.add_options()(
771  "skip-intermediate-count",
772  po::value<bool>(&g_skip_intermediate_count)
773  ->default_value(g_skip_intermediate_count)
774  ->implicit_value(true),
775  "Skip pre-flight counts for intermediate projections with no filters.");
776  developer_desc.add_options()(
777  "strip-join-covered-quals",
778  po::value<bool>(&g_strip_join_covered_quals)
779  ->default_value(g_strip_join_covered_quals)
780  ->implicit_value(true),
781  "Remove quals from the filtered count if they are covered by a "
782  "join condition (currently only ST_Contains).");
783 
784  developer_desc.add_options()(
785  "min-cpu-slab-size",
786  po::value<size_t>(&system_parameters.min_cpu_slab_size)
787  ->default_value(system_parameters.min_cpu_slab_size),
788  "Min slab size (size of memory allocations) for CPU buffer pool.");
789  developer_desc.add_options()(
790  "max-cpu-slab-size",
791  po::value<size_t>(&system_parameters.max_cpu_slab_size)
792  ->default_value(system_parameters.max_cpu_slab_size),
793  "Max CPU buffer pool slab size (size of memory allocations). Note if "
794  "there is not enough free memory to accomodate the target slab size, smaller "
795  "slabs will be allocated, down to the minimum size specified by "
796  "min-cpu-slab-size.");
797  developer_desc.add_options()(
798  "min-gpu-slab-size",
799  po::value<size_t>(&system_parameters.min_gpu_slab_size)
800  ->default_value(system_parameters.min_gpu_slab_size),
801  "Min slab size (size of memory allocations) for GPU buffer pools.");
802  developer_desc.add_options()(
803  "max-gpu-slab-size",
804  po::value<size_t>(&system_parameters.max_gpu_slab_size)
805  ->default_value(system_parameters.max_gpu_slab_size),
806  "Max GPU buffer pool slab size (size of memory allocations). Note if "
807  "there is not enough free memory to accomodate the target slab size, smaller "
808  "slabs will be allocated, down to the minimum size speified by "
809  "min-gpu-slab-size.");
810 
811  developer_desc.add_options()(
812  "max-output-projection-allocation-bytes",
813  po::value<size_t>(&g_max_memory_allocation_size)
814  ->default_value(g_max_memory_allocation_size),
815  "Maximum allocation size for a fixed output buffer allocation for projection "
816  "queries with no pre-flight count. Default is the maximum slab size (sizes "
817  "greater "
818  "than the maximum slab size have no affect). Requires bump allocator.");
819  developer_desc.add_options()(
820  "min-output-projection-allocation-bytes",
821  po::value<size_t>(&g_min_memory_allocation_size)
822  ->default_value(g_min_memory_allocation_size),
823  "Minimum allocation size for a fixed output buffer allocation for projection "
824  "queries with no pre-flight count. If an allocation of this size cannot be "
825  "obtained, the query will be retried with different execution parameters and/or "
826  "on "
827  "CPU (if allow-cpu-retry is enabled). Requires bump allocator.");
828  developer_desc.add_options()("enable-bump-allocator",
829  po::value<bool>(&g_enable_bump_allocator)
830  ->default_value(g_enable_bump_allocator)
831  ->implicit_value(true),
832  "Enable the bump allocator for projection queries on "
833  "GPU. The bump allocator will "
834  "allocate a fixed size buffer for each query, track the "
835  "number of rows passing the "
836  "kernel during query execution, and copy back only the "
837  "rows that passed the kernel "
838  "to CPU after execution. When disabled, pre-flight "
839  "count queries are used to size "
840  "the output buffer for projection queries.");
841  developer_desc.add_options()(
842  "code-cache-eviction-percent",
843  po::value<float>(&g_fraction_code_cache_to_evict)
844  ->default_value(g_fraction_code_cache_to_evict),
845  "Percentage of the GPU code cache to evict if an out of memory error is "
846  "encountered while attempting to place generated code on the GPU.");
847 
848  developer_desc.add_options()("ssl-cert",
849  po::value<std::string>(&system_parameters.ssl_cert_file)
850  ->default_value(std::string("")),
851  "SSL Validated public certficate.");
852 
853  developer_desc.add_options()("ssl-private-key",
854  po::value<std::string>(&system_parameters.ssl_key_file)
855  ->default_value(std::string("")),
856  "SSL private key file.");
857  // Note ssl_trust_store is passed through to Calcite via system_parameters
858  // todo(jack): add ensure ssl-trust-store exists if cert and private key in use
859  developer_desc.add_options()("ssl-trust-store",
860  po::value<std::string>(&system_parameters.ssl_trust_store)
861  ->default_value(std::string("")),
862  "SSL public CA certifcates (java trust store) to validate "
863  "TLS connections (passed through to the Calcite server).");
864 
865  developer_desc.add_options()(
866  "ssl-trust-password",
867  po::value<std::string>(&system_parameters.ssl_trust_password)
868  ->default_value(std::string("")),
869  "SSL password for java trust store provided via --ssl-trust-store parameter.");
870 
871  developer_desc.add_options()(
872  "ssl-trust-ca",
873  po::value<std::string>(&system_parameters.ssl_trust_ca_file)
874  ->default_value(std::string("")),
875  "SSL public CA certificates to validate TLS connection(as a client).");
876 
877  developer_desc.add_options()(
878  "ssl-trust-ca-server",
879  po::value<std::string>(&authMetadata.ca_file_name)->default_value(std::string("")),
880  "SSL public CA certificates to validate TLS connection(as a server).");
881 
882  developer_desc.add_options()("ssl-keystore",
883  po::value<std::string>(&system_parameters.ssl_keystore)
884  ->default_value(std::string("")),
885  "SSL server credentials as a java key store (passed "
886  "through to the Calcite server).");
887 
888  developer_desc.add_options()(
889  "ssl-keystore-password",
890  po::value<std::string>(&system_parameters.ssl_keystore_password)
891  ->default_value(std::string("")),
892  "SSL password for java keystore, provide by via --ssl-keystore.");
893 
894  developer_desc.add_options()(
895  "udf",
896  po::value<std::string>(&udf_file_name),
897  "Load user defined extension functions from this file at startup. The file is "
898  "expected to be a C/C++ file with extension .cpp.");
899 
900  developer_desc.add_options()(
901  "udf-compiler-path",
902  po::value<std::string>(&udf_compiler_path),
903  "Provide absolute path to clang++ used in udf compilation.");
904 
905  developer_desc.add_options()("udf-compiler-options",
906  po::value<std::vector<std::string>>(&udf_compiler_options),
907  "Specify compiler options to tailor udf compilation.");
908 
909 #ifdef ENABLE_GEOS
910  developer_desc.add_options()("libgeos-so-filename",
911  po::value<std::string>(&libgeos_so_filename),
912  "Specify libgeos shared object filename to be used for "
913  "geos-backed geo opertations.");
914 #endif
915  developer_desc.add_options()(
916  "large-ndv-threshold",
917  po::value<int64_t>(&g_large_ndv_threshold)->default_value(g_large_ndv_threshold));
918  developer_desc.add_options()(
919  "large-ndv-multiplier",
920  po::value<size_t>(&g_large_ndv_multiplier)->default_value(g_large_ndv_multiplier));
921  developer_desc.add_options()("approx_quantile_buffer",
922  po::value<size_t>(&g_approx_quantile_buffer)
923  ->default_value(g_approx_quantile_buffer));
924  developer_desc.add_options()("approx_quantile_centroids",
925  po::value<size_t>(&g_approx_quantile_centroids)
926  ->default_value(g_approx_quantile_centroids));
927  developer_desc.add_options()(
928  "bitmap-memory-limit",
929  po::value<int64_t>(&g_bitmap_memory_limit)->default_value(g_bitmap_memory_limit),
930  "Limit for count distinct bitmap memory use. The limit is computed by taking the "
931  "size of the group by buffer (entry count in Query Memory Descriptor) and "
932  "multiplying it by the number of count distinct expression and the size of bitmap "
933  "required for each. For approx_count_distinct this is typically 8192 bytes.");
934  developer_desc.add_options()(
935  "enable-filter-function",
936  po::value<bool>(&g_enable_filter_function)
937  ->default_value(g_enable_filter_function)
938  ->implicit_value(true),
939  "Enable the filter function protection feature for the SQL JIT compiler. "
940  "Normally should be on but techs might want to disable for troubleshooting.");
941  developer_desc.add_options()(
942  "enable-idp-temporary-users",
943  po::value<bool>(&g_enable_idp_temporary_users)
944  ->default_value(g_enable_idp_temporary_users)
945  ->implicit_value(true),
946  "Enable temporary users for SAML and LDAP logins on read-only servers. "
947  "Normally should be on but techs might want to disable for troubleshooting.");
948  developer_desc.add_options()(
949  "enable-seconds-refresh-interval",
950  po::value<bool>(&g_enable_seconds_refresh)
951  ->default_value(g_enable_seconds_refresh)
952  ->implicit_value(true),
953  "Enable foreign table seconds refresh interval for testing purposes.");
954  developer_desc.add_options()("enable-auto-metadata-update",
955  po::value<bool>(&g_enable_auto_metadata_update)
956  ->default_value(g_enable_auto_metadata_update)
957  ->implicit_value(true),
958  "Enable automatic metadata update.");
959  developer_desc.add_options()(
960  "parallel-top-min",
961  po::value<size_t>(&g_parallel_top_min)->default_value(g_parallel_top_min),
962  "For ResultSets requiring a heap sort, the number of rows necessary to trigger "
963  "parallelTop() to sort.");
964  developer_desc.add_options()(
965  "parallel-top-max",
966  po::value<size_t>(&g_parallel_top_max)->default_value(g_parallel_top_max),
967  "For ResultSets requiring a heap sort, the maximum number of rows allowed by "
968  "watchdog.");
969  developer_desc.add_options()(
970  "streaming-top-n-max",
971  po::value<size_t>(&g_streaming_topn_max)->default_value(g_streaming_topn_max),
972  "The maximum number of rows allowing streaming top-N sorting.");
973  developer_desc.add_options()("vacuum-min-selectivity",
974  po::value<float>(&g_vacuum_min_selectivity)
975  ->default_value(g_vacuum_min_selectivity),
976  "Minimum selectivity for automatic vacuuming. "
977  "This specifies the percentage (with a value of 0 "
978  "implying 0% and a value of 1 implying 100%) of "
979  "deleted rows in a fragment at which to perform "
980  "automatic vacuuming. A number greater than 1 can "
981  "be used to disable automatic vacuuming.");
982  developer_desc.add_options()("enable-automatic-ir-metadata",
983  po::value<bool>(&g_enable_automatic_ir_metadata)
984  ->default_value(g_enable_automatic_ir_metadata)
985  ->implicit_value(true),
986  "Enable automatic IR metadata (debug builds only).");
987  developer_desc.add_options()(
988  "max-log-length",
989  po::value<size_t>(&g_max_log_length)->default_value(g_max_log_length),
990  "The maximum number of characters that a log message can has. If the log message "
991  "is longer than this, we only record \'g_max_log_message_length\' characters.");
992  developer_desc.add_options()(
993  "estimator-failure-max-groupby-size",
994  po::value<size_t>(&g_estimator_failure_max_groupby_size)
995  ->default_value(g_estimator_failure_max_groupby_size),
996  "Maximum size of the groupby buffer if the estimator fails. By default we use the "
997  "number of tuples in the table up to this value.");
998  developer_desc.add_options()("columnar-large-projections",
999  po::value<bool>(&g_columnar_large_projections)
1000  ->default_value(g_columnar_large_projections)
1001  ->implicit_value(true),
1002  "Prefer columnar output if projection size is >= "
1003  "threshold set by --columnar-large-projections-threshold "
1004  "(default 1,000,000 rows).");
1005  developer_desc.add_options()(
1006  "columnar-large-projections-threshold",
1007  po::value<size_t>(&g_columnar_large_projections_threshold)
1008  ->default_value(g_columnar_large_projections_threshold),
1009  "Threshold (in minimum number of rows) to prefer columnar output for projections. "
1010  "Requires --columnar-large-projections to be set.");
1011 
1012  help_desc.add_options()(
1013  "allow-query-step-cpu-retry",
1014  po::value<bool>(&g_allow_query_step_cpu_retry)
1015  ->default_value(g_allow_query_step_cpu_retry)
1016  ->implicit_value(true),
1017  R"(Allow certain query steps to retry on CPU, even when allow-cpu-retry is disabled)");
1018  help_desc.add_options()("enable-http-binary-server",
1019  po::value<bool>(&g_enable_http_binary_server)
1020  ->default_value(g_enable_http_binary_server)
1021  ->implicit_value(true),
1022  "Enable binary over HTTP Thrift server");
1023 
1024  help_desc.add_options()("enable-assign-render-groups",
1025  po::value<bool>(&g_enable_assign_render_groups)
1026  ->default_value(g_enable_assign_render_groups)
1027  ->implicit_value(true),
1028  "Enable Render Group assignment");
1029 
1030  help_desc.add_options()("enable-query-engine-cuda-streams",
1031  po::value<bool>(&g_query_engine_cuda_streams)
1032  ->default_value(g_query_engine_cuda_streams)
1033  ->implicit_value(true),
1034  "Enable Query Engine CUDA streams");
1035 
1036  help_desc.add_options()(
1037  "allow-invalid-literal-buffer-reads",
1038  po::value<bool>(&g_allow_invalid_literal_buffer_reads)
1039  ->default_value(g_allow_invalid_literal_buffer_reads)
1040  ->implicit_value(true),
1041  "For backwards compatibility. Enabling may cause invalid query results.");
1042 }
int64_t g_large_ndv_threshold
bool g_use_table_device_offset
bool g_enable_parallel_window_partition_sort
bool g_enable_left_join_filter_hoisting
Definition: Execute.cpp:100
bool g_enable_smem_group_by
size_t g_parallel_top_max
Definition: ResultSet.cpp:50
size_t g_cpu_sub_task_size
Definition: Execute.cpp:83
bool g_strip_join_covered_quals
Definition: Execute.cpp:107
bool g_enable_direct_columnarization
Definition: Execute.cpp:122
bool g_enable_lazy_fetch
Definition: Execute.cpp:124
std::string udf_compiler_path
bool g_skip_intermediate_count
po::options_description help_desc
bool enable_calcite_view_optimize
unsigned g_cpu_threads_override
bool g_enable_auto_metadata_update
size_t g_streaming_topn_max
Definition: ResultSet.cpp:51
bool g_enable_geo_ops_on_uncompressed_coords
Definition: Execute.cpp:114
bool g_enable_smem_non_grouped_agg
Definition: Execute.cpp:138
size_t g_parallel_top_min
Definition: ResultSet.cpp:49
std::string ssl_trust_ca_file
bool g_enable_columnar_output
Definition: Execute.cpp:99
std::string ssl_trust_store
bool g_enable_idp_temporary_users
Definition: SysCatalog.cpp:63
size_t g_window_function_aggregation_tree_fanout
bool g_enable_assign_render_groups
bool g_enable_http_binary_server
int64_t g_bitmap_memory_limit
size_t g_max_memory_allocation_size
Definition: Execute.cpp:116
size_t g_approx_quantile_buffer
Definition: Execute.cpp:159
size_t g_max_log_length
Definition: Execute.cpp:164
bool g_enable_dev_table_functions
Definition: Execute.cpp:113
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
bool g_enable_window_functions
Definition: Execute.cpp:111
size_t g_min_memory_allocation_size
Definition: Execute.cpp:117
bool g_enable_seconds_refresh
size_t g_estimator_failure_max_groupby_size
bool g_enable_smem_grouped_non_count_agg
Definition: Execute.cpp:135
bool g_enable_automatic_ir_metadata
Definition: Execute.cpp:162
std::vector< std::string > udf_compiler_options
float g_vacuum_min_selectivity
bool g_enable_filter_function
Definition: Execute.cpp:84
float g_fraction_code_cache_to_evict
bool g_allow_invalid_literal_buffer_reads
Definition: ConstantIR.cpp:140
std::string ssl_keystore_password
std::string ssl_trust_password
bool g_enable_bump_allocator
Definition: Execute.cpp:120
bool g_enable_parallel_window_partition_compute
bool g_enable_cpu_sub_tasks
Definition: Execute.cpp:82
std::string ssl_keystore
bool g_allow_query_step_cpu_retry
Definition: Execute.cpp:87
size_t g_approx_quantile_centroids
Definition: Execute.cpp:160
po::options_description developer_desc
bool g_optimize_row_initialization
Definition: Execute.cpp:101
bool g_columnar_large_projections
size_t g_columnar_large_projections_threshold
bool g_query_engine_cuda_streams
Definition: QueryEngine.h:9
size_t g_large_ndv_multiplier
SystemParameters system_parameters
size_t g_gpu_smem_threshold
Definition: Execute.cpp:130
std::string ssl_cert_file

+ Here is the caller graph for this function:

void CommandLineOptions::fillOptions ( )

Definition at line 95 of file CommandLineOptions.cpp.

References g_allow_auto_resultset_caching, g_allow_cpu_retry, g_allow_query_step_skipping, g_allow_s3_server_privileges, g_auto_resultset_caching_threshold, g_bigint_count, g_cache_string_hash, g_enable_add_metadata_columns, g_enable_debug_timer, g_enable_distance_rangejoin, g_enable_filter_push_down, g_enable_fsi, g_enable_fsi_regex_import, g_enable_hashjoin_many_to_many, g_enable_interop, g_enable_legacy_delimited_import, g_enable_logs_system_tables, g_enable_overlaps_hashjoin, g_enable_string_functions, g_enable_stringdict_parallel, g_enable_system_tables, g_enable_table_functions, g_enable_thrift_logs, g_enable_union, g_filter_push_down_high_frac, g_filter_push_down_low_frac, g_filter_push_down_passing_row_ubound, g_from_table_reordering, g_hll_precision_bits, g_inner_join_fragment_skipping, Catalog_Namespace::g_log_user_id, g_logs_system_tables_max_files_count, g_max_cacheable_query_resultset_size_bytes, g_max_import_threads, g_null_div_by_zero, g_overlaps_max_table_size_bytes, g_overlaps_target_entries_per_bin, g_pmem_path, g_pmem_size, g_query_resultset_cache_total_bytes, g_trivial_loop_join_threshold, g_uniform_request_ids_per_thrift_call, g_use_chunk_metadata_cache, g_use_query_resultset_cache, and run_benchmark_import::required.

Referenced by CommandLineOptions().

95  {
96  help_desc.add_options()("help,h", "Show available options.");
97  help_desc.add_options()(
98  "allow-cpu-retry",
99  po::value<bool>(&g_allow_cpu_retry)
100  ->default_value(g_allow_cpu_retry)
101  ->implicit_value(true),
102  R"(Allow the queries which failed on GPU to retry on CPU, even when watchdog is enabled.)");
103  help_desc.add_options()("allow-loop-joins",
104  po::value<bool>(&allow_loop_joins)
105  ->default_value(allow_loop_joins)
106  ->implicit_value(true),
107  "Enable loop joins.");
108  help_desc.add_options()("bigint-count",
109  po::value<bool>(&g_bigint_count)
110  ->default_value(g_bigint_count)
111  ->implicit_value(true),
112  "Use 64-bit count.");
113  help_desc.add_options()("calcite-max-mem",
114  po::value<size_t>(&system_parameters.calcite_max_mem)
115  ->default_value(system_parameters.calcite_max_mem),
116  "Max memory available to calcite JVM.");
117  if (!dist_v5_) {
118  help_desc.add_options()("calcite-port",
119  po::value<int>(&system_parameters.calcite_port)
120  ->default_value(system_parameters.calcite_port),
121  "Calcite port number.");
122  }
123  help_desc.add_options()("config",
124  po::value<std::string>(&system_parameters.config_file),
125  "Path to server configuration file.");
126  help_desc.add_options()("cpu-buffer-mem-bytes",
127  po::value<size_t>(&system_parameters.cpu_buffer_mem_bytes)
128  ->default_value(system_parameters.cpu_buffer_mem_bytes),
129  "Size of memory reserved for CPU buffers, in bytes.");
130 
131  help_desc.add_options()("cpu-only",
132  po::value<bool>(&system_parameters.cpu_only)
133  ->default_value(system_parameters.cpu_only)
134  ->implicit_value(true),
135  "Run on CPU only, even if GPUs are available.");
136  help_desc.add_options()("cuda-block-size",
137  po::value<size_t>(&system_parameters.cuda_block_size)
138  ->default_value(system_parameters.cuda_block_size),
139  "Size of block to use on NVIDIA GPU.");
140  help_desc.add_options()("cuda-grid-size",
141  po::value<size_t>(&system_parameters.cuda_grid_size)
142  ->default_value(system_parameters.cuda_grid_size),
143  "Size of grid to use on NVIDIA GPU.");
144  help_desc.add_options()("optimize-cuda-block-and-grid-sizes",
145  po::value<bool>(&optimize_cuda_block_and_grid_sizes)
146  ->default_value(false)
147  ->implicit_value(true));
148  if (!dist_v5_) {
149  help_desc.add_options()(
150  "data",
151  po::value<std::string>(&base_path)->required()->default_value("storage"),
152  "Directory path to HeavyDB data storage (catalogs, raw data, log files, etc).");
153  positional_options.add("data", 1);
154  }
155  help_desc.add_options()("db-query-list",
156  po::value<std::string>(&db_query_file),
157  "Path to file containing HeavyDB warmup queries.");
158  help_desc.add_options()(
159  "exit-after-warmup",
160  po::value<bool>(&exit_after_warmup)->default_value(false)->implicit_value(true),
161  "Exit after HeavyDB warmup queries.");
162  help_desc.add_options()("dynamic-watchdog-time-limit",
163  po::value<unsigned>(&dynamic_watchdog_time_limit)
164  ->default_value(dynamic_watchdog_time_limit)
165  ->implicit_value(10000),
166  "Dynamic watchdog time limit, in milliseconds.");
167  help_desc.add_options()("enable-data-recycler",
168  po::value<bool>(&enable_data_recycler)
169  ->default_value(enable_data_recycler)
170  ->implicit_value(true),
171  "Use data recycler.");
172  help_desc.add_options()("use-hashtable-cache",
173  po::value<bool>(&use_hashtable_cache)
174  ->default_value(use_hashtable_cache)
175  ->implicit_value(true),
176  "Use hashtable cache.");
177  help_desc.add_options()("use-query-resultset-cache",
178  po::value<bool>(&g_use_query_resultset_cache)
179  ->default_value(g_use_query_resultset_cache)
180  ->implicit_value(true),
181  "Use query resultset cache.");
182  help_desc.add_options()("use-chunk-metadata-cache",
183  po::value<bool>(&g_use_chunk_metadata_cache)
184  ->default_value(g_use_chunk_metadata_cache)
185  ->implicit_value(true),
186  "Use chunk metadata cache.");
187  help_desc.add_options()(
188  "hashtable-cache-total-bytes",
189  po::value<size_t>(&hashtable_cache_total_bytes)
190  ->default_value(hashtable_cache_total_bytes)
191  ->implicit_value(4294967296),
192  "Size of total memory space for hashtable cache, in bytes (default: 4GB).");
193  help_desc.add_options()("max-cacheable-hashtable-size-bytes",
194  po::value<size_t>(&max_cacheable_hashtable_size_bytes)
195  ->default_value(max_cacheable_hashtable_size_bytes)
196  ->implicit_value(2147483648),
197  "The maximum size of hashtable that is available to cache, in "
198  "bytes (default: 2GB).");
199  help_desc.add_options()(
200  "query-resultset-cache-total-bytes",
201  po::value<size_t>(&g_query_resultset_cache_total_bytes)
202  ->default_value(g_query_resultset_cache_total_bytes),
203  "Size of total memory space for query resultset cache, in bytes (default: 4GB).");
204  help_desc.add_options()(
205  "max-query-resultset-size-bytes",
208  "The maximum size of query resultset that is available to cache, in "
209  "bytes (default: 2GB).");
210  help_desc.add_options()("allow-auto-query-resultset-caching",
211  po::value<bool>(&g_allow_auto_resultset_caching)
212  ->default_value(g_allow_auto_resultset_caching)
213  ->implicit_value(true),
214  "Allow automatic query resultset caching when the size of "
215  "query resultset is smaller or equal to the threshold defined "
216  "by `auto-resultset-caching-threshold-bytes`, in bytes (to "
217  "enable this, query resultset recycler "
218  "should be enabled, default: 1048576 bytes (or 1MB)).");
219  help_desc.add_options()(
220  "auto-resultset-caching-threshold-bytes",
221  po::value<size_t>(&g_auto_resultset_caching_threshold)
222  ->default_value(g_auto_resultset_caching_threshold),
223  "A threshold that allows caching query resultset automatically if the size of "
224  "resultset is less than it, in bytes (default: 1MB).");
225  help_desc.add_options()("allow-query-step-skipping",
226  po::value<bool>(&g_allow_query_step_skipping)
227  ->default_value(g_allow_query_step_skipping)
228  ->implicit_value(true),
229  "Allow query step skipping when multi-step query has at least "
230  "one cached query resultset.");
231  help_desc.add_options()("enable-debug-timer",
232  po::value<bool>(&g_enable_debug_timer)
233  ->default_value(g_enable_debug_timer)
234  ->implicit_value(true),
235  "Enable debug timer logging.");
236  help_desc.add_options()("enable-dynamic-watchdog",
237  po::value<bool>(&enable_dynamic_watchdog)
238  ->default_value(enable_dynamic_watchdog)
239  ->implicit_value(true),
240  "Enable dynamic watchdog.");
241  help_desc.add_options()("enable-filter-push-down",
242  po::value<bool>(&g_enable_filter_push_down)
243  ->default_value(g_enable_filter_push_down)
244  ->implicit_value(true),
245  "Enable filter push down through joins.");
246  help_desc.add_options()("enable-overlaps-hashjoin",
247  po::value<bool>(&g_enable_overlaps_hashjoin)
248  ->default_value(g_enable_overlaps_hashjoin)
249  ->implicit_value(true),
250  "Enable the overlaps hash join framework allowing for range "
251  "join (e.g. spatial overlaps) computation using a hash table.");
252  help_desc.add_options()("enable-hashjoin-many-to-many",
253  po::value<bool>(&g_enable_hashjoin_many_to_many)
254  ->default_value(g_enable_hashjoin_many_to_many)
255  ->implicit_value(true),
256  "Enable the overlaps hash join framework allowing for range "
257  "join (e.g. spatial overlaps) computation using a hash table.");
258  help_desc.add_options()("enable-distance-rangejoin",
259  po::value<bool>(&g_enable_distance_rangejoin)
260  ->default_value(g_enable_distance_rangejoin)
261  ->implicit_value(true),
262  "Enable accelerating point distance joins with a hash table. "
263  "This rewrites ST_Distance when using an upperbound (<= X).");
264  help_desc.add_options()("enable-runtime-query-interrupt",
265  po::value<bool>(&enable_runtime_query_interrupt)
266  ->default_value(enable_runtime_query_interrupt)
267  ->implicit_value(true),
268  "Enable runtime query interrupt.");
269  help_desc.add_options()("enable-non-kernel-time-query-interrupt",
272  ->implicit_value(true),
273  "Enable non-kernel time query interrupt.");
274  help_desc.add_options()("pending-query-interrupt-freq",
275  po::value<unsigned>(&pending_query_interrupt_freq)
276  ->default_value(pending_query_interrupt_freq)
277  ->implicit_value(1000),
278  "A frequency of checking the request of pending query "
279  "interrupt from user (in millisecond).");
280  help_desc.add_options()(
281  "running-query-interrupt-freq",
282  po::value<double>(&running_query_interrupt_freq)
283  ->default_value(running_query_interrupt_freq)
284  ->implicit_value(0.5),
285  "A frequency of checking the request of running query "
286  "interrupt from user (0.0 (less frequent) ~ (more frequent) 1.0).");
287  help_desc.add_options()("use-estimator-result-cache",
288  po::value<bool>(&use_estimator_result_cache)
289  ->default_value(use_estimator_result_cache)
290  ->implicit_value(true),
291  "Use estimator result cache.");
292  if (!dist_v5_) {
293  help_desc.add_options()(
294  "enable-string-dict-hash-cache",
295  po::value<bool>(&g_cache_string_hash)
296  ->default_value(g_cache_string_hash)
297  ->implicit_value(true),
298  "Cache string hash values in the string dictionary server during import.");
299  }
300  help_desc.add_options()(
301  "enable-thrift-logs",
302  po::value<bool>(&g_enable_thrift_logs)
303  ->default_value(g_enable_thrift_logs)
304  ->implicit_value(true),
305  "Enable writing messages directly from thrift to stdout/stderr.");
306  help_desc.add_options()("enable-watchdog",
307  po::value<bool>(&enable_watchdog)
308  ->default_value(enable_watchdog)
309  ->implicit_value(true),
310  "Enable watchdog.");
311  help_desc.add_options()(
312  "watchdog-none-encoded-string-translation-limit",
315  "Max number of none-encoded strings allowed to be translated "
316  "to dictionary-encoded with watchdog enabled");
317  help_desc.add_options()(
318  "filter-push-down-low-frac",
319  po::value<float>(&g_filter_push_down_low_frac)
320  ->default_value(g_filter_push_down_low_frac)
321  ->implicit_value(g_filter_push_down_low_frac),
322  "Lower threshold for selectivity of filters that are pushed down.");
323  help_desc.add_options()(
324  "filter-push-down-high-frac",
325  po::value<float>(&g_filter_push_down_high_frac)
326  ->default_value(g_filter_push_down_high_frac)
327  ->implicit_value(g_filter_push_down_high_frac),
328  "Higher threshold for selectivity of filters that are pushed down.");
329  help_desc.add_options()("filter-push-down-passing-row-ubound",
330  po::value<size_t>(&g_filter_push_down_passing_row_ubound)
332  ->implicit_value(g_filter_push_down_passing_row_ubound),
333  "Upperbound on the number of rows that should pass the filter "
334  "if the selectivity is less than "
335  "the high fraction threshold.");
336  help_desc.add_options()("from-table-reordering",
337  po::value<bool>(&g_from_table_reordering)
338  ->default_value(g_from_table_reordering)
339  ->implicit_value(true),
340  "Enable automatic table reordering in FROM clause.");
341  help_desc.add_options()("gpu-buffer-mem-bytes",
342  po::value<size_t>(&system_parameters.gpu_buffer_mem_bytes)
343  ->default_value(system_parameters.gpu_buffer_mem_bytes),
344  "Size of memory reserved for GPU buffers, in bytes, per GPU.");
345  help_desc.add_options()("gpu-input-mem-limit",
346  po::value<double>(&system_parameters.gpu_input_mem_limit)
347  ->default_value(system_parameters.gpu_input_mem_limit),
348  "Force query to CPU when input data memory usage exceeds this "
349  "percentage of available GPU memory.");
350  help_desc.add_options()(
351  "hll-precision-bits",
352  po::value<int>(&g_hll_precision_bits)
353  ->default_value(g_hll_precision_bits)
354  ->implicit_value(g_hll_precision_bits),
355  "Number of bits used from the hash value used to specify the bucket number.");
356  if (!dist_v5_) {
357  help_desc.add_options()("http-port",
358  po::value<int>(&http_port)->default_value(http_port),
359  "HTTP port number.");
360  help_desc.add_options()(
361  "http-binary-port",
362  po::value<int>(&http_binary_port)->default_value(http_binary_port),
363  "HTTP binary port number.");
364  }
365  help_desc.add_options()(
366  "idle-session-duration",
367  po::value<int>(&idle_session_duration)->default_value(idle_session_duration),
368  "Maximum duration of idle session.");
369  help_desc.add_options()("inner-join-fragment-skipping",
370  po::value<bool>(&g_inner_join_fragment_skipping)
371  ->default_value(g_inner_join_fragment_skipping)
372  ->implicit_value(true),
373  "Enable/disable inner join fragment skipping. This feature is "
374  "considered stable and is enabled by default. This "
375  "parameter will be removed in a future release.");
376  help_desc.add_options()(
377  "max-session-duration",
378  po::value<int>(&max_session_duration)->default_value(max_session_duration),
379  "Maximum duration of active session.");
380  help_desc.add_options()("num-sessions",
381  po::value<int>(&system_parameters.num_sessions)
382  ->default_value(system_parameters.num_sessions),
383  "Maximum number of active session.");
384  help_desc.add_options()(
385  "null-div-by-zero",
386  po::value<bool>(&g_null_div_by_zero)
387  ->default_value(g_null_div_by_zero)
388  ->implicit_value(true),
389  "Return null on division by zero instead of throwing an exception.");
390  help_desc.add_options()(
391  "num-reader-threads",
392  po::value<size_t>(&num_reader_threads)->default_value(num_reader_threads),
393  "Number of reader threads to use.");
394  help_desc.add_options()(
395  "max-import-threads",
396  po::value<size_t>(&g_max_import_threads)->default_value(g_max_import_threads),
397  "Max number of default import threads to use (num hardware threads will be used "
398  "instead if lower). Can be overriden with copy statement threads option).");
399  help_desc.add_options()(
400  "overlaps-max-table-size-bytes",
401  po::value<size_t>(&g_overlaps_max_table_size_bytes)
402  ->default_value(g_overlaps_max_table_size_bytes),
403  "The maximum size in bytes of the hash table for an overlaps hash join.");
404  help_desc.add_options()("overlaps-target-entries-per-bin",
405  po::value<double>(&g_overlaps_target_entries_per_bin)
406  ->default_value(g_overlaps_target_entries_per_bin),
407  "The target number of hash entries per bin for overlaps join");
408  if (!dist_v5_) {
409  help_desc.add_options()("port,p",
410  po::value<int>(&system_parameters.omnisci_server_port)
411  ->default_value(system_parameters.omnisci_server_port),
412  "TCP Port number.");
413  }
414  help_desc.add_options()("num-gpus",
415  po::value<int>(&system_parameters.num_gpus)
416  ->default_value(system_parameters.num_gpus),
417  "Number of gpus to use.");
418  help_desc.add_options()(
419  "read-only",
420  po::value<bool>(&read_only)->default_value(read_only)->implicit_value(true),
421  "Enable read-only mode.");
422 
423  help_desc.add_options()(
424  "res-gpu-mem",
425  po::value<size_t>(&reserved_gpu_mem)->default_value(reserved_gpu_mem),
426  "Reduces GPU memory available to the HeavyDB allocator by this amount. Used for "
427  "compiled code cache and ancillary GPU functions and other processes that may also "
428  "be using the GPU concurrent with HeavyDB.");
429 
430  help_desc.add_options()("start-gpu",
431  po::value<int>(&system_parameters.start_gpu)
432  ->default_value(system_parameters.start_gpu),
433  "First gpu to use.");
434  help_desc.add_options()("trivial-loop-join-threshold",
435  po::value<unsigned>(&g_trivial_loop_join_threshold)
436  ->default_value(g_trivial_loop_join_threshold)
437  ->implicit_value(1000),
438  "The maximum number of rows in the inner table of a loop join "
439  "considered to be trivially small.");
440  help_desc.add_options()(
441  "uniform-request-ids-per-thrift-call",
442  po::value<bool>(&g_uniform_request_ids_per_thrift_call)
444  ->implicit_value(true),
445  "If true (default) then assign the same request_id to thrift calls that were "
446  "initiated by the same external thrift call. If false then assign different "
447  "request_ids and log the parent/child relationships.");
448  help_desc.add_options()("verbose",
449  po::value<bool>(&verbose_logging)
450  ->default_value(verbose_logging)
451  ->implicit_value(true),
452  "Write additional debug log messages to server logs.");
453  help_desc.add_options()(
454  "enable-runtime-udf",
455  po::value<bool>(&enable_runtime_udf)
456  ->default_value(enable_runtime_udf)
457  ->implicit_value(true),
458  "DEPRECATED. Please use `enable-runtime-udfs` instead as this flag will be removed "
459  "in the near future.");
460  help_desc.add_options()(
461  "enable-runtime-udfs",
462  po::value<bool>(&enable_runtime_udfs)
463  ->default_value(enable_runtime_udfs)
464  ->implicit_value(true),
465  "Enable runtime UDF registration by passing signatures and corresponding LLVM IR "
466  "to the `register_runtime_udf` endpoint. For use with the Python Remote Backend "
467  "Compiler server, packaged separately.");
468  help_desc.add_options()("enable-udf-registration-for-all-users",
469  po::value<bool>(&enable_udf_registration_for_all_users)
471  ->implicit_value(true),
472  "Allow all users, not just superusers, to register runtime "
473  "UDFs/UDTFs. Option only valid if "
474  "`--enable-runtime-udfs` is set to true.");
475  help_desc.add_options()("version,v", "Print Version Number.");
476  help_desc.add_options()("enable-string-functions",
477  po::value<bool>(&g_enable_string_functions)
478  ->default_value(g_enable_string_functions)
479  ->implicit_value(true),
480  "Enable experimental string functions.");
481  help_desc.add_options()("enable-experimental-string-functions",
482  po::value<bool>(&g_enable_string_functions)
483  ->default_value(g_enable_string_functions)
484  ->implicit_value(true),
485  "DEPRECATED. String functions are now enabled by default, "
486  "but can still be controlled with --enable-string-functions.");
487  help_desc.add_options()(
488  "enable-fsi",
489  po::value<bool>(&g_enable_fsi)->default_value(g_enable_fsi)->implicit_value(true),
490  "Enable foreign storage interface.");
491 
492  help_desc.add_options()("enable-legacy-delimited-import",
493  po::value<bool>(&g_enable_legacy_delimited_import)
494  ->default_value(g_enable_legacy_delimited_import)
495  ->implicit_value(true),
496  "Use legacy importer for delimited sources.");
497 #ifdef ENABLE_IMPORT_PARQUET
498  help_desc.add_options()("enable-legacy-parquet-import",
499  po::value<bool>(&g_enable_legacy_parquet_import)
500  ->default_value(g_enable_legacy_parquet_import)
501  ->implicit_value(true),
502  "Use legacy importer for parquet sources.");
503 #endif
504  help_desc.add_options()("enable-fsi-regex-import",
505  po::value<bool>(&g_enable_fsi_regex_import)
506  ->default_value(g_enable_fsi_regex_import)
507  ->implicit_value(true),
508  "Use FSI importer for regex parsed sources.");
509 
510  help_desc.add_options()("enable-add-metadata-columns",
511  po::value<bool>(&g_enable_add_metadata_columns)
512  ->default_value(g_enable_add_metadata_columns)
513  ->implicit_value(true),
514  "Enable add_metadata_columns COPY FROM WITH option (Beta).");
515 
516  help_desc.add_options()("disk-cache-path",
517  po::value<std::string>(&disk_cache_config.path),
518  "Specify the path for the disk cache.");
519 
520  help_desc.add_options()(
521  "disk-cache-level",
522  po::value<std::string>(&(disk_cache_level))->default_value("foreign_tables"),
523  "Specify level of disk cache. Valid options are 'foreign_tables', "
524  "'local_tables', 'none', and 'all'.");
525 
526  help_desc.add_options()("disk-cache-size",
527  po::value<size_t>(&(disk_cache_config.size_limit)),
528  "Specify a maximum size for the disk cache in bytes.");
529 
530 #ifdef HAVE_AWS_S3
531  help_desc.add_options()(
532  "allow-s3-server-privileges",
533  po::value<bool>(&g_allow_s3_server_privileges)
534  ->default_value(g_allow_s3_server_privileges)
535  ->implicit_value(true),
536  "Allow S3 server privileges, if IAM user credentials are not provided. Credentials "
537  "may be specified with "
538  "environment variables (such as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, etc), "
539  "an AWS credentials file, or when running on an EC2 instance, with an IAM role "
540  "that is attached to the instance.");
541 #endif // defined(HAVE_AWS_S3)
542  help_desc.add_options()(
543  "enable-interoperability",
544  po::value<bool>(&g_enable_interop)
545  ->default_value(g_enable_interop)
546  ->implicit_value(true),
547  "Enable offloading of query portions to an external execution engine.");
548  help_desc.add_options()("enable-union",
549  po::value<bool>(&g_enable_union)
550  ->default_value(g_enable_union)
551  ->implicit_value(true),
552  "DEPRECATED. UNION ALL is enabled by default. Please remove "
553  "use of this option, as it may be disabled in the future.");
554  help_desc.add_options()(
555  "calcite-service-timeout",
556  po::value<size_t>(&system_parameters.calcite_timeout)
557  ->default_value(system_parameters.calcite_timeout),
558  "Calcite server timeout (milliseconds). Increase this on systems with frequent "
559  "schema changes or when running large numbers of parallel queries.");
560  help_desc.add_options()("calcite-service-keepalive",
561  po::value<size_t>(&system_parameters.calcite_keepalive)
562  ->default_value(system_parameters.calcite_keepalive)
563  ->implicit_value(true),
564  "Enable keepalive on Calcite connections.");
565  help_desc.add_options()(
566  "stringdict-parallelizm",
567  po::value<bool>(&g_enable_stringdict_parallel)
568  ->default_value(g_enable_stringdict_parallel)
569  ->implicit_value(true),
570  "Allow StringDictionary to parallelize loads using multiple threads");
571  help_desc.add_options()(
572  "log-user-id",
573  po::value<bool>(&Catalog_Namespace::g_log_user_id)
574  ->default_value(Catalog_Namespace::g_log_user_id)
575  ->implicit_value(true),
576  "Log userId integer in place of the userName (when available).");
577  help_desc.add_options()("log-user-origin",
578  po::value<bool>(&log_user_origin)
579  ->default_value(log_user_origin)
580  ->implicit_value(true),
581  "Lookup the origin of inbound connections by IP address/DNS "
582  "name, and print this information as part of stdlog.");
583  help_desc.add_options()(
584  "allowed-import-paths",
585  po::value<std::string>(&allowed_import_paths),
586  "List of allowed root paths that can be used in import operations.");
587  help_desc.add_options()(
588  "allowed-export-paths",
589  po::value<std::string>(&allowed_export_paths),
590  "List of allowed root paths that can be used in export operations.");
591  help_desc.add_options()("enable-system-tables",
592  po::value<bool>(&g_enable_system_tables)
593  ->default_value(g_enable_system_tables)
594  ->implicit_value(true),
595  "Enable use of system tables.");
596  help_desc.add_options()("enable-table-functions",
597  po::value<bool>(&g_enable_table_functions)
598  ->default_value(g_enable_table_functions)
599  ->implicit_value(true),
600  "Enable system table functions support.");
601  help_desc.add_options()("enable-logs-system-tables",
602  po::value<bool>(&g_enable_logs_system_tables)
603  ->default_value(g_enable_logs_system_tables)
604  ->implicit_value(true),
605  "Enable use of logs system tables.");
606  help_desc.add_options()(
607  "logs-system-tables-max-files-count",
608  po::value<size_t>(&g_logs_system_tables_max_files_count)
609  ->default_value(g_logs_system_tables_max_files_count),
610  "Maximum number of log files that will be processed by each logs system table.");
611 #ifdef ENABLE_MEMKIND
612  help_desc.add_options()("enable-tiered-cpu-mem",
613  po::value<bool>(&g_enable_tiered_cpu_mem)
614  ->default_value(g_enable_tiered_cpu_mem)
615  ->implicit_value(true),
616  "Enable additional tiers of CPU memory (PMEM, etc...)");
617  help_desc.add_options()("pmem-size", po::value<size_t>(&g_pmem_size)->default_value(0));
618  help_desc.add_options()("pmem-path", po::value<std::string>(&g_pmem_path));
619 #endif
620 
622 }
size_t g_pmem_size
float g_filter_push_down_low_frac
Definition: Execute.cpp:96
bool g_use_query_resultset_cache
Definition: Execute.cpp:148
logger::LogOptions log_options_
bool g_enable_logs_system_tables
Definition: Catalog.cpp:100
bool g_enable_legacy_delimited_import
Definition: ParserNode.cpp:81
po::options_description help_desc
bool g_allow_query_step_skipping
Definition: Execute.cpp:151
size_t g_logs_system_tables_max_files_count
bool g_enable_debug_timer
Definition: Logger.cpp:17
size_t g_filter_push_down_passing_row_ubound
Definition: Execute.cpp:98
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:89
bool enable_non_kernel_time_query_interrupt
int g_hll_precision_bits
std::string config_file
bool g_enable_overlaps_hashjoin
Definition: Execute.cpp:102
bool g_inner_join_fragment_skipping
Definition: Execute.cpp:91
bool g_use_chunk_metadata_cache
Definition: Execute.cpp:149
bool g_enable_string_functions
bool g_null_div_by_zero
Definition: Execute.cpp:88
bool g_enable_interop
bool g_from_table_reordering
Definition: Execute.cpp:90
bool g_enable_hashjoin_many_to_many
Definition: Execute.cpp:104
bool g_enable_system_tables
Definition: SysCatalog.cpp:64
std::string g_pmem_path
float g_filter_push_down_high_frac
Definition: Execute.cpp:97
bool g_enable_distance_rangejoin
Definition: Execute.cpp:103
bool g_bigint_count
double g_overlaps_target_entries_per_bin
Definition: Execute.cpp:106
bool g_allow_auto_resultset_caching
Definition: Execute.cpp:150
std::string allowed_export_paths
size_t g_overlaps_max_table_size_bytes
Definition: Execute.cpp:105
size_t g_query_resultset_cache_total_bytes
Definition: Execute.cpp:154
size_t g_max_cacheable_query_resultset_size_bytes
Definition: Execute.cpp:155
unsigned pending_query_interrupt_freq
bool g_enable_fsi_regex_import
Definition: ParserNode.cpp:85
bool g_cache_string_hash
bool g_uniform_request_ids_per_thrift_call
Definition: DBHandler.cpp:123
bool g_enable_filter_push_down
Definition: Execute.cpp:95
boost::program_options::options_description const & get_options() const
po::positional_options_description positional_options
bool g_enable_union
bool g_allow_cpu_retry
Definition: Execute.cpp:86
File_Namespace::DiskCacheConfig disk_cache_config
bool enable_udf_registration_for_all_users
std::string allowed_import_paths
bool g_enable_stringdict_parallel
std::string disk_cache_level
size_t max_cacheable_hashtable_size_bytes
size_t watchdog_none_encoded_string_translation_limit
bool g_enable_fsi
Definition: Catalog.cpp:96
bool g_allow_s3_server_privileges
Definition: S3Archive.cpp:34
bool g_enable_thrift_logs
Definition: HeavyDB.cpp:289
bool g_enable_add_metadata_columns
Definition: ParserNode.cpp:87
size_t g_max_import_threads
Definition: Importer.cpp:106
size_t g_auto_resultset_caching_threshold
Definition: Execute.cpp:156
bool g_enable_table_functions
Definition: Execute.cpp:112
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters

+ Here is the caller graph for this function:

std::string CommandLineOptions::getNodeIds ( )
std::vector<std::string> CommandLineOptions::getNodeIdsArray ( )
void CommandLineOptions::init_logging ( )

Definition at line 86 of file CommandLineOptions.cpp.

References logger::DEBUG1, and logger::init().

Referenced by EmbeddedDatabase::DBEngineImpl::init().

86  {
89  }
93 }
logger::LogOptions log_options_
void init(LogOptions const &log_opts)
Definition: Logger.cpp:360
Severity severity_
Definition: Logger.h:212
void set_base_path(std::string const &base_path)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

boost::optional< int > CommandLineOptions::parse_command_line ( int  argc,
char const *const *  argv,
const bool  should_init_logging = false 
)

Definition at line 1365 of file CommandLineOptions.cpp.

References SystemParameters::ALLOWED_ALL_USERS, SystemParameters::ALLOWED_SUPERUSERS_ONLY, construct_runtime_udf_registration_policy(), SystemParameters::DISALLOWED, logger::ERROR, migrations::MigrationMgr::executeRebrandMigration(), g_allow_auto_resultset_caching, g_allow_query_step_skipping, g_auto_resultset_caching_threshold, g_dynamic_watchdog_time_limit, g_enable_data_recycler, g_enable_dynamic_watchdog, g_enable_filter_push_down, g_enable_fsi, g_enable_fsi_regex_import, g_enable_legacy_delimited_import, g_enable_non_kernel_time_query_interrupt, g_enable_runtime_query_interrupt, g_enable_system_tables, g_enable_union, g_enable_watchdog, g_from_table_reordering, g_hashtable_cache_total_bytes, g_max_cacheable_hashtable_size_bytes, g_max_cacheable_query_resultset_size_bytes, g_max_import_threads, g_multi_instance, g_optimize_cuda_block_and_grid_sizes, g_parallel_top_max, g_parallel_top_min, g_pending_query_interrupt_freq, g_query_resultset_cache_total_bytes, g_running_query_interrupt_freq, g_use_chunk_metadata_cache, g_use_estimator_result_cache, g_use_hashtable_cache, g_use_query_resultset_cache, g_watchdog_none_encoded_string_translation_limit, logger::INFO, shared::kCatalogDirectoryName, shared::kDataDirectoryName, shared::kLockfilesDirectoryName, LOG, MAPD_RELEASE, migrations::MigrationMgr::migrationEnabled(), run, anonymous_namespace{CommandLineOptions.cpp}::sanitize_config_file(), migrations::MigrationMgr::takeMigrationLock(), anonymous_namespace{CommandLineOptions.cpp}::trim_and_check_file_exists(), and UNREACHABLE.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and main().

1368  {
1369  po::options_description all_desc("All options");
1370  all_desc.add(help_desc).add(developer_desc);
1371 
1372  try {
1373  po::store(po::command_line_parser(argc, argv)
1374  .options(all_desc)
1375  .positional(positional_options)
1376  .run(),
1377  vm);
1378  po::notify(vm);
1379 
1380  if (vm.count("help")) {
1381  std::cerr << "Usage: heavydb <data directory path> [-p <port number>] "
1382  "[--http-port <http port number>] [--flush-log] [--version|-v]"
1383  << std::endl
1384  << std::endl;
1385  std::cout << help_desc << std::endl;
1386  return 0;
1387  }
1388  if (vm.count("dev-options")) {
1389  std::cout << "Usage: heavydb <data directory path> [-p <port number>] "
1390  "[--http-port <http port number>] [--flush-log] [--version|-v]"
1391  << std::endl
1392  << std::endl;
1393  std::cout << developer_desc << std::endl;
1394  return 0;
1395  }
1396  if (vm.count("version")) {
1397  std::cout << "HeavyDB Version: " << MAPD_RELEASE << std::endl;
1398  return 0;
1399  }
1400 
1401  if (vm.count("config")) {
1402  std::ifstream settings_file(system_parameters.config_file);
1403 
1404  auto sanitized_settings = sanitize_config_file(settings_file);
1405 
1406  po::store(po::parse_config_file(sanitized_settings, all_desc, false), vm);
1407  po::notify(vm);
1408  settings_file.close();
1409  }
1410 
1411  if (!g_enable_union) {
1412  std::cerr
1413  << "The enable-union option is DEPRECATED and is now enabled by default. "
1414  "Please remove use of this option, as it may be disabled in the future."
1415  << std::endl;
1416  }
1417 
1418  // Trim base path before executing migration
1419  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
1420 
1421  // Execute rebrand migration before accessing any system files.
1422  std::string lockfiles_path = base_path + "/" + shared::kLockfilesDirectoryName;
1423  if (!boost::filesystem::exists(lockfiles_path)) {
1424  if (!boost::filesystem::create_directory(lockfiles_path)) {
1425  std::cerr << "Cannot create " + shared::kLockfilesDirectoryName +
1426  " subdirectory under "
1427  << base_path << std::endl;
1428  return 1;
1429  }
1430  }
1431  std::string lockfiles_path2 = lockfiles_path + "/" + shared::kCatalogDirectoryName;
1432  if (!boost::filesystem::exists(lockfiles_path2)) {
1433  if (!boost::filesystem::create_directory(lockfiles_path2)) {
1434  std::cerr << "Cannot create " + shared::kLockfilesDirectoryName + "/" +
1435  shared::kCatalogDirectoryName + " subdirectory under "
1436  << base_path << std::endl;
1437  return 1;
1438  }
1439  }
1440  std::string lockfiles_path3 = lockfiles_path + "/" + shared::kDataDirectoryName;
1441  if (!boost::filesystem::exists(lockfiles_path3)) {
1442  if (!boost::filesystem::create_directory(lockfiles_path3)) {
1443  std::cerr << "Cannot create " + shared::kLockfilesDirectoryName + "/" +
1444  shared::kDataDirectoryName + " subdirectory under "
1445  << base_path << std::endl;
1446  return 1;
1447  }
1448  }
1452  }
1453 
1454  if (!vm["enable-runtime-udf"].defaulted()) {
1455  if (!vm["enable-runtime-udfs"].defaulted()) {
1456  std::cerr << "Usage Error: Both enable-runtime-udf and enable-runtime-udfs "
1457  "specified. Please remove use of the enable-runtime-udfs flag, "
1458  "as it will be deprecated in the future."
1459  << std::endl;
1460  return 1;
1461  } else {
1463  std::cerr << "The enable-runtime-udf flag has been deprecated and replaced "
1464  "with enable-runtime-udfs. Please remove use of this option "
1465  "as it will be disabled in the future."
1466  << std::endl;
1467  }
1468  }
1472 
1473  if (should_init_logging) {
1474  init_logging();
1475  }
1476 
1478  return 1;
1479  }
1480  if (!trim_and_check_file_exists(authMetadata.ca_file_name, "ca file name")) {
1481  return 1;
1482  }
1484  "ssl trust store")) {
1485  return 1;
1486  }
1488  return 1;
1489  }
1491  return 1;
1492  }
1494  return 1;
1495  }
1496 
1512 
1513  if (g_multi_instance) {
1514  LOG(INFO) << "Disabling FSI and Disk Cache as they are not currently supported "
1515  "with multi-instance.";
1516  // Fsi & disk cache currently unsupported in multi-instance. The other option
1517  // configs are required because they require fsi support.
1518  g_enable_fsi = false;
1519  g_enable_fsi_regex_import = false;
1520  g_enable_system_tables = false;
1522 #ifdef ENABLE_IMPORT_PARQUET
1523  g_enable_legacy_parquet_import = true;
1524 #endif
1525  disk_cache_level = "none";
1526  }
1527 
1528  } catch (po::error& e) {
1529  std::cerr << "Usage Error: " << e.what() << std::endl;
1530  return 1;
1531  }
1532 
1533  if (g_hll_precision_bits < 1 || g_hll_precision_bits > 16) {
1534  std::cerr << "hll-precision-bits must be between 1 and 16." << std::endl;
1535  return 1;
1536  }
1537 
1538  if (!g_from_table_reordering) {
1539  LOG(INFO) << " From clause table reordering is disabled";
1540  }
1541 
1543  LOG(INFO) << " Filter push down for JOIN is enabled";
1544  }
1545 
1546  if (vm.count("udf")) {
1547  boost::algorithm::trim_if(udf_file_name, boost::is_any_of("\"'"));
1548 
1549  if (!boost::filesystem::exists(udf_file_name)) {
1550  LOG(ERROR) << " User defined function file " << udf_file_name << " does not exist.";
1551  return 1;
1552  }
1553 
1554  LOG(INFO) << " User provided extension functions loaded from " << udf_file_name;
1555  }
1556 
1557  if (vm.count("udf-compiler-path")) {
1558  boost::algorithm::trim_if(udf_compiler_path, boost::is_any_of("\"'"));
1559  }
1560 
1561  auto trim_string = [](std::string& s) {
1562  boost::algorithm::trim_if(s, boost::is_any_of("\"'"));
1563  };
1564 
1565  if (vm.count("udf-compiler-options")) {
1566  std::for_each(udf_compiler_options.begin(), udf_compiler_options.end(), trim_string);
1567  }
1568 
1569  boost::algorithm::trim_if(system_parameters.ha_brokers, boost::is_any_of("\"'"));
1570  boost::algorithm::trim_if(system_parameters.ha_group_id, boost::is_any_of("\"'"));
1571  boost::algorithm::trim_if(system_parameters.ha_shared_data, boost::is_any_of("\"'"));
1572  boost::algorithm::trim_if(system_parameters.ha_unique_server_id,
1573  boost::is_any_of("\"'"));
1574 
1575  if (!system_parameters.ha_group_id.empty()) {
1576  LOG(INFO) << " HA group id " << system_parameters.ha_group_id;
1577  if (system_parameters.ha_unique_server_id.empty()) {
1578  LOG(ERROR) << "Starting server in HA mode --ha-unique-server-id must be set ";
1579  return 5;
1580  } else {
1581  LOG(INFO) << " HA unique server id " << system_parameters.ha_unique_server_id;
1582  }
1583  if (system_parameters.ha_brokers.empty()) {
1584  LOG(ERROR) << "Starting server in HA mode --ha-brokers must be set ";
1585  return 6;
1586  } else {
1587  LOG(INFO) << " HA brokers " << system_parameters.ha_brokers;
1588  }
1589  if (system_parameters.ha_shared_data.empty()) {
1590  LOG(ERROR) << "Starting server in HA mode --ha-shared-data must be set ";
1591  return 7;
1592  } else {
1593  LOG(INFO) << " HA shared data is " << system_parameters.ha_shared_data;
1594  }
1595  }
1596 
1597  boost::algorithm::trim_if(system_parameters.master_address, boost::is_any_of("\"'"));
1598  if (!system_parameters.master_address.empty()) {
1599  if (!read_only) {
1600  LOG(ERROR) << "The master-address setting is only allowed in read-only mode";
1601  return 9;
1602  }
1603  LOG(INFO) << " Master Address is " << system_parameters.master_address;
1604  LOG(INFO) << " Master Port is " << system_parameters.master_port;
1605  }
1606 
1607  if (g_max_import_threads < 1) {
1608  std::cerr << "max-import-threads must be >= 1 (was set to " << g_max_import_threads
1609  << ")." << std::endl;
1610  return 8;
1611  } else {
1612  LOG(INFO) << " Max import threads " << g_max_import_threads;
1613  }
1614 
1616  LOG(INFO) << " cuda block size " << system_parameters.cuda_block_size;
1617  }
1619  LOG(INFO) << " cuda grid size " << system_parameters.cuda_grid_size;
1620  }
1621  LOG(INFO) << " Min CPU buffer pool slab size " << system_parameters.min_cpu_slab_size;
1622  LOG(INFO) << " Max CPU buffer pool slab size " << system_parameters.max_cpu_slab_size;
1623  LOG(INFO) << " Min GPU buffer pool slab size " << system_parameters.min_gpu_slab_size;
1624  LOG(INFO) << " Max GPU buffer pool slab size " << system_parameters.max_gpu_slab_size;
1625  LOG(INFO) << " calcite JVM max memory " << system_parameters.calcite_max_mem;
1626  LOG(INFO) << " HeavyDB Server Port " << system_parameters.omnisci_server_port;
1627  LOG(INFO) << " HeavyDB Calcite Port " << system_parameters.calcite_port;
1628  LOG(INFO) << " Enable Calcite view optimize "
1630  LOG(INFO) << " Allow Local Auth Fallback: "
1631  << (authMetadata.allowLocalAuthFallback ? "enabled" : "disabled");
1632  LOG(INFO) << " ParallelTop min threshold: " << g_parallel_top_min;
1633  LOG(INFO) << " ParallelTop watchdog max: " << g_parallel_top_max;
1634 
1635  LOG(INFO) << " Enable Data Recycler: "
1636  << (g_enable_data_recycler ? "enabled" : "disabled");
1637  if (g_enable_data_recycler) {
1638  LOG(INFO) << " \t Use hashtable cache: "
1639  << (g_use_hashtable_cache ? "enabled" : "disabled");
1640  if (g_use_hashtable_cache) {
1641  LOG(INFO) << " \t\t Total amount of bytes that hashtable cache keeps: "
1642  << g_hashtable_cache_total_bytes / (1024 * 1024) << " MB.";
1643  LOG(INFO) << " \t\t Per-hashtable size limit: "
1644  << g_max_cacheable_hashtable_size_bytes / (1024 * 1024) << " MB.";
1645  }
1646  LOG(INFO) << " \t Use query resultset cache: "
1647  << (g_use_query_resultset_cache ? "enabled" : "disabled");
1649  LOG(INFO) << " \t\t Total amount of bytes that query resultset cache keeps: "
1650  << g_query_resultset_cache_total_bytes / (1024 * 1024) << " MB.";
1651  LOG(INFO) << " \t\t Per-query resultset size limit: "
1652  << g_max_cacheable_query_resultset_size_bytes / (1024 * 1024) << " MB.";
1653  }
1654  LOG(INFO) << " \t\t Use auto query resultset caching: "
1655  << (g_allow_auto_resultset_caching ? "enabled" : "disabled");
1657  LOG(INFO) << " \t\t\t The maximum bytes of a query resultset which is "
1658  "automatically cached: "
1659  << g_auto_resultset_caching_threshold << " Bytes.";
1660  }
1661  LOG(INFO) << " \t\t Use query step skipping: "
1662  << (g_allow_query_step_skipping ? "enabled" : "disabled");
1663  LOG(INFO) << " \t Use chunk metadata cache: "
1664  << (g_use_chunk_metadata_cache ? "enabled" : "disabled");
1665  }
1666 
1667  const std::string udf_reg_policy_log_prefix{
1668  " \t\t Runtime UDF/UDTF Registration Policy: "};
1671  LOG(INFO) << udf_reg_policy_log_prefix << " DISALLOWED";
1672  break;
1673  }
1675  LOG(INFO) << udf_reg_policy_log_prefix << " ALLOWED for superusers only";
1676  break;
1677  }
1679  LOG(INFO) << udf_reg_policy_log_prefix << " ALLOWED for all users";
1680  break;
1681  }
1682  default: {
1683  UNREACHABLE() << "Unrecognized option for Runtime UDF/UDTF registration policy.";
1684  }
1685  }
1686 
1687  boost::algorithm::trim_if(authMetadata.distinguishedName, boost::is_any_of("\"'"));
1688  boost::algorithm::trim_if(authMetadata.uri, boost::is_any_of("\"'"));
1689  boost::algorithm::trim_if(authMetadata.ldapQueryUrl, boost::is_any_of("\"'"));
1690  boost::algorithm::trim_if(authMetadata.ldapRoleRegex, boost::is_any_of("\"'"));
1691  boost::algorithm::trim_if(authMetadata.ldapSuperUserRole, boost::is_any_of("\"'"));
1692 
1693  return boost::none;
1694 }
std::string distinguishedName
Definition: AuthMetadata.h:25
double g_running_query_interrupt_freq
Definition: Execute.cpp:129
size_t g_parallel_top_max
Definition: ResultSet.cpp:50
const std::string kDataDirectoryName
std::string ldapQueryUrl
Definition: AuthMetadata.h:26
bool g_use_query_resultset_cache
Definition: Execute.cpp:148
bool g_multi_instance
Definition: heavyai_locks.h:21
SystemParameters::RuntimeUdfRegistrationPolicy construct_runtime_udf_registration_policy(const bool enable_runtime_udfs, const bool enable_udf_registration_for_all_users)
bool trim_and_check_file_exists(std::string &filename, const std::string desc)
std::string ha_shared_data
std::string udf_compiler_path
bool g_enable_legacy_delimited_import
Definition: ParserNode.cpp:81
unsigned g_pending_query_interrupt_freq
Definition: Execute.cpp:128
po::options_description help_desc
#define LOG(tag)
Definition: Logger.h:283
bool enable_calcite_view_optimize
bool g_allow_query_step_skipping
Definition: Execute.cpp:151
std::string ldapRoleRegex
Definition: AuthMetadata.h:27
#define UNREACHABLE()
Definition: Logger.h:333
bool g_enable_dynamic_watchdog
Definition: Execute.cpp:80
size_t g_hashtable_cache_total_bytes
Definition: Execute.cpp:152
bool g_enable_non_kernel_time_query_interrupt
Definition: Execute.cpp:126
bool enable_non_kernel_time_query_interrupt
bool g_enable_data_recycler
Definition: Execute.cpp:146
std::string config_file
bool g_use_chunk_metadata_cache
Definition: Execute.cpp:149
size_t g_max_cacheable_hashtable_size_bytes
Definition: Execute.cpp:153
size_t g_watchdog_none_encoded_string_translation_limit
Definition: Execute.cpp:81
std::string ha_brokers
size_t g_parallel_top_min
Definition: ResultSet.cpp:49
std::string ssl_trust_ca_file
std::string ssl_trust_store
bool g_from_table_reordering
Definition: Execute.cpp:90
bool g_enable_system_tables
Definition: SysCatalog.cpp:64
static bool migrationEnabled()
Definition: MigrationMgr.h:43
std::string uri
Definition: AuthMetadata.h:24
bool g_enable_watchdog
bool g_allow_auto_resultset_caching
Definition: Execute.cpp:150
std::string ha_unique_server_id
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
bool g_optimize_cuda_block_and_grid_sizes
Definition: Execute.cpp:157
size_t g_query_resultset_cache_total_bytes
Definition: Execute.cpp:154
size_t g_max_cacheable_query_resultset_size_bytes
Definition: Execute.cpp:155
RuntimeUdfRegistrationPolicy runtime_udf_registration_policy
std::string ldapSuperUserRole
Definition: AuthMetadata.h:28
static void executeRebrandMigration(const std::string &base_path)
static void takeMigrationLock(const std::string &base_path)
unsigned pending_query_interrupt_freq
bool g_enable_fsi_regex_import
Definition: ParserNode.cpp:85
std::stringstream sanitize_config_file(std::ifstream &in)
std::vector< std::string > udf_compiler_options
const std::string kCatalogDirectoryName
bool g_enable_filter_push_down
Definition: Execute.cpp:95
bool g_use_estimator_result_cache
Definition: Execute.cpp:127
bool allowLocalAuthFallback
Definition: AuthMetadata.h:32
po::positional_options_description positional_options
bool g_enable_union
std::string ssl_keystore
const std::string kLockfilesDirectoryName
bool enable_udf_registration_for_all_users
po::options_description developer_desc
static const std::string MAPD_RELEASE
Definition: release.h:42
std::string disk_cache_level
static bool run
po::variables_map vm
size_t max_cacheable_hashtable_size_bytes
size_t watchdog_none_encoded_string_translation_limit
unsigned g_dynamic_watchdog_time_limit
Definition: Execute.cpp:85
bool g_enable_fsi
Definition: Catalog.cpp:96
std::string ha_group_id
bool g_enable_runtime_query_interrupt
Definition: Execute.cpp:125
size_t g_max_import_threads
Definition: Importer.cpp:106
bool g_use_hashtable_cache
Definition: Execute.cpp:147
size_t g_auto_resultset_caching_threshold
Definition: Execute.cpp:156
std::string master_address
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters
std::string ssl_cert_file

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void CommandLineOptions::validate ( )

Definition at line 1085 of file CommandLineOptions.cpp.

References anonymous_namespace{CommandLineOptions.cpp}::addOptionalFileToBlacklist(), ddl_utils::FilePathBlacklist::addToBlacklist(), File_Namespace::all, test_exceptions::data_path, File_Namespace::fsi, heavyai::ftruncate(), g_allow_invalid_literal_buffer_reads, g_enable_debug_timer, g_enable_fsi, g_enable_fsi_regex_import, g_enable_legacy_delimited_import, g_enable_logs_system_tables, g_enable_s3_fsi, g_enable_system_tables, Catalog_Namespace::g_log_user_id, g_logs_system_tables_max_files_count, g_multi_instance, g_pmem_path, g_pmem_size, g_read_only, g_vacuum_min_selectivity, File_Namespace::CachingFileMgr::getMinimumSize(), logger::INFO, ddl_utils::FilePathWhitelist::initialize(), shared::kCatalogDirectoryName, shared::kDataDirectoryName, shared::kDefaultDiskCacheDirName, shared::kDefaultLicenseFileName, shared::kDefaultLogDirName, shared::kSystemCatalogName, LOG, File_Namespace::non_fsi, File_Namespace::none, heavyai::safe_close(), heavyai::safe_fcntl(), heavyai::safe_open(), heavyai::safe_write(), import_export::ForeignDataImporter::setDefaultImportPath(), to_string(), VLOG, and logger::WARNING.

Referenced by main().

1085  {
1086  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
1087  const auto data_path = boost::filesystem::path(base_path) / shared::kDataDirectoryName;
1088  if (!boost::filesystem::exists(data_path)) {
1089  throw std::runtime_error("HeavyDB data directory does not exist at '" + base_path +
1090  "'");
1091  }
1092 
1093 // TODO: support lock on Windows
1094 #ifndef _WIN32
1095  {
1096  // If we aren't sharing the data directory, take and hold a write lock on
1097  // heavydb_pid.lck to prevent other processes from trying to share our dir.
1098  // TODO(sy): Probably need to get rid of this PID file because it doesn't make much
1099  // sense to store only one server's PID when we have the --multi-instance option.
1100  auto exe_filename = boost::filesystem::path(exe_name).filename().string();
1101  const std::string lock_file =
1102  (boost::filesystem::path(base_path) / std::string(exe_filename + "_pid.lck"))
1103  .string();
1104  auto pid = std::to_string(getpid());
1105  if (!g_multi_instance) {
1106  VLOG(1) << "taking [" << lock_file << "] read+write lock until process exit";
1107  } else {
1108  VLOG(1) << "taking [" << lock_file << "] read-only lock until process exit";
1109  }
1110 
1111  int fd;
1112  fd = heavyai::safe_open(lock_file.c_str(), O_RDWR | O_CREAT, 0664);
1113  if (fd == -1) {
1114  throw std::runtime_error("failed to open lockfile: " + lock_file + ": " +
1115  std::string(strerror(errno)) + " (" +
1116  std::to_string(errno) + ")");
1117  }
1118 
1119  struct flock fl;
1120  memset(&fl, 0, sizeof(fl));
1121  fl.l_type = !g_multi_instance ? F_WRLCK : F_RDLCK;
1122  fl.l_whence = SEEK_SET;
1123  int cmd;
1124 #ifdef __linux__
1125  // cmd = F_OFD_SETLK; // TODO(sy): broken on centos
1126  cmd = F_SETLK;
1127 #else
1128  cmd = F_SETLK;
1129 #endif // __linux__
1130  int ret = heavyai::safe_fcntl(fd, cmd, &fl);
1131  if (ret == -1 && (errno == EACCES || errno == EAGAIN)) { // locked by someone else
1132  heavyai::safe_close(fd);
1133  throw std::runtime_error(
1134  "another HeavyDB server instance is already using data directory: " +
1135  base_path);
1136  } else if (ret == -1) {
1137  auto errno0 = errno;
1138  heavyai::safe_close(fd);
1139  throw std::runtime_error("failed to lock lockfile: " + lock_file + ": " +
1140  std::string(strerror(errno0)) + " (" +
1141  std::to_string(errno0) + ")");
1142  }
1143 
1144  if (!g_multi_instance) {
1145  if (heavyai::ftruncate(fd, 0) == -1) {
1146  auto errno0 = errno;
1147  heavyai::safe_close(fd);
1148  throw std::runtime_error("failed to truncate lockfile: " + lock_file + ": " +
1149  std::string(strerror(errno0)) + " (" +
1150  std::to_string(errno0) + ")");
1151  }
1152  if (heavyai::safe_write(fd, pid.c_str(), pid.length()) == -1) {
1153  auto errno0 = errno;
1154  heavyai::safe_close(fd);
1155  throw std::runtime_error("failed to write lockfile: " + lock_file + ": " +
1156  std::string(strerror(errno0)) + " (" +
1157  std::to_string(errno0) + ")");
1158  }
1159  }
1160 
1161  // Intentionally leak the file descriptor. Lock will be held until process exit.
1162  }
1163 #endif // _WIN32
1164 
1165  boost::algorithm::trim_if(db_query_file, boost::is_any_of("\"'"));
1166  if (db_query_file.length() > 0 && !boost::filesystem::exists(db_query_file)) {
1167  throw std::runtime_error("File containing DB queries " + db_query_file +
1168  " does not exist.");
1169  }
1170  const auto db_file = boost::filesystem::path(base_path) /
1172  if (!boost::filesystem::exists(db_file)) {
1173  { // check old system catalog existsense
1174  const auto db_file =
1175  boost::filesystem::path(base_path) / shared::kCatalogDirectoryName / "mapd";
1176  if (!boost::filesystem::exists(db_file)) {
1177  throw std::runtime_error("System catalog " + shared::kSystemCatalogName +
1178  " does not exist.");
1179  }
1180  }
1181  }
1182  if (license_path.length() == 0) {
1184  }
1185 
1186  // add all parameters to be displayed on startup
1187  LOG(INFO) << "HeavyDB started with data directory at '" << base_path << "'";
1188  if (vm.count("license-path")) {
1189  LOG(INFO) << "License key path set to '" << license_path << "'";
1190  }
1192  LOG(INFO) << " Server read-only mode is " << read_only << " (--read-only)";
1193  if (g_multi_instance) {
1194  LOG(INFO) << " Multiple servers per --data directory is " << g_multi_instance
1195  << " (--multi-instance)";
1196  }
1197  if (g_read_only && g_multi_instance) {
1198  throw std::runtime_error(
1199  "You may not use the --read-only and --multi-instance configuration flags "
1200  "simultaneously.");
1201  }
1203  LOG(WARNING) << " Allowing invalid reads from the literal buffer. May cause invalid "
1204  "query results! (--allow-invalid-literal-buffer-reads)";
1205  }
1206 #if DISABLE_CONCURRENCY
1207  LOG(INFO) << " Threading layer: serial";
1208 #elif ENABLE_TBB
1209  LOG(INFO) << " Threading layer: TBB";
1210 #else
1211  LOG(INFO) << " Threading layer: std";
1212 #endif
1213  LOG(INFO) << " Watchdog is set to " << enable_watchdog;
1214  LOG(INFO) << " Dynamic Watchdog is set to " << enable_dynamic_watchdog;
1216  LOG(INFO) << " Dynamic Watchdog timeout is set to " << dynamic_watchdog_time_limit;
1217  }
1218  LOG(INFO) << " Runtime query interrupt is set to " << enable_runtime_query_interrupt;
1220  LOG(INFO) << " A frequency of checking pending query interrupt request is set to "
1221  << pending_query_interrupt_freq << " (in ms.)";
1222  LOG(INFO) << " A frequency of checking running query interrupt request is set to "
1223  << running_query_interrupt_freq << " (0.0 ~ 1.0)";
1224  }
1225  LOG(INFO) << " Non-kernel time query interrupt is set to "
1227 
1228  LOG(INFO) << " Debug Timer is set to " << g_enable_debug_timer;
1229  LOG(INFO) << " LogUserId is set to " << Catalog_Namespace::g_log_user_id;
1230  LOG(INFO) << " Maximum idle session duration " << idle_session_duration;
1231  LOG(INFO) << " Maximum active session duration " << max_session_duration;
1232  LOG(INFO) << " Maximum number of sessions " << system_parameters.num_sessions;
1233 
1234  LOG(INFO) << "Legacy delimited import is set to " << g_enable_legacy_delimited_import;
1235 #ifdef ENABLE_IMPORT_PARQUET
1236  LOG(INFO) << "Legacy parquet import is set to " << g_enable_legacy_parquet_import;
1237 #endif
1238  LOG(INFO) << "FSI regex parsed import is set to " << g_enable_fsi_regex_import;
1239 
1240  LOG(INFO) << "Allowed import paths is set to " << allowed_import_paths;
1241  LOG(INFO) << "Allowed export paths is set to " << allowed_export_paths;
1244 
1254  g_enable_s3_fsi = false;
1255 
1257 #ifdef ENABLE_IMPORT_PARQUET
1258  !g_enable_legacy_parquet_import ||
1259 #endif
1261  g_enable_fsi =
1262  true; // a requirement for FSI import code-paths is for FSI to be enabled
1263  LOG(INFO) << "FSI has been enabled as a side effect of enabling non-legacy import.";
1264  }
1265 
1266  if (disk_cache_level == "foreign_tables") {
1267  if (g_enable_fsi) {
1269  LOG(INFO) << "Disk cache enabled for foreign tables only";
1270  } else {
1271  LOG(INFO) << "Cannot enable disk cache for fsi when fsi is disabled. Defaulted to "
1272  "disk cache disabled";
1273  }
1274  } else if (disk_cache_level == "all") {
1276  LOG(INFO) << "Disk cache enabled for all tables";
1277  } else if (disk_cache_level == "local_tables") {
1279  LOG(INFO) << "Disk cache enabled for non-FSI tables";
1280  } else if (disk_cache_level == "none") {
1282  LOG(INFO) << "Disk cache disabled";
1283  } else {
1284  throw std::runtime_error{
1285  "Unexpected \"disk-cache-level\" value: " + disk_cache_level +
1286  ". Valid options are 'foreign_tables', "
1287  "'local_tables', 'none', and 'all'."};
1288  }
1289 
1291  throw std::runtime_error{"disk-cache-size must be at least " +
1293  }
1294 
1295  if (disk_cache_config.path.empty()) {
1297  }
1299 
1302 
1303  // If passed in, blacklist all security config files
1312 
1313  if (g_vacuum_min_selectivity < 0) {
1314  throw std::runtime_error{"vacuum-min-selectivity cannot be less than 0."};
1315  }
1316  LOG(INFO) << "Vacuum Min Selectivity: " << g_vacuum_min_selectivity;
1317 
1318  LOG(INFO) << "Enable system tables is set to " << g_enable_system_tables;
1319  if (g_enable_system_tables) {
1320  // System tables currently reuse FSI infrastructure and therefore, require FSI to be
1321  // enabled
1322  if (!g_enable_fsi) {
1323  g_enable_fsi = true;
1324  LOG(INFO) << "FSI has been enabled as a side effect of enabling system tables";
1325  }
1326  }
1327  LOG(INFO) << "Enable FSI is set to " << g_enable_fsi;
1328  LOG(INFO) << "Enable logs system tables set to " << g_enable_logs_system_tables;
1329 
1331  throw std::runtime_error{
1332  "Invalid value provided for the \"logs-system-tables-max-files-count\" "
1333  "option. Value must be greater than 0."};
1334  }
1335  LOG(INFO) << "Maximum number of logs system table files set to "
1337 
1338 #ifdef ENABLE_MEMKIND
1339  if (g_enable_tiered_cpu_mem) {
1340  if (g_pmem_path == "") {
1341  throw std::runtime_error{"pmem-path must be set to use tiered cpu memory"};
1342  }
1343  if (g_pmem_size == 0) {
1344  throw std::runtime_error{"pmem-size must be set to use tiered cpu memory"};
1345  }
1346  if (!std::filesystem::exists(g_pmem_path.c_str())) {
1347  throw std::runtime_error{"path to PMem directory (" + g_pmem_path +
1348  ") does not exist."};
1349  }
1350  }
1351 #endif
1352 }
size_t g_pmem_size
int safe_open(const char *path, int flags, mode_t mode) noexcept
Definition: heavyai_fs.cpp:90
const std::string kDataDirectoryName
bool g_multi_instance
Definition: heavyai_locks.h:21
bool g_enable_logs_system_tables
Definition: Catalog.cpp:100
static void initialize(const std::string &data_dir, const std::string &allowed_import_paths, const std::string &allowed_export_paths)
Definition: DdlUtils.cpp:841
const std::string kDefaultDiskCacheDirName
bool g_enable_legacy_delimited_import
Definition: ParserNode.cpp:81
#define LOG(tag)
Definition: Logger.h:283
size_t g_logs_system_tables_max_files_count
bool g_enable_debug_timer
Definition: Logger.cpp:17
const std::string kDefaultLogDirName
const std::string kSystemCatalogName
void addOptionalFileToBlacklist(std::string &filename)
bool enable_non_kernel_time_query_interrupt
std::string to_string(char const *&&v)
std::string ssl_trust_ca_file
ssize_t safe_write(const int fd, const void *buffer, const size_t buffer_size) noexcept
Definition: heavyai_fs.cpp:144
std::string ssl_trust_store
bool g_enable_s3_fsi
Definition: Catalog.cpp:97
static void setDefaultImportPath(const std::string &base_path)
bool g_enable_system_tables
Definition: SysCatalog.cpp:64
std::string g_pmem_path
std::string allowed_export_paths
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
bool g_read_only
Definition: File.cpp:40
unsigned pending_query_interrupt_freq
bool g_enable_fsi_regex_import
Definition: ParserNode.cpp:85
float g_vacuum_min_selectivity
const std::string kCatalogDirectoryName
bool g_allow_invalid_literal_buffer_reads
Definition: ConstantIR.cpp:140
const std::string kDefaultLicenseFileName
std::string ssl_keystore
File_Namespace::DiskCacheConfig disk_cache_config
int32_t ftruncate(const int32_t fd, int64_t length)
Definition: heavyai_fs.cpp:86
static void addToBlacklist(const std::string &path)
Definition: DdlUtils.cpp:888
std::string allowed_import_paths
std::string disk_cache_level
po::variables_map vm
int safe_fcntl(int fd, int cmd, struct flock *fl) noexcept
Definition: heavyai_fs.cpp:112
int safe_close(int fd) noexcept
Definition: heavyai_fs.cpp:101
bool g_enable_fsi
Definition: Catalog.cpp:96
#define VLOG(n)
Definition: Logger.h:383
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters
std::string ssl_cert_file

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void CommandLineOptions::validate_base_path ( )

Definition at line 1078 of file CommandLineOptions.cpp.

Referenced by main().

1078  {
1079  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
1080  if (!boost::filesystem::exists(base_path)) {
1081  throw std::runtime_error("HeavyDB base directory does not exist at " + base_path);
1082  }
1083 }

+ Here is the caller graph for this function:

Member Data Documentation

bool CommandLineOptions::allow_loop_joins = false
bool CommandLineOptions::allow_multifrag = true
std::string CommandLineOptions::allowed_export_paths {}

Definition at line 120 of file CommandLineOptions.h.

std::string CommandLineOptions::allowed_import_paths {}

Definition at line 119 of file CommandLineOptions.h.

AuthMetadata CommandLineOptions::authMetadata
std::string CommandLineOptions::base_path
std::string CommandLineOptions::cluster_file = {"cluster.conf"}

Definition at line 52 of file CommandLineOptions.h.

std::string CommandLineOptions::cluster_topology_file = {"cluster_topology.conf"}

Definition at line 53 of file CommandLineOptions.h.

std::string CommandLineOptions::clusterIds_arg

Definition at line 141 of file CommandLineOptions.h.

std::string CommandLineOptions::compressor = std::string(BLOSC_LZ4HC_COMPNAME)

Definition at line 129 of file CommandLineOptions.h.

std::vector<LeafHostInfo> CommandLineOptions::db_leaves
std::string CommandLineOptions::db_query_file = {""}

path to file containing warmup queries list

Definition at line 101 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

po::options_description CommandLineOptions::developer_desc

Definition at line 132 of file CommandLineOptions.h.

File_Namespace::DiskCacheConfig CommandLineOptions::disk_cache_config
std::string CommandLineOptions::disk_cache_level = ""

Definition at line 86 of file CommandLineOptions.h.

const bool CommandLineOptions::dist_v5_

Definition at line 153 of file CommandLineOptions.h.

unsigned CommandLineOptions::dynamic_watchdog_time_limit = 10000

Definition at line 85 of file CommandLineOptions.h.

bool CommandLineOptions::enable_auto_clear_render_mem = false
bool CommandLineOptions::enable_data_recycler = true

Definition at line 88 of file CommandLineOptions.h.

bool CommandLineOptions::enable_dynamic_watchdog = false

Definition at line 78 of file CommandLineOptions.h.

bool CommandLineOptions::enable_legacy_syntax = true
bool CommandLineOptions::enable_non_kernel_time_query_interrupt = true

Definition at line 81 of file CommandLineOptions.h.

bool CommandLineOptions::enable_rendering = false
bool CommandLineOptions::enable_runtime_query_interrupt = true

Definition at line 80 of file CommandLineOptions.h.

bool CommandLineOptions::enable_runtime_udf = true
private

Definition at line 160 of file CommandLineOptions.h.

bool CommandLineOptions::enable_runtime_udfs = true
private

Definition at line 156 of file CommandLineOptions.h.

bool CommandLineOptions::enable_udf_registration_for_all_users = false
private

Definition at line 161 of file CommandLineOptions.h.

bool CommandLineOptions::enable_watchdog = true

Definition at line 77 of file CommandLineOptions.h.

std::string CommandLineOptions::encryption_key_store_path = {}

Definition at line 55 of file CommandLineOptions.h.

std::string CommandLineOptions::exe_name

Definition at line 134 of file CommandLineOptions.h.

bool CommandLineOptions::exit_after_warmup = false

exit after warmup

Definition at line 105 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

size_t CommandLineOptions::hashtable_cache_total_bytes = 4294967296

Definition at line 90 of file CommandLineOptions.h.

po::options_description CommandLineOptions::help_desc

Definition at line 131 of file CommandLineOptions.h.

int CommandLineOptions::http_binary_port = 6276

Definition at line 48 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

int CommandLineOptions::http_port = 6278

Definition at line 47 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

int CommandLineOptions::idle_session_duration = kMinsPerHour

Inactive session tolerance in mins (60 mins)

Definition at line 109 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startHeavyDBServer().

bool CommandLineOptions::intel_jit_profile = false
bool CommandLineOptions::jit_debug = false
std::string CommandLineOptions::license_path = {""}

Definition at line 54 of file CommandLineOptions.h.

logger::LogOptions CommandLineOptions::log_options_

Definition at line 133 of file CommandLineOptions.h.

bool CommandLineOptions::log_user_origin = true

Definition at line 63 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

size_t CommandLineOptions::max_cacheable_hashtable_size_bytes = 2147483648

Definition at line 91 of file CommandLineOptions.h.

size_t CommandLineOptions::max_concurrent_render_sessions = 500
int CommandLineOptions::max_session_duration = kMinsPerMonth

Maximum session life in mins (43,200 mins == 30 Days) (https://pages.nist.gov/800-63-3/sp800-63b.html#aal3reauth)

Definition at line 114 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startHeavyDBServer().

const std::string CommandLineOptions::nodeIds_token = {"node_id"}
static

Definition at line 145 of file CommandLineOptions.h.

size_t CommandLineOptions::num_reader_threads = 0

Number of threads used when loading data

Definition at line 97 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startHeavyDBServer().

bool CommandLineOptions::optimize_cuda_block_and_grid_sizes = false

Definition at line 92 of file CommandLineOptions.h.

unsigned CommandLineOptions::pending_query_interrupt_freq = 1000

Definition at line 84 of file CommandLineOptions.h.

po::positional_options_description CommandLineOptions::positional_options

Definition at line 135 of file CommandLineOptions.h.

bool CommandLineOptions::read_only = false
bool CommandLineOptions::render_compositor_use_last_gpu = true
size_t CommandLineOptions::render_mem_bytes = 1000000000
int CommandLineOptions::render_oom_retry_threshold = 0
bool CommandLineOptions::renderer_prefer_igpu = false
bool CommandLineOptions::renderer_use_parallel_executors = true

Definition at line 76 of file CommandLineOptions.h.

Referenced by startHeavyDBServer().

bool CommandLineOptions::renderer_use_ppll_polys = false
unsigned CommandLineOptions::renderer_vulkan_timeout_ms = 60000
size_t CommandLineOptions::reserved_gpu_mem = 384 * 1024 * 1024
double CommandLineOptions::running_query_interrupt_freq = 0.1

Definition at line 83 of file CommandLineOptions.h.

std::vector<LeafHostInfo> CommandLineOptions::string_leaves
SystemParameters CommandLineOptions::system_parameters
std::vector<std::string> CommandLineOptions::udf_compiler_options
std::string CommandLineOptions::udf_compiler_path = {""}
std::string CommandLineOptions::udf_file_name = {""}
bool CommandLineOptions::use_estimator_result_cache = true

Definition at line 82 of file CommandLineOptions.h.

bool CommandLineOptions::use_hashtable_cache = true

Definition at line 89 of file CommandLineOptions.h.

bool CommandLineOptions::verbose_logging = false

Definition at line 56 of file CommandLineOptions.h.

po::variables_map CommandLineOptions::vm

Definition at line 140 of file CommandLineOptions.h.

size_t CommandLineOptions::watchdog_none_encoded_string_translation_limit = 1000000

Definition at line 79 of file CommandLineOptions.h.


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