├── .gitignore ├── README.md ├── microbenchmarks ├── CMakeLists.txt ├── README.md ├── benchmark │ ├── bw_benchmark.c │ ├── parsing.c │ ├── pmem_mapping.c │ ├── read_bw_benchmark.c │ ├── thread_mapping.c │ └── write_bw_benchmark.c ├── cmake │ ├── FindLibpmem.cmake │ └── FindLibpmem2.cmake ├── include │ ├── bw_benchmark.h │ ├── common.h │ ├── parsing.h │ ├── pmem_mapping.h │ ├── read_bw_benchmark.h │ ├── thread_mapping.h │ ├── unrolled_instructions.h │ └── write_bw_benchmark.h ├── main.c └── mapping_files │ ├── socket_1_split │ ├── socket_2_linear │ └── socket_2_split ├── plot_scripts ├── .gitignore ├── README.md ├── __init__.py ├── common.py ├── heatmap.py ├── mixed_performance.py ├── multiple_sockets.py ├── optimal_access_size.py ├── pinning_variants.py ├── random_access.py ├── requirements.txt ├── ssb_detail.py ├── ssb_full.py ├── ssb_worker.py └── warm_up_behavior.py ├── scripts ├── microbenchmarks │ ├── all_benchmarks.sh │ ├── all_benchmarks_dram.sh │ ├── benchmark.sh │ ├── example.sh │ ├── random_write.sh │ ├── read_benchmark.sh │ ├── sequential_read.sh │ └── sequential_write.sh ├── reproducibility │ ├── README.txt │ ├── microbenchmarks-random.sh │ └── microbenchmarks.sh └── ssb │ └── run_ssb.sh └── ssb ├── handcrafted ├── Makefile ├── README.md ├── common.hpp ├── dash_ssb.patch ├── dram_ht.hpp ├── init_dash.sh ├── pmem_ht.hpp ├── ssb.cpp └── ssd_ht.hpp ├── hyrise-dram ├── .clang-format ├── .clang-tidy ├── .clang-tidy-ignore ├── .dockerignore ├── CMakeLists.txt ├── CONTRIBUTING.md ├── DEPENDENCIES.md ├── Dockerfile ├── GLOSSARY.md ├── INFORMATION.md ├── Jenkinsfile ├── LICENSE ├── PreLoad.cmake ├── README.md ├── cmake │ ├── EmbedLLVM.cmake │ ├── FindLibpmem.cmake │ ├── FindLibpmem2.cmake │ ├── FindMemkind.cmake │ ├── FindNuma.cmake │ ├── FindReadline.cmake │ ├── FindSqlite3.cmake │ ├── FindTbb.cmake │ ├── TargetLinkLibrariesSystem.cmake │ └── git_watcher.cmake ├── install_dependencies.sh ├── nvm.json ├── requirements.txt ├── scripts │ ├── analyze_ccache_usage.py │ ├── analyze_gtest_runtime.py │ ├── benchmark.sh │ ├── benchmark_all.sh │ ├── benchmark_multithreaded.py │ ├── clang_tidy_wrapper.sh │ ├── compare_benchmarks.py │ ├── compare_benchmarks_multithreaded.py │ ├── compare_coverage.sh │ ├── compile_time.sh │ ├── coverage.sh │ ├── format.sh │ ├── lint.sh │ ├── planviz │ │ ├── imgcat.sh │ │ └── is_iterm2.sh │ ├── plot_operator_breakdown.py │ ├── plot_performance_breakdown.py │ ├── plot_performance_over_commit_range.py │ ├── plot_performance_over_time.py │ ├── run_benchmarks_over_commit_range.sh │ ├── run_server_tests.sh │ ├── setup_imdb.py │ └── test │ │ ├── compareBenchmarkScriptTest.py │ │ ├── hyriseBenchmarkCore.py │ │ ├── hyriseBenchmarkFileBased_test.py │ │ ├── hyriseBenchmarkJCCH_test.py │ │ ├── hyriseBenchmarkJoinOrder_test.py │ │ ├── hyriseBenchmarkTPCC_test.py │ │ ├── hyriseBenchmarkTPCH_test.py │ │ └── hyriseConsole_test.py └── src │ ├── CMakeLists.txt │ ├── benchmark │ ├── CMakeLists.txt │ ├── benchmark_playground.cpp │ ├── file_based_benchmark.cpp │ ├── join_order_benchmark.cpp │ ├── micro_benchmark_basic_fixture.cpp │ ├── micro_benchmark_basic_fixture.hpp │ ├── micro_benchmark_main.cpp │ ├── micro_benchmark_utils.cpp │ ├── micro_benchmark_utils.hpp │ ├── operators │ │ ├── aggregate_benchmark.cpp │ │ ├── difference_benchmark.cpp │ │ ├── join_aggregate_benchmark.cpp │ │ ├── join_benchmark.cpp │ │ ├── projection_benchmark.cpp │ │ ├── sort_benchmark.cpp │ │ ├── sql_benchmark.cpp │ │ ├── table_scan_benchmark.cpp │ │ ├── table_scan_sorted_benchmark.cpp │ │ ├── union_all_benchmark.cpp │ │ └── union_positions_benchmark.cpp │ ├── tpcc_benchmark.cpp │ ├── tpcds_benchmark.cpp │ ├── tpch_benchmark.cpp │ ├── tpch_data_micro_benchmark.cpp │ └── tpch_table_generator_benchmark.cpp │ ├── benchmarklib │ ├── CMakeLists.txt │ ├── abstract_benchmark_item_runner.cpp │ ├── abstract_benchmark_item_runner.hpp │ ├── abstract_table_generator.cpp │ ├── abstract_table_generator.hpp │ ├── benchmark_config.cpp │ ├── benchmark_config.hpp │ ├── benchmark_item_result.cpp │ ├── benchmark_item_result.hpp │ ├── benchmark_item_run_result.cpp │ ├── benchmark_item_run_result.hpp │ ├── benchmark_runner.cpp │ ├── benchmark_runner.hpp │ ├── benchmark_sql_executor.cpp │ ├── benchmark_sql_executor.hpp │ ├── benchmark_state.cpp │ ├── benchmark_state.hpp │ ├── benchmark_table_encoder.cpp │ ├── benchmark_table_encoder.hpp │ ├── cli_config_parser.cpp │ ├── cli_config_parser.hpp │ ├── encoding_config.cpp │ ├── encoding_config.hpp │ ├── file_based_benchmark_item_runner.cpp │ ├── file_based_benchmark_item_runner.hpp │ ├── file_based_table_generator.cpp │ ├── file_based_table_generator.hpp │ ├── jcch │ │ ├── jcch_benchmark_item_runner.cpp │ │ ├── jcch_benchmark_item_runner.hpp │ │ ├── jcch_table_generator.cpp │ │ └── jcch_table_generator.hpp │ ├── random_generator.hpp │ ├── synthetic_table_generator.cpp │ ├── synthetic_table_generator.hpp │ ├── table_builder.hpp │ ├── tpcc │ │ ├── constants.hpp │ │ ├── defines.hpp │ │ ├── procedures │ │ │ ├── abstract_tpcc_procedure.cpp │ │ │ ├── abstract_tpcc_procedure.hpp │ │ │ ├── tpcc_delivery.cpp │ │ │ ├── tpcc_delivery.hpp │ │ │ ├── tpcc_new_order.cpp │ │ │ ├── tpcc_new_order.hpp │ │ │ ├── tpcc_order_status.cpp │ │ │ ├── tpcc_order_status.hpp │ │ │ ├── tpcc_payment.cpp │ │ │ ├── tpcc_payment.hpp │ │ │ ├── tpcc_stock_level.cpp │ │ │ └── tpcc_stock_level.hpp │ │ ├── readme.md │ │ ├── tpcc_benchmark_item_runner.cpp │ │ ├── tpcc_benchmark_item_runner.hpp │ │ ├── tpcc_random_generator.hpp │ │ ├── tpcc_table_generator.cpp │ │ └── tpcc_table_generator.hpp │ ├── tpcds │ │ ├── tpcds_table_generator.cpp │ │ └── tpcds_table_generator.hpp │ └── tpch │ │ ├── tpch_benchmark_item_runner.cpp │ │ ├── tpch_benchmark_item_runner.hpp │ │ ├── tpch_queries.cpp │ │ ├── tpch_queries.hpp │ │ ├── tpch_table_generator.cpp │ │ └── tpch_table_generator.hpp │ ├── bin │ ├── CMakeLists.txt │ ├── client.cpp │ ├── client.hpp │ ├── console │ │ ├── console.cpp │ │ ├── console.hpp │ │ ├── pagination.cpp │ │ └── pagination.hpp │ ├── playground.cpp │ └── server.cpp │ ├── lib │ ├── CMakeLists.txt │ ├── all_parameter_variant.cpp │ ├── all_parameter_variant.hpp │ ├── all_type_variant.cpp │ ├── all_type_variant.hpp │ ├── cache │ │ ├── abstract_cache.hpp │ │ └── gdfs_cache.hpp │ ├── concurrency │ │ ├── commit_context.cpp │ │ ├── commit_context.hpp │ │ ├── transaction_context.cpp │ │ ├── transaction_context.hpp │ │ ├── transaction_manager.cpp │ │ └── transaction_manager.hpp │ ├── constant_mappings.cpp │ ├── constant_mappings.hpp │ ├── cost_estimation │ │ ├── abstract_cost_estimator.cpp │ │ ├── abstract_cost_estimator.hpp │ │ ├── cost_estimator_logical.cpp │ │ └── cost_estimator_logical.hpp │ ├── expression │ │ ├── abstract_expression.cpp │ │ ├── abstract_expression.hpp │ │ ├── abstract_predicate_expression.cpp │ │ ├── abstract_predicate_expression.hpp │ │ ├── aggregate_expression.cpp │ │ ├── aggregate_expression.hpp │ │ ├── arithmetic_expression.cpp │ │ ├── arithmetic_expression.hpp │ │ ├── between_expression.cpp │ │ ├── between_expression.hpp │ │ ├── binary_predicate_expression.cpp │ │ ├── binary_predicate_expression.hpp │ │ ├── case_expression.cpp │ │ ├── case_expression.hpp │ │ ├── cast_expression.cpp │ │ ├── cast_expression.hpp │ │ ├── correlated_parameter_expression.cpp │ │ ├── correlated_parameter_expression.hpp │ │ ├── evaluation │ │ │ ├── expression_evaluator.cpp │ │ │ ├── expression_evaluator.hpp │ │ │ ├── expression_functors.hpp │ │ │ ├── expression_result.hpp │ │ │ ├── expression_result_views.hpp │ │ │ ├── like_matcher.cpp │ │ │ └── like_matcher.hpp │ │ ├── exists_expression.cpp │ │ ├── exists_expression.hpp │ │ ├── expression_functional.cpp │ │ ├── expression_functional.hpp │ │ ├── expression_precedence.hpp │ │ ├── expression_utils.cpp │ │ ├── expression_utils.hpp │ │ ├── extract_expression.cpp │ │ ├── extract_expression.hpp │ │ ├── function_expression.cpp │ │ ├── function_expression.hpp │ │ ├── in_expression.cpp │ │ ├── in_expression.hpp │ │ ├── is_null_expression.cpp │ │ ├── is_null_expression.hpp │ │ ├── list_expression.cpp │ │ ├── list_expression.hpp │ │ ├── logical_expression.cpp │ │ ├── logical_expression.hpp │ │ ├── lqp_column_expression.cpp │ │ ├── lqp_column_expression.hpp │ │ ├── lqp_subquery_expression.cpp │ │ ├── lqp_subquery_expression.hpp │ │ ├── placeholder_expression.cpp │ │ ├── placeholder_expression.hpp │ │ ├── pqp_column_expression.cpp │ │ ├── pqp_column_expression.hpp │ │ ├── pqp_subquery_expression.cpp │ │ ├── pqp_subquery_expression.hpp │ │ ├── unary_minus_expression.cpp │ │ ├── unary_minus_expression.hpp │ │ ├── value_expression.cpp │ │ └── value_expression.hpp │ ├── hyrise.cpp │ ├── hyrise.hpp │ ├── import_export │ │ ├── binary │ │ │ ├── binary_parser.cpp │ │ │ ├── binary_parser.hpp │ │ │ ├── binary_writer.cpp │ │ │ └── binary_writer.hpp │ │ ├── csv │ │ │ ├── csv_converter.cpp │ │ │ ├── csv_converter.hpp │ │ │ ├── csv_meta.cpp │ │ │ ├── csv_meta.hpp │ │ │ ├── csv_parser.cpp │ │ │ ├── csv_parser.hpp │ │ │ ├── csv_writer.cpp │ │ │ └── csv_writer.hpp │ │ ├── file_type.cpp │ │ └── file_type.hpp │ ├── logical_query_plan │ │ ├── abstract_lqp_node.cpp │ │ ├── abstract_lqp_node.hpp │ │ ├── abstract_non_query_node.cpp │ │ ├── abstract_non_query_node.hpp │ │ ├── aggregate_node.cpp │ │ ├── aggregate_node.hpp │ │ ├── alias_node.cpp │ │ ├── alias_node.hpp │ │ ├── change_meta_table_node.cpp │ │ ├── change_meta_table_node.hpp │ │ ├── create_prepared_plan_node.cpp │ │ ├── create_prepared_plan_node.hpp │ │ ├── create_table_node.cpp │ │ ├── create_table_node.hpp │ │ ├── create_view_node.cpp │ │ ├── create_view_node.hpp │ │ ├── delete_node.cpp │ │ ├── delete_node.hpp │ │ ├── drop_table_node.cpp │ │ ├── drop_table_node.hpp │ │ ├── drop_view_node.cpp │ │ ├── drop_view_node.hpp │ │ ├── dummy_table_node.cpp │ │ ├── dummy_table_node.hpp │ │ ├── enable_make_for_lqp_node.hpp │ │ ├── except_node.cpp │ │ ├── except_node.hpp │ │ ├── export_node.cpp │ │ ├── export_node.hpp │ │ ├── functional_dependency.cpp │ │ ├── functional_dependency.hpp │ │ ├── import_node.cpp │ │ ├── import_node.hpp │ │ ├── insert_node.cpp │ │ ├── insert_node.hpp │ │ ├── intersect_node.cpp │ │ ├── intersect_node.hpp │ │ ├── join_node.cpp │ │ ├── join_node.hpp │ │ ├── limit_node.cpp │ │ ├── limit_node.hpp │ │ ├── logical_plan_root_node.cpp │ │ ├── logical_plan_root_node.hpp │ │ ├── lqp_translator.cpp │ │ ├── lqp_translator.hpp │ │ ├── lqp_unique_constraint.cpp │ │ ├── lqp_unique_constraint.hpp │ │ ├── lqp_utils.cpp │ │ ├── lqp_utils.hpp │ │ ├── mock_node.cpp │ │ ├── mock_node.hpp │ │ ├── predicate_node.cpp │ │ ├── predicate_node.hpp │ │ ├── projection_node.cpp │ │ ├── projection_node.hpp │ │ ├── sort_node.cpp │ │ ├── sort_node.hpp │ │ ├── static_table_node.cpp │ │ ├── static_table_node.hpp │ │ ├── stored_table_node.cpp │ │ ├── stored_table_node.hpp │ │ ├── union_node.cpp │ │ ├── union_node.hpp │ │ ├── update_node.cpp │ │ ├── update_node.hpp │ │ ├── validate_node.cpp │ │ └── validate_node.hpp │ ├── lossless_cast.cpp │ ├── lossless_cast.hpp │ ├── lossy_cast.hpp │ ├── memory │ │ ├── boost_default_memory_resource.cpp │ │ ├── dram_memory_resource.cpp │ │ ├── dram_memory_resource.hpp │ │ ├── kind_memory_manager.cpp │ │ ├── kind_memory_manager.hpp │ │ ├── nvm_memory_resource.cpp │ │ └── nvm_memory_resource.hpp │ ├── null_value.hpp │ ├── operators │ │ ├── abstract_aggregate_operator.cpp │ │ ├── abstract_aggregate_operator.hpp │ │ ├── abstract_join_operator.cpp │ │ ├── abstract_join_operator.hpp │ │ ├── abstract_operator.cpp │ │ ├── abstract_operator.hpp │ │ ├── abstract_read_only_operator.cpp │ │ ├── abstract_read_only_operator.hpp │ │ ├── abstract_read_write_operator.cpp │ │ ├── abstract_read_write_operator.hpp │ │ ├── aggregate │ │ │ └── aggregate_traits.hpp │ │ ├── aggregate_hash.cpp │ │ ├── aggregate_hash.hpp │ │ ├── aggregate_sort.cpp │ │ ├── aggregate_sort.hpp │ │ ├── alias_operator.cpp │ │ ├── alias_operator.hpp │ │ ├── change_meta_table.cpp │ │ ├── change_meta_table.hpp │ │ ├── delete.cpp │ │ ├── delete.hpp │ │ ├── difference.cpp │ │ ├── difference.hpp │ │ ├── export.cpp │ │ ├── export.hpp │ │ ├── get_table.cpp │ │ ├── get_table.hpp │ │ ├── import.cpp │ │ ├── import.hpp │ │ ├── index_scan.cpp │ │ ├── index_scan.hpp │ │ ├── insert.cpp │ │ ├── insert.hpp │ │ ├── join_hash.cpp │ │ ├── join_hash.hpp │ │ ├── join_hash │ │ │ ├── join_hash_steps.hpp │ │ │ └── join_hash_traits.hpp │ │ ├── join_index.cpp │ │ ├── join_index.hpp │ │ ├── join_nested_loop.cpp │ │ ├── join_nested_loop.hpp │ │ ├── join_sort_merge.cpp │ │ ├── join_sort_merge.hpp │ │ ├── join_sort_merge │ │ │ ├── column_materializer.hpp │ │ │ └── radix_cluster_sort.hpp │ │ ├── join_verification.cpp │ │ ├── join_verification.hpp │ │ ├── limit.cpp │ │ ├── limit.hpp │ │ ├── maintenance │ │ │ ├── create_prepared_plan.cpp │ │ │ ├── create_prepared_plan.hpp │ │ │ ├── create_table.cpp │ │ │ ├── create_table.hpp │ │ │ ├── create_view.cpp │ │ │ ├── create_view.hpp │ │ │ ├── drop_table.cpp │ │ │ ├── drop_table.hpp │ │ │ ├── drop_view.cpp │ │ │ └── drop_view.hpp │ │ ├── multi_predicate_join │ │ │ ├── multi_predicate_join_evaluator.cpp │ │ │ └── multi_predicate_join_evaluator.hpp │ │ ├── operator_join_predicate.cpp │ │ ├── operator_join_predicate.hpp │ │ ├── operator_performance_data.cpp │ │ ├── operator_performance_data.hpp │ │ ├── operator_scan_predicate.cpp │ │ ├── operator_scan_predicate.hpp │ │ ├── pqp_utils.hpp │ │ ├── print.cpp │ │ ├── print.hpp │ │ ├── product.cpp │ │ ├── product.hpp │ │ ├── projection.cpp │ │ ├── projection.hpp │ │ ├── sort.cpp │ │ ├── sort.hpp │ │ ├── table_scan.cpp │ │ ├── table_scan.hpp │ │ ├── table_scan │ │ │ ├── abstract_dereferenced_column_table_scan_impl.cpp │ │ │ ├── abstract_dereferenced_column_table_scan_impl.hpp │ │ │ ├── abstract_table_scan_impl.hpp │ │ │ ├── column_between_table_scan_impl.cpp │ │ │ ├── column_between_table_scan_impl.hpp │ │ │ ├── column_is_null_table_scan_impl.cpp │ │ │ ├── column_is_null_table_scan_impl.hpp │ │ │ ├── column_like_table_scan_impl.cpp │ │ │ ├── column_like_table_scan_impl.hpp │ │ │ ├── column_vs_column_table_scan_impl.cpp │ │ │ ├── column_vs_column_table_scan_impl.hpp │ │ │ ├── column_vs_value_table_scan_impl.cpp │ │ │ ├── column_vs_value_table_scan_impl.hpp │ │ │ ├── expression_evaluator_table_scan_impl.cpp │ │ │ ├── expression_evaluator_table_scan_impl.hpp │ │ │ └── sorted_segment_search.hpp │ │ ├── table_wrapper.cpp │ │ ├── table_wrapper.hpp │ │ ├── union_all.cpp │ │ ├── union_all.hpp │ │ ├── union_positions.cpp │ │ ├── union_positions.hpp │ │ ├── update.cpp │ │ ├── update.hpp │ │ ├── validate.cpp │ │ └── validate.hpp │ ├── optimizer │ │ ├── join_ordering │ │ │ ├── abstract_join_ordering_algorithm.cpp │ │ │ ├── abstract_join_ordering_algorithm.hpp │ │ │ ├── dp_ccp.cpp │ │ │ ├── dp_ccp.hpp │ │ │ ├── enumerate_ccp.cpp │ │ │ ├── enumerate_ccp.hpp │ │ │ ├── greedy_operator_ordering.cpp │ │ │ ├── greedy_operator_ordering.hpp │ │ │ ├── join_graph.cpp │ │ │ ├── join_graph.hpp │ │ │ ├── join_graph_builder.cpp │ │ │ ├── join_graph_builder.hpp │ │ │ ├── join_graph_edge.cpp │ │ │ └── join_graph_edge.hpp │ │ ├── optimizer.cpp │ │ ├── optimizer.hpp │ │ └── strategy │ │ │ ├── abstract_rule.cpp │ │ │ ├── abstract_rule.hpp │ │ │ ├── between_composition_rule.cpp │ │ │ ├── between_composition_rule.hpp │ │ │ ├── chunk_pruning_rule.cpp │ │ │ ├── chunk_pruning_rule.hpp │ │ │ ├── column_pruning_rule.cpp │ │ │ ├── column_pruning_rule.hpp │ │ │ ├── dependent_group_by_reduction_rule.cpp │ │ │ ├── dependent_group_by_reduction_rule.hpp │ │ │ ├── expression_reduction_rule.cpp │ │ │ ├── expression_reduction_rule.hpp │ │ │ ├── in_expression_rewrite_rule.cpp │ │ │ ├── in_expression_rewrite_rule.hpp │ │ │ ├── index_scan_rule.cpp │ │ │ ├── index_scan_rule.hpp │ │ │ ├── join_ordering_rule.cpp │ │ │ ├── join_ordering_rule.hpp │ │ │ ├── join_predicate_ordering_rule.cpp │ │ │ ├── join_predicate_ordering_rule.hpp │ │ │ ├── predicate_merge_rule.cpp │ │ │ ├── predicate_merge_rule.hpp │ │ │ ├── predicate_placement_rule.cpp │ │ │ ├── predicate_placement_rule.hpp │ │ │ ├── predicate_reordering_rule.cpp │ │ │ ├── predicate_reordering_rule.hpp │ │ │ ├── predicate_split_up_rule.cpp │ │ │ ├── predicate_split_up_rule.hpp │ │ │ ├── semi_join_reduction_rule.cpp │ │ │ ├── semi_join_reduction_rule.hpp │ │ │ ├── stored_table_column_alignment_rule.cpp │ │ │ ├── stored_table_column_alignment_rule.hpp │ │ │ ├── subquery_to_join_rule.cpp │ │ │ └── subquery_to_join_rule.hpp │ ├── resolve_type.hpp │ ├── scheduler │ │ ├── abstract_scheduler.cpp │ │ ├── abstract_scheduler.hpp │ │ ├── abstract_task.cpp │ │ ├── abstract_task.hpp │ │ ├── immediate_execution_scheduler.cpp │ │ ├── immediate_execution_scheduler.hpp │ │ ├── job_task.cpp │ │ ├── job_task.hpp │ │ ├── node_queue_scheduler.cpp │ │ ├── node_queue_scheduler.hpp │ │ ├── operator_task.cpp │ │ ├── operator_task.hpp │ │ ├── task_queue.cpp │ │ ├── task_queue.hpp │ │ ├── topology.cpp │ │ ├── topology.hpp │ │ ├── worker.cpp │ │ └── worker.hpp │ ├── server │ │ ├── client_disconnect_exception.hpp │ │ ├── postgres_message_type.hpp │ │ ├── postgres_protocol_handler.cpp │ │ ├── postgres_protocol_handler.hpp │ │ ├── query_handler.cpp │ │ ├── query_handler.hpp │ │ ├── read_buffer.cpp │ │ ├── read_buffer.hpp │ │ ├── result_serializer.cpp │ │ ├── result_serializer.hpp │ │ ├── ring_buffer_iterator.hpp │ │ ├── server.cpp │ │ ├── server.hpp │ │ ├── server_types.hpp │ │ ├── session.cpp │ │ ├── session.hpp │ │ ├── write_buffer.cpp │ │ └── write_buffer.hpp │ ├── sql │ │ ├── create_sql_parser_error_message.cpp │ │ ├── create_sql_parser_error_message.hpp │ │ ├── parameter_id_allocator.cpp │ │ ├── parameter_id_allocator.hpp │ │ ├── sql_identifier.cpp │ │ ├── sql_identifier.hpp │ │ ├── sql_identifier_resolver.cpp │ │ ├── sql_identifier_resolver.hpp │ │ ├── sql_identifier_resolver_proxy.cpp │ │ ├── sql_identifier_resolver_proxy.hpp │ │ ├── sql_pipeline.cpp │ │ ├── sql_pipeline.hpp │ │ ├── sql_pipeline_builder.cpp │ │ ├── sql_pipeline_builder.hpp │ │ ├── sql_pipeline_statement.cpp │ │ ├── sql_pipeline_statement.hpp │ │ ├── sql_plan_cache.hpp │ │ ├── sql_translator.cpp │ │ └── sql_translator.hpp │ ├── statistics │ │ ├── abstract_cardinality_estimator.cpp │ │ ├── abstract_cardinality_estimator.hpp │ │ ├── attribute_statistics.cpp │ │ ├── attribute_statistics.hpp │ │ ├── base_attribute_statistics.cpp │ │ ├── base_attribute_statistics.hpp │ │ ├── cardinality_estimation_cache.hpp │ │ ├── cardinality_estimator.cpp │ │ ├── cardinality_estimator.hpp │ │ ├── generate_pruning_statistics.cpp │ │ ├── generate_pruning_statistics.hpp │ │ ├── join_graph_statistics_cache.cpp │ │ ├── join_graph_statistics_cache.hpp │ │ ├── statistics_objects │ │ │ ├── abstract_histogram.cpp │ │ │ ├── abstract_histogram.hpp │ │ │ ├── abstract_statistics_object.cpp │ │ │ ├── abstract_statistics_object.hpp │ │ │ ├── equal_distinct_count_histogram.cpp │ │ │ ├── equal_distinct_count_histogram.hpp │ │ │ ├── generic_histogram.cpp │ │ │ ├── generic_histogram.hpp │ │ │ ├── generic_histogram_builder.cpp │ │ │ ├── generic_histogram_builder.hpp │ │ │ ├── histogram_domain.cpp │ │ │ ├── histogram_domain.hpp │ │ │ ├── min_max_filter.cpp │ │ │ ├── min_max_filter.hpp │ │ │ ├── null_value_ratio_statistics.cpp │ │ │ ├── null_value_ratio_statistics.hpp │ │ │ ├── range_filter.cpp │ │ │ └── range_filter.hpp │ │ ├── table_statistics.cpp │ │ └── table_statistics.hpp │ ├── storage │ │ ├── abstract_encoded_segment.cpp │ │ ├── abstract_encoded_segment.hpp │ │ ├── abstract_segment.cpp │ │ ├── abstract_segment.hpp │ │ ├── abstract_table_constraint.cpp │ │ ├── abstract_table_constraint.hpp │ │ ├── base_dictionary_segment.hpp │ │ ├── base_segment_accessor.hpp │ │ ├── base_segment_encoder.hpp │ │ ├── base_value_segment.hpp │ │ ├── chunk.cpp │ │ ├── chunk.hpp │ │ ├── chunk_encoder.cpp │ │ ├── chunk_encoder.hpp │ │ ├── create_iterable_from_reference_segment.ipp │ │ ├── create_iterable_from_segment.hpp │ │ ├── create_iterable_from_segment.ipp │ │ ├── dictionary_segment.cpp │ │ ├── dictionary_segment.hpp │ │ ├── dictionary_segment │ │ │ ├── attribute_vector_iterable.hpp │ │ │ ├── dictionary_encoder.hpp │ │ │ └── dictionary_segment_iterable.hpp │ │ ├── encoding_type.cpp │ │ ├── encoding_type.hpp │ │ ├── fixed_string_dictionary_segment.cpp │ │ ├── fixed_string_dictionary_segment.hpp │ │ ├── fixed_string_dictionary_segment │ │ │ ├── fixed_string.cpp │ │ │ ├── fixed_string.hpp │ │ │ ├── fixed_string_vector.cpp │ │ │ ├── fixed_string_vector.hpp │ │ │ └── fixed_string_vector_iterator.hpp │ │ ├── frame_of_reference_segment.cpp │ │ ├── frame_of_reference_segment.hpp │ │ ├── frame_of_reference_segment │ │ │ ├── frame_of_reference_encoder.hpp │ │ │ └── frame_of_reference_segment_iterable.hpp │ │ ├── index │ │ │ ├── abstract_index.cpp │ │ │ ├── abstract_index.hpp │ │ │ ├── adaptive_radix_tree │ │ │ │ ├── adaptive_radix_tree_index.cpp │ │ │ │ ├── adaptive_radix_tree_index.hpp │ │ │ │ ├── adaptive_radix_tree_nodes.cpp │ │ │ │ └── adaptive_radix_tree_nodes.hpp │ │ │ ├── b_tree │ │ │ │ ├── b_tree_index.cpp │ │ │ │ ├── b_tree_index.hpp │ │ │ │ ├── b_tree_index_impl.cpp │ │ │ │ └── b_tree_index_impl.hpp │ │ │ ├── group_key │ │ │ │ ├── composite_group_key_index.cpp │ │ │ │ ├── composite_group_key_index.hpp │ │ │ │ ├── group_key_index.cpp │ │ │ │ ├── group_key_index.hpp │ │ │ │ ├── variable_length_key.cpp │ │ │ │ ├── variable_length_key.hpp │ │ │ │ ├── variable_length_key_base.cpp │ │ │ │ ├── variable_length_key_base.hpp │ │ │ │ ├── variable_length_key_proxy.cpp │ │ │ │ ├── variable_length_key_proxy.hpp │ │ │ │ ├── variable_length_key_store.cpp │ │ │ │ └── variable_length_key_store.hpp │ │ │ ├── index_statistics.cpp │ │ │ ├── index_statistics.hpp │ │ │ └── segment_index_type.hpp │ │ ├── lqp_view.cpp │ │ ├── lqp_view.hpp │ │ ├── lz4_segment.cpp │ │ ├── lz4_segment.hpp │ │ ├── lz4_segment │ │ │ ├── lz4_encoder.hpp │ │ │ └── lz4_segment_iterable.hpp │ │ ├── materialize.hpp │ │ ├── mvcc_data.cpp │ │ ├── mvcc_data.hpp │ │ ├── pos_lists │ │ │ ├── abstract_pos_list.cpp │ │ │ ├── abstract_pos_list.hpp │ │ │ ├── entire_chunk_pos_list.cpp │ │ │ ├── entire_chunk_pos_list.hpp │ │ │ ├── row_id_pos_list.cpp │ │ │ └── row_id_pos_list.hpp │ │ ├── prepared_plan.cpp │ │ ├── prepared_plan.hpp │ │ ├── reference_segment.cpp │ │ ├── reference_segment.hpp │ │ ├── reference_segment │ │ │ └── reference_segment_iterable.hpp │ │ ├── resolve_encoded_segment_type.hpp │ │ ├── run_length_segment.cpp │ │ ├── run_length_segment.hpp │ │ ├── run_length_segment │ │ │ ├── run_length_encoder.hpp │ │ │ └── run_length_segment_iterable.hpp │ │ ├── segment_access_counter.cpp │ │ ├── segment_access_counter.hpp │ │ ├── segment_accessor.cpp │ │ ├── segment_accessor.hpp │ │ ├── segment_encoding_utils.cpp │ │ ├── segment_encoding_utils.hpp │ │ ├── segment_iterables.hpp │ │ ├── segment_iterables │ │ │ ├── abstract_segment_iterators.hpp │ │ │ ├── any_segment_iterable.cpp │ │ │ ├── any_segment_iterable.hpp │ │ │ ├── any_segment_iterator.hpp │ │ │ ├── create_iterable_from_attribute_vector.hpp │ │ │ └── segment_positions.hpp │ │ ├── segment_iterate.hpp │ │ ├── split_pos_list_by_chunk_id.cpp │ │ ├── split_pos_list_by_chunk_id.hpp │ │ ├── storage_manager.cpp │ │ ├── storage_manager.hpp │ │ ├── table.cpp │ │ ├── table.hpp │ │ ├── table_column_definition.cpp │ │ ├── table_column_definition.hpp │ │ ├── table_key_constraint.cpp │ │ ├── table_key_constraint.hpp │ │ ├── value_segment.cpp │ │ ├── value_segment.hpp │ │ ├── value_segment │ │ │ ├── null_value_vector_iterable.hpp │ │ │ └── value_segment_iterable.hpp │ │ └── vector_compression │ │ │ ├── base_compressed_vector.hpp │ │ │ ├── base_vector_compressor.hpp │ │ │ ├── base_vector_decompressor.hpp │ │ │ ├── compressed_vector_type.hpp │ │ │ ├── fixed_size_byte_aligned │ │ │ ├── fixed_size_byte_aligned_compressor.cpp │ │ │ ├── fixed_size_byte_aligned_compressor.hpp │ │ │ ├── fixed_size_byte_aligned_decompressor.hpp │ │ │ ├── fixed_size_byte_aligned_utils.hpp │ │ │ └── fixed_size_byte_aligned_vector.hpp │ │ │ ├── resolve_compressed_vector_type.hpp │ │ │ ├── simd_bp128 │ │ │ ├── oversized_types.hpp │ │ │ ├── simd_bp128_compressor.cpp │ │ │ ├── simd_bp128_compressor.hpp │ │ │ ├── simd_bp128_decompressor.cpp │ │ │ ├── simd_bp128_decompressor.hpp │ │ │ ├── simd_bp128_iterator.cpp │ │ │ ├── simd_bp128_iterator.hpp │ │ │ ├── simd_bp128_packing.cpp │ │ │ ├── simd_bp128_packing.hpp │ │ │ ├── simd_bp128_vector.cpp │ │ │ └── simd_bp128_vector.hpp │ │ │ ├── vector_compression.cpp │ │ │ └── vector_compression.hpp │ ├── strong_typedef.hpp │ ├── tasks │ │ ├── chunk_compression_task.cpp │ │ └── chunk_compression_task.hpp │ ├── type_comparison.hpp │ ├── types.cpp │ ├── types.hpp │ ├── uid_allocator.hpp │ ├── utils │ │ ├── abstract_plugin.hpp │ │ ├── aligned_size.hpp │ │ ├── assert.hpp │ │ ├── boost_bimap_core_override.hpp │ │ ├── boost_curry_override.hpp │ │ ├── check_table_equal.cpp │ │ ├── check_table_equal.hpp │ │ ├── column_ids_after_pruning.cpp │ │ ├── column_ids_after_pruning.hpp │ │ ├── copyable_atomic.hpp │ │ ├── enum_constant.hpp │ │ ├── format_bytes.cpp │ │ ├── format_bytes.hpp │ │ ├── format_duration.cpp │ │ ├── format_duration.hpp │ │ ├── invalid_input_exception.hpp │ │ ├── list_directory.cpp │ │ ├── list_directory.hpp │ │ ├── load_table.cpp │ │ ├── load_table.hpp │ │ ├── log_manager.cpp │ │ ├── log_manager.hpp │ │ ├── lossless_predicate_cast.cpp │ │ ├── lossless_predicate_cast.hpp │ │ ├── make_bimap.hpp │ │ ├── meta_table_manager.cpp │ │ ├── meta_table_manager.hpp │ │ ├── meta_tables │ │ │ ├── abstract_meta_table.cpp │ │ │ ├── abstract_meta_table.hpp │ │ │ ├── meta_chunk_sort_orders_table.cpp │ │ │ ├── meta_chunk_sort_orders_table.hpp │ │ │ ├── meta_chunks_table.cpp │ │ │ ├── meta_chunks_table.hpp │ │ │ ├── meta_columns_table.cpp │ │ │ ├── meta_columns_table.hpp │ │ │ ├── meta_log_table.cpp │ │ │ ├── meta_log_table.hpp │ │ │ ├── meta_plugins_table.cpp │ │ │ ├── meta_plugins_table.hpp │ │ │ ├── meta_segments_accurate_table.cpp │ │ │ ├── meta_segments_accurate_table.hpp │ │ │ ├── meta_segments_table.cpp │ │ │ ├── meta_segments_table.hpp │ │ │ ├── meta_settings_table.cpp │ │ │ ├── meta_settings_table.hpp │ │ │ ├── meta_system_information_table.cpp │ │ │ ├── meta_system_information_table.hpp │ │ │ ├── meta_system_utilization_table.cpp │ │ │ ├── meta_system_utilization_table.hpp │ │ │ ├── meta_tables_table.cpp │ │ │ ├── meta_tables_table.hpp │ │ │ ├── segment_meta_data.cpp │ │ │ └── segment_meta_data.hpp │ │ ├── pausable_loop_thread.cpp │ │ ├── pausable_loop_thread.hpp │ │ ├── performance_warning.cpp │ │ ├── performance_warning.hpp │ │ ├── plugin_manager.cpp │ │ ├── plugin_manager.hpp │ │ ├── print_directed_acyclic_graph.hpp │ │ ├── settings │ │ │ ├── abstract_setting.cpp │ │ │ └── abstract_setting.hpp │ │ ├── settings_manager.cpp │ │ ├── settings_manager.hpp │ │ ├── singleton.hpp │ │ ├── size_estimation_utils.hpp │ │ ├── sqlite_add_indices.cpp │ │ ├── sqlite_add_indices.hpp │ │ ├── sqlite_wrapper.cpp │ │ ├── sqlite_wrapper.hpp │ │ ├── string_utils.cpp │ │ ├── string_utils.hpp │ │ ├── template_type.hpp │ │ ├── timer.cpp │ │ ├── timer.hpp │ │ └── tracing │ │ │ └── probes.hpp │ ├── version.hpp.in │ └── visualization │ │ ├── abstract_visualizer.hpp │ │ ├── join_graph_visualizer.cpp │ │ ├── join_graph_visualizer.hpp │ │ ├── lqp_visualizer.cpp │ │ ├── lqp_visualizer.hpp │ │ ├── pqp_visualizer.cpp │ │ ├── pqp_visualizer.hpp │ │ ├── viz_record_layout.cpp │ │ └── viz_record_layout.hpp │ ├── plugins │ ├── CMakeLists.txt │ ├── mvcc_delete_plugin.cpp │ ├── mvcc_delete_plugin.hpp │ ├── non_instantiable_plugin.cpp │ ├── test_plugin.cpp │ └── test_plugin.hpp │ └── test │ ├── CMakeLists.txt │ ├── base_test.cpp │ ├── base_test.hpp │ ├── benchmarklib │ ├── sqlite_add_indices_test.cpp │ ├── synthetic_table_generator_test.cpp │ ├── table_builder_test.cpp │ ├── tpcc │ │ └── tpcc_test.cpp │ ├── tpcds │ │ └── tpcds_db_generator_test.cpp │ └── tpch │ │ └── tpch_db_generator_test.cpp │ ├── gtest_case_template.cpp │ ├── gtest_main.cpp │ ├── lib │ ├── all_parameter_variant_test.cpp │ ├── all_type_variant_test.cpp │ ├── cache │ │ └── cache_test.cpp │ ├── concurrency │ │ ├── commit_context_test.cpp │ │ ├── stress_test.cpp │ │ ├── transaction_context_test.cpp │ │ └── transaction_manager_test.cpp │ ├── cost_estimation │ │ └── abstract_cost_estimator_test.cpp │ ├── expression │ │ ├── evaluation │ │ │ ├── expression_result_test.cpp │ │ │ └── like_matcher_test.cpp │ │ ├── expression_evaluator_to_pos_list_test.cpp │ │ ├── expression_evaluator_to_values_test.cpp │ │ ├── expression_test.cpp │ │ ├── expression_utils_test.cpp │ │ ├── lqp_subquery_expression_test.cpp │ │ └── pqp_subquery_expression_test.cpp │ ├── hyrise_test.cpp │ ├── import_export │ │ ├── binary │ │ │ ├── binary_parser_test.cpp │ │ │ └── binary_writer_test.cpp │ │ └── csv │ │ │ ├── csv_meta_test.cpp │ │ │ ├── csv_parser_test.cpp │ │ │ └── csv_writer_test.cpp │ ├── logical_query_plan │ │ ├── aggregate_node_test.cpp │ │ ├── alias_node_test.cpp │ │ ├── change_meta_table_node_test.cpp │ │ ├── create_prepared_plan_node_test.cpp │ │ ├── create_table_node_test.cpp │ │ ├── create_view_node_test.cpp │ │ ├── delete_node_test.cpp │ │ ├── drop_table_node_test.cpp │ │ ├── drop_view_node_test.cpp │ │ ├── dummy_table_node_test.cpp │ │ ├── except_node_test.cpp │ │ ├── export_node_test.cpp │ │ ├── functional_dependency_test.cpp │ │ ├── import_node_test.cpp │ │ ├── insert_node_test.cpp │ │ ├── intersect_node_test.cpp │ │ ├── join_node_test.cpp │ │ ├── limit_node_test.cpp │ │ ├── logical_query_plan_test.cpp │ │ ├── lqp_find_subplan_mismatch_test.cpp │ │ ├── lqp_translator_test.cpp │ │ ├── lqp_unique_constraint_test.cpp │ │ ├── lqp_utils_test.cpp │ │ ├── mock_node_test.cpp │ │ ├── predicate_node_test.cpp │ │ ├── projection_node_test.cpp │ │ ├── sort_node_test.cpp │ │ ├── static_table_node_test.cpp │ │ ├── stored_table_node_test.cpp │ │ ├── union_node_test.cpp │ │ ├── update_node_test.cpp │ │ └── validate_node_test.cpp │ ├── lossless_cast_test.cpp │ ├── lossy_cast_test.cpp │ ├── memory │ │ └── segments_using_allocators_test.cpp │ ├── null_value_test.cpp │ ├── operators │ │ ├── aggregate_sort_test.cpp │ │ ├── aggregate_test.cpp │ │ ├── alias_operator_test.cpp │ │ ├── change_meta_table_test.cpp │ │ ├── delete_test.cpp │ │ ├── difference_test.cpp │ │ ├── export_test.cpp │ │ ├── get_table_test.cpp │ │ ├── import_test.cpp │ │ ├── index_scan_test.cpp │ │ ├── insert_test.cpp │ │ ├── join_hash │ │ │ ├── join_hash_steps_test.cpp │ │ │ ├── join_hash_traits_test.cpp │ │ │ └── join_hash_types_test.cpp │ │ ├── join_hash_test.cpp │ │ ├── join_index_test.cpp │ │ ├── join_nested_loop_test.cpp │ │ ├── join_sort_merge_test.cpp │ │ ├── join_test_runner.cpp │ │ ├── join_verification_test.cpp │ │ ├── limit_test.cpp │ │ ├── maintenance │ │ │ ├── create_prepared_plan_test.cpp │ │ │ ├── create_table_test.cpp │ │ │ ├── create_view_test.cpp │ │ │ ├── drop_table_test.cpp │ │ │ └── drop_view_test.cpp │ │ ├── operator_deep_copy_test.cpp │ │ ├── operator_join_predicate_test.cpp │ │ ├── operator_performance_data_test.cpp │ │ ├── operator_scan_predicate_test.cpp │ │ ├── pqp_utils_test.cpp │ │ ├── print_test.cpp │ │ ├── product_test.cpp │ │ ├── projection_test.cpp │ │ ├── sort_test.cpp │ │ ├── table_scan_between_test.cpp │ │ ├── table_scan_sorted_segment_search_test.cpp │ │ ├── table_scan_string_test.cpp │ │ ├── table_scan_test.cpp │ │ ├── typed_operator_base_test.hpp │ │ ├── union_all_test.cpp │ │ ├── union_positions_test.cpp │ │ ├── update_test.cpp │ │ ├── validate_test.cpp │ │ └── validate_visibility_test.cpp │ ├── optimizer │ │ ├── join_ordering │ │ │ ├── dp_ccp_test.cpp │ │ │ ├── enumerate_ccp_test.cpp │ │ │ ├── greedy_operator_ordering_test.cpp │ │ │ ├── join_graph_builder_test.cpp │ │ │ └── join_graph_test.cpp │ │ ├── optimizer_test.cpp │ │ └── strategy │ │ │ ├── between_composition_rule_test.cpp │ │ │ ├── chunk_pruning_rule_test.cpp │ │ │ ├── column_pruning_rule_test.cpp │ │ │ ├── dependent_group_by_reduction_rule_test.cpp │ │ │ ├── expression_reduction_rule_test.cpp │ │ │ ├── in_expression_rewrite_rule_test.cpp │ │ │ ├── index_scan_rule_test.cpp │ │ │ ├── join_ordering_rule_test.cpp │ │ │ ├── join_predicate_ordering_rule_test.cpp │ │ │ ├── predicate_merge_rule_test.cpp │ │ │ ├── predicate_placement_rule_test.cpp │ │ │ ├── predicate_reordering_rule_test.cpp │ │ │ ├── predicate_split_up_rule_test.cpp │ │ │ ├── semi_join_reduction_rule_test.cpp │ │ │ ├── stored_table_column_alignment_rule_test.cpp │ │ │ ├── strategy_base_test.cpp │ │ │ ├── strategy_base_test.hpp │ │ │ └── subquery_to_join_rule_test.cpp │ ├── scheduler │ │ ├── operator_task_test.cpp │ │ └── scheduler_test.cpp │ ├── server │ │ ├── mock_socket.hpp │ │ ├── postgres_protocol_handler_test.cpp │ │ ├── query_handler_test.cpp │ │ ├── read_buffer_test.cpp │ │ ├── result_serializer_test.cpp │ │ ├── server_test_runner.cpp │ │ ├── transaction_handling_test.cpp │ │ └── write_buffer_test.cpp │ ├── sql │ │ ├── sql_identifier_resolver_test.cpp │ │ ├── sql_pipeline_statement_test.cpp │ │ ├── sql_pipeline_test.cpp │ │ ├── sql_plan_cache_test.cpp │ │ ├── sql_translator_test.cpp │ │ └── sqlite_testrunner │ │ │ ├── sqlite_testrunner.cpp │ │ │ ├── sqlite_testrunner.hpp │ │ │ ├── sqlite_testrunner_encodings.cpp │ │ │ ├── sqlite_testrunner_unencoded.cpp │ │ │ └── sqlite_wrapper_test.cpp │ ├── statistics │ │ ├── attribute_statistics_test.cpp │ │ ├── cardinality_estimator_test.cpp │ │ ├── join_graph_statistics_cache_test.cpp │ │ ├── statistics_objects │ │ │ ├── equal_distinct_count_histogram_test.cpp │ │ │ ├── generic_histogram_test.cpp │ │ │ ├── min_max_filter_test.cpp │ │ │ ├── range_filter_test.cpp │ │ │ └── string_histogram_domain_test.cpp │ │ └── table_statistics_test.cpp │ ├── storage │ │ ├── any_segment_iterable_test.cpp │ │ ├── chunk_encoder_test.cpp │ │ ├── chunk_test.cpp │ │ ├── compressed_vector_test.cpp │ │ ├── dictionary_segment_test.cpp │ │ ├── encoded_segment_test.cpp │ │ ├── encoded_string_segment_test.cpp │ │ ├── encoding_test.hpp │ │ ├── fixed_string_dictionary_segment │ │ │ ├── fixed_string_test.cpp │ │ │ └── fixed_string_vector_test.cpp │ │ ├── fixed_string_dictionary_segment_test.cpp │ │ ├── index │ │ │ ├── adaptive_radix_tree │ │ │ │ └── adaptive_radix_tree_index_test.cpp │ │ │ ├── b_tree │ │ │ │ └── b_tree_index_test.cpp │ │ │ ├── group_key │ │ │ │ ├── composite_group_key_index_test.cpp │ │ │ │ ├── group_key_index_test.cpp │ │ │ │ ├── variable_length_key_base_test.cpp │ │ │ │ ├── variable_length_key_store_test.cpp │ │ │ │ └── variable_length_key_test.cpp │ │ │ ├── multi_segment_index_test.cpp │ │ │ └── single_segment_index_test.cpp │ │ ├── iterables_test.cpp │ │ ├── lz4_segment_test.cpp │ │ ├── materialize_test.cpp │ │ ├── pos_lists │ │ │ └── entire_chunk_pos_list_test.cpp │ │ ├── prepared_plan_test.cpp │ │ ├── reference_segment_test.cpp │ │ ├── segment_access_counter_test.cpp │ │ ├── segment_accessor_test.cpp │ │ ├── segment_iterators_test.cpp │ │ ├── storage_manager_test.cpp │ │ ├── table_column_definition_test.cpp │ │ ├── table_key_constraint_test.cpp │ │ ├── table_test.cpp │ │ ├── value_segment_test.cpp │ │ └── vector_compression │ │ │ └── simd_bp128 │ │ │ └── simd_bp128_test.cpp │ ├── tasks │ │ └── chunk_compression_task_test.cpp │ └── utils │ │ ├── check_table_equal_test.cpp │ │ ├── column_ids_after_pruning_test.cpp │ │ ├── format_bytes_test.cpp │ │ ├── format_duration_test.cpp │ │ ├── load_table_test.cpp │ │ ├── log_manager_test.cpp │ │ ├── lossless_predicate_cast_test.cpp │ │ ├── meta_table_manager_test.cpp │ │ ├── meta_tables │ │ ├── meta_log_table_test.cpp │ │ ├── meta_mock_table.cpp │ │ ├── meta_mock_table.hpp │ │ ├── meta_plugins_table_test.cpp │ │ ├── meta_settings_table_test.cpp │ │ ├── meta_system_utilization_table_test.cpp │ │ └── meta_table_test.cpp │ │ ├── mock_setting.cpp │ │ ├── mock_setting.hpp │ │ ├── plugin_manager_test.cpp │ │ ├── plugin_test_utils.cpp │ │ ├── plugin_test_utils.hpp │ │ ├── setting_test.cpp │ │ ├── settings_manager_test.cpp │ │ ├── singleton_test.cpp │ │ ├── size_estimation_utils_test.cpp │ │ └── string_utils_test.cpp │ ├── operators │ └── alias_operator_test.cpp │ ├── plugins │ ├── mvcc_delete_plugin_system_test.cpp │ └── mvcc_delete_plugin_test.cpp │ ├── testing_assert.cpp │ ├── testing_assert.hpp │ └── utils │ └── constraint_test_utils.hpp └── hyrise-pmem ├── .clang-format ├── .clang-tidy ├── .clang-tidy-ignore ├── .dockerignore ├── CMakeLists.txt ├── CONTRIBUTING.md ├── CPackConfig.cmake ├── CPackSourceConfig.cmake ├── DEPENDENCIES.md ├── Dockerfile ├── GLOSSARY.md ├── INFORMATION.md ├── Jenkinsfile ├── LICENSE ├── Makefile ├── PreLoad.cmake ├── README.md ├── cmake ├── EmbedLLVM.cmake ├── FindLibpmem.cmake ├── FindLibpmem2.cmake ├── FindMemkind.cmake ├── FindNuma.cmake ├── FindReadline.cmake ├── FindSqlite3.cmake ├── FindTbb.cmake ├── TargetLinkLibrariesSystem.cmake └── git_watcher.cmake ├── cmake_install.cmake ├── install_dependencies.sh ├── nvm.json ├── queries ├── q11.sql ├── q12.sql ├── q13.sql ├── q21.sql ├── q22.sql ├── q23.sql ├── q31.sql ├── q32.sql ├── q33.sql ├── q34.sql ├── q41.sql ├── q42.sql └── q43.sql ├── requirements.txt ├── scripts ├── analyze_ccache_usage.py ├── analyze_gtest_runtime.py ├── benchmark.sh ├── benchmark_all.sh ├── benchmark_multithreaded.py ├── clang_tidy_wrapper.sh ├── compare_benchmarks.py ├── compare_benchmarks_multithreaded.py ├── compare_coverage.sh ├── compile_time.sh ├── coverage.sh ├── format.sh ├── lint.sh ├── planviz │ ├── imgcat.sh │ └── is_iterm2.sh ├── plot_operator_breakdown.py ├── plot_performance_breakdown.py ├── plot_performance_over_commit_range.py ├── plot_performance_over_time.py ├── run_benchmarks_over_commit_range.sh ├── run_server_tests.sh ├── setup_imdb.py └── test │ ├── compareBenchmarkScriptTest.py │ ├── hyriseBenchmarkCore.py │ ├── hyriseBenchmarkFileBased_test.py │ ├── hyriseBenchmarkJCCH_test.py │ ├── hyriseBenchmarkJoinOrder_test.py │ ├── hyriseBenchmarkTPCC_test.py │ ├── hyriseBenchmarkTPCH_test.py │ └── hyriseConsole_test.py ├── src ├── CMakeFiles │ ├── CMakeDirectoryInformation.cmake │ └── progress.marks ├── CMakeLists.txt ├── Makefile ├── SSB_instructions.md ├── benchmark │ ├── CMakeFiles │ │ ├── CMakeDirectoryInformation.cmake │ │ ├── hyriseBenchmarkFileBased.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseBenchmarkJoinOrder.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseBenchmarkPlayground.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseBenchmarkTPCC.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseBenchmarkTPCDS.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseBenchmarkTPCH.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseMicroBenchmarks.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ └── progress.marks │ ├── CMakeLists.txt │ ├── Makefile │ ├── benchmark_playground.cpp │ ├── cmake_install.cmake │ ├── file_based_benchmark.cpp │ ├── join_order_benchmark.cpp │ ├── micro_benchmark_basic_fixture.cpp │ ├── micro_benchmark_basic_fixture.hpp │ ├── micro_benchmark_main.cpp │ ├── micro_benchmark_utils.cpp │ ├── micro_benchmark_utils.hpp │ ├── operators │ │ ├── aggregate_benchmark.cpp │ │ ├── difference_benchmark.cpp │ │ ├── join_aggregate_benchmark.cpp │ │ ├── join_benchmark.cpp │ │ ├── projection_benchmark.cpp │ │ ├── sort_benchmark.cpp │ │ ├── sql_benchmark.cpp │ │ ├── table_scan_benchmark.cpp │ │ ├── table_scan_sorted_benchmark.cpp │ │ ├── union_all_benchmark.cpp │ │ └── union_positions_benchmark.cpp │ ├── tpcc_benchmark.cpp │ ├── tpcds_benchmark.cpp │ ├── tpch_benchmark.cpp │ ├── tpch_data_micro_benchmark.cpp │ └── tpch_table_generator_benchmark.cpp ├── benchmarklib │ ├── CMakeFiles │ │ ├── CMakeDirectoryInformation.cmake │ │ ├── hyriseBenchmarkLib.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── cmake_clean_target.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ └── progress.marks │ ├── CMakeLists.txt │ ├── Makefile │ ├── abstract_benchmark_item_runner.cpp │ ├── abstract_benchmark_item_runner.hpp │ ├── abstract_table_generator.cpp │ ├── abstract_table_generator.hpp │ ├── benchmark_config.cpp │ ├── benchmark_config.hpp │ ├── benchmark_item_result.cpp │ ├── benchmark_item_result.hpp │ ├── benchmark_item_run_result.cpp │ ├── benchmark_item_run_result.hpp │ ├── benchmark_runner.cpp │ ├── benchmark_runner.hpp │ ├── benchmark_sql_executor.cpp │ ├── benchmark_sql_executor.hpp │ ├── benchmark_state.cpp │ ├── benchmark_state.hpp │ ├── benchmark_table_encoder.cpp │ ├── benchmark_table_encoder.hpp │ ├── cli_config_parser.cpp │ ├── cli_config_parser.hpp │ ├── cmake_install.cmake │ ├── encoding_config.cpp │ ├── encoding_config.hpp │ ├── file_based_benchmark_item_runner.cpp │ ├── file_based_benchmark_item_runner.hpp │ ├── file_based_table_generator.cpp │ ├── file_based_table_generator.hpp │ ├── jcch │ │ ├── jcch_benchmark_item_runner.cpp │ │ ├── jcch_benchmark_item_runner.hpp │ │ ├── jcch_table_generator.cpp │ │ └── jcch_table_generator.hpp │ ├── random_generator.hpp │ ├── synthetic_table_generator.cpp │ ├── synthetic_table_generator.hpp │ ├── table_builder.hpp │ ├── tpcc │ │ ├── constants.hpp │ │ ├── defines.hpp │ │ ├── procedures │ │ │ ├── abstract_tpcc_procedure.cpp │ │ │ ├── abstract_tpcc_procedure.hpp │ │ │ ├── tpcc_delivery.cpp │ │ │ ├── tpcc_delivery.hpp │ │ │ ├── tpcc_new_order.cpp │ │ │ ├── tpcc_new_order.hpp │ │ │ ├── tpcc_order_status.cpp │ │ │ ├── tpcc_order_status.hpp │ │ │ ├── tpcc_payment.cpp │ │ │ ├── tpcc_payment.hpp │ │ │ ├── tpcc_stock_level.cpp │ │ │ └── tpcc_stock_level.hpp │ │ ├── readme.md │ │ ├── tpcc_benchmark_item_runner.cpp │ │ ├── tpcc_benchmark_item_runner.hpp │ │ ├── tpcc_random_generator.hpp │ │ ├── tpcc_table_generator.cpp │ │ └── tpcc_table_generator.hpp │ ├── tpcds │ │ ├── tpcds_table_generator.cpp │ │ └── tpcds_table_generator.hpp │ └── tpch │ │ ├── tpch_benchmark_item_runner.cpp │ │ ├── tpch_benchmark_item_runner.hpp │ │ ├── tpch_queries.cpp │ │ ├── tpch_queries.hpp │ │ ├── tpch_table_generator.cpp │ │ └── tpch_table_generator.hpp ├── bin │ ├── CMakeFiles │ │ ├── CMakeDirectoryInformation.cmake │ │ ├── hyriseClient.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseConsole.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyrisePlayground.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseServer.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ └── progress.marks │ ├── CMakeLists.txt │ ├── Makefile │ ├── client.cpp │ ├── client.hpp │ ├── cmake_install.cmake │ ├── console │ │ ├── console.cpp │ │ ├── console.hpp │ │ ├── pagination.cpp │ │ └── pagination.hpp │ ├── playground.cpp │ └── server.cpp ├── cmake_install.cmake ├── lib │ ├── CMakeFiles │ │ ├── AlwaysCheckGit.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.internal │ │ │ ├── depend.make │ │ │ └── progress.make │ │ ├── CMakeDirectoryInformation.cmake │ │ ├── hyrise_impl.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── cmake_pch.hxx │ │ │ ├── cmake_pch.hxx.cxx │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── progress.marks │ │ └── resourceLink.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.internal │ │ │ ├── depend.make │ │ │ └── progress.make │ ├── CMakeLists.txt │ ├── Makefile │ ├── all_parameter_variant.cpp │ ├── all_parameter_variant.hpp │ ├── all_type_variant.cpp │ ├── all_type_variant.hpp │ ├── cache │ │ ├── abstract_cache.hpp │ │ └── gdfs_cache.hpp │ ├── cmake_install.cmake │ ├── concurrency │ │ ├── commit_context.cpp │ │ ├── commit_context.hpp │ │ ├── transaction_context.cpp │ │ ├── transaction_context.hpp │ │ ├── transaction_manager.cpp │ │ └── transaction_manager.hpp │ ├── constant_mappings.cpp │ ├── constant_mappings.hpp │ ├── cost_estimation │ │ ├── abstract_cost_estimator.cpp │ │ ├── abstract_cost_estimator.hpp │ │ ├── cost_estimator_logical.cpp │ │ └── cost_estimator_logical.hpp │ ├── expression │ │ ├── abstract_expression.cpp │ │ ├── abstract_expression.hpp │ │ ├── abstract_predicate_expression.cpp │ │ ├── abstract_predicate_expression.hpp │ │ ├── aggregate_expression.cpp │ │ ├── aggregate_expression.hpp │ │ ├── arithmetic_expression.cpp │ │ ├── arithmetic_expression.hpp │ │ ├── between_expression.cpp │ │ ├── between_expression.hpp │ │ ├── binary_predicate_expression.cpp │ │ ├── binary_predicate_expression.hpp │ │ ├── case_expression.cpp │ │ ├── case_expression.hpp │ │ ├── cast_expression.cpp │ │ ├── cast_expression.hpp │ │ ├── correlated_parameter_expression.cpp │ │ ├── correlated_parameter_expression.hpp │ │ ├── evaluation │ │ │ ├── expression_evaluator.cpp │ │ │ ├── expression_evaluator.hpp │ │ │ ├── expression_functors.hpp │ │ │ ├── expression_result.hpp │ │ │ ├── expression_result_views.hpp │ │ │ ├── like_matcher.cpp │ │ │ └── like_matcher.hpp │ │ ├── exists_expression.cpp │ │ ├── exists_expression.hpp │ │ ├── expression_functional.cpp │ │ ├── expression_functional.hpp │ │ ├── expression_precedence.hpp │ │ ├── expression_utils.cpp │ │ ├── expression_utils.hpp │ │ ├── extract_expression.cpp │ │ ├── extract_expression.hpp │ │ ├── function_expression.cpp │ │ ├── function_expression.hpp │ │ ├── in_expression.cpp │ │ ├── in_expression.hpp │ │ ├── is_null_expression.cpp │ │ ├── is_null_expression.hpp │ │ ├── list_expression.cpp │ │ ├── list_expression.hpp │ │ ├── logical_expression.cpp │ │ ├── logical_expression.hpp │ │ ├── lqp_column_expression.cpp │ │ ├── lqp_column_expression.hpp │ │ ├── lqp_subquery_expression.cpp │ │ ├── lqp_subquery_expression.hpp │ │ ├── placeholder_expression.cpp │ │ ├── placeholder_expression.hpp │ │ ├── pqp_column_expression.cpp │ │ ├── pqp_column_expression.hpp │ │ ├── pqp_subquery_expression.cpp │ │ ├── pqp_subquery_expression.hpp │ │ ├── unary_minus_expression.cpp │ │ ├── unary_minus_expression.hpp │ │ ├── value_expression.cpp │ │ └── value_expression.hpp │ ├── git-state │ ├── hyrise.cpp │ ├── hyrise.hpp │ ├── import_export │ │ ├── binary │ │ │ ├── binary_parser.cpp │ │ │ ├── binary_parser.hpp │ │ │ ├── binary_writer.cpp │ │ │ └── binary_writer.hpp │ │ ├── csv │ │ │ ├── csv_converter.cpp │ │ │ ├── csv_converter.hpp │ │ │ ├── csv_meta.cpp │ │ │ ├── csv_meta.hpp │ │ │ ├── csv_parser.cpp │ │ │ ├── csv_parser.hpp │ │ │ ├── csv_writer.cpp │ │ │ └── csv_writer.hpp │ │ ├── file_type.cpp │ │ └── file_type.hpp │ ├── logical_query_plan │ │ ├── abstract_lqp_node.cpp │ │ ├── abstract_lqp_node.hpp │ │ ├── abstract_non_query_node.cpp │ │ ├── abstract_non_query_node.hpp │ │ ├── aggregate_node.cpp │ │ ├── aggregate_node.hpp │ │ ├── alias_node.cpp │ │ ├── alias_node.hpp │ │ ├── change_meta_table_node.cpp │ │ ├── change_meta_table_node.hpp │ │ ├── create_prepared_plan_node.cpp │ │ ├── create_prepared_plan_node.hpp │ │ ├── create_table_node.cpp │ │ ├── create_table_node.hpp │ │ ├── create_view_node.cpp │ │ ├── create_view_node.hpp │ │ ├── delete_node.cpp │ │ ├── delete_node.hpp │ │ ├── drop_table_node.cpp │ │ ├── drop_table_node.hpp │ │ ├── drop_view_node.cpp │ │ ├── drop_view_node.hpp │ │ ├── dummy_table_node.cpp │ │ ├── dummy_table_node.hpp │ │ ├── enable_make_for_lqp_node.hpp │ │ ├── except_node.cpp │ │ ├── except_node.hpp │ │ ├── export_node.cpp │ │ ├── export_node.hpp │ │ ├── functional_dependency.cpp │ │ ├── functional_dependency.hpp │ │ ├── import_node.cpp │ │ ├── import_node.hpp │ │ ├── insert_node.cpp │ │ ├── insert_node.hpp │ │ ├── intersect_node.cpp │ │ ├── intersect_node.hpp │ │ ├── join_node.cpp │ │ ├── join_node.hpp │ │ ├── limit_node.cpp │ │ ├── limit_node.hpp │ │ ├── logical_plan_root_node.cpp │ │ ├── logical_plan_root_node.hpp │ │ ├── lqp_translator.cpp │ │ ├── lqp_translator.hpp │ │ ├── lqp_unique_constraint.cpp │ │ ├── lqp_unique_constraint.hpp │ │ ├── lqp_utils.cpp │ │ ├── lqp_utils.hpp │ │ ├── mock_node.cpp │ │ ├── mock_node.hpp │ │ ├── predicate_node.cpp │ │ ├── predicate_node.hpp │ │ ├── projection_node.cpp │ │ ├── projection_node.hpp │ │ ├── sort_node.cpp │ │ ├── sort_node.hpp │ │ ├── static_table_node.cpp │ │ ├── static_table_node.hpp │ │ ├── stored_table_node.cpp │ │ ├── stored_table_node.hpp │ │ ├── union_node.cpp │ │ ├── union_node.hpp │ │ ├── update_node.cpp │ │ ├── update_node.hpp │ │ ├── validate_node.cpp │ │ └── validate_node.hpp │ ├── lossless_cast.cpp │ ├── lossless_cast.hpp │ ├── lossy_cast.hpp │ ├── memory │ │ ├── boost_default_memory_resource.cpp │ │ ├── dram_memory_resource.cpp │ │ ├── dram_memory_resource.hpp │ │ ├── kind_memory_manager.cpp │ │ ├── kind_memory_manager.hpp │ │ ├── nvm_memory_resource.cpp │ │ └── nvm_memory_resource.hpp │ ├── null_value.hpp │ ├── operators │ │ ├── abstract_aggregate_operator.cpp │ │ ├── abstract_aggregate_operator.hpp │ │ ├── abstract_join_operator.cpp │ │ ├── abstract_join_operator.hpp │ │ ├── abstract_operator.cpp │ │ ├── abstract_operator.hpp │ │ ├── abstract_read_only_operator.cpp │ │ ├── abstract_read_only_operator.hpp │ │ ├── abstract_read_write_operator.cpp │ │ ├── abstract_read_write_operator.hpp │ │ ├── aggregate │ │ │ └── aggregate_traits.hpp │ │ ├── aggregate_hash.cpp │ │ ├── aggregate_hash.hpp │ │ ├── aggregate_sort.cpp │ │ ├── aggregate_sort.hpp │ │ ├── alias_operator.cpp │ │ ├── alias_operator.hpp │ │ ├── change_meta_table.cpp │ │ ├── change_meta_table.hpp │ │ ├── delete.cpp │ │ ├── delete.hpp │ │ ├── difference.cpp │ │ ├── difference.hpp │ │ ├── export.cpp │ │ ├── export.hpp │ │ ├── get_table.cpp │ │ ├── get_table.hpp │ │ ├── import.cpp │ │ ├── import.hpp │ │ ├── index_scan.cpp │ │ ├── index_scan.hpp │ │ ├── insert.cpp │ │ ├── insert.hpp │ │ ├── join_hash.cpp │ │ ├── join_hash.hpp │ │ ├── join_hash │ │ │ ├── join_hash_steps.hpp │ │ │ └── join_hash_traits.hpp │ │ ├── join_index.cpp │ │ ├── join_index.hpp │ │ ├── join_nested_loop.cpp │ │ ├── join_nested_loop.hpp │ │ ├── join_sort_merge.cpp │ │ ├── join_sort_merge.hpp │ │ ├── join_sort_merge │ │ │ ├── column_materializer.hpp │ │ │ └── radix_cluster_sort.hpp │ │ ├── join_verification.cpp │ │ ├── join_verification.hpp │ │ ├── limit.cpp │ │ ├── limit.hpp │ │ ├── maintenance │ │ │ ├── create_prepared_plan.cpp │ │ │ ├── create_prepared_plan.hpp │ │ │ ├── create_table.cpp │ │ │ ├── create_table.hpp │ │ │ ├── create_view.cpp │ │ │ ├── create_view.hpp │ │ │ ├── drop_table.cpp │ │ │ ├── drop_table.hpp │ │ │ ├── drop_view.cpp │ │ │ └── drop_view.hpp │ │ ├── multi_predicate_join │ │ │ ├── multi_predicate_join_evaluator.cpp │ │ │ └── multi_predicate_join_evaluator.hpp │ │ ├── operator_join_predicate.cpp │ │ ├── operator_join_predicate.hpp │ │ ├── operator_performance_data.cpp │ │ ├── operator_performance_data.hpp │ │ ├── operator_scan_predicate.cpp │ │ ├── operator_scan_predicate.hpp │ │ ├── pqp_utils.hpp │ │ ├── print.cpp │ │ ├── print.hpp │ │ ├── product.cpp │ │ ├── product.hpp │ │ ├── projection.cpp │ │ ├── projection.hpp │ │ ├── sort.cpp │ │ ├── sort.hpp │ │ ├── table_scan.cpp │ │ ├── table_scan.hpp │ │ ├── table_scan │ │ │ ├── abstract_dereferenced_column_table_scan_impl.cpp │ │ │ ├── abstract_dereferenced_column_table_scan_impl.hpp │ │ │ ├── abstract_table_scan_impl.hpp │ │ │ ├── column_between_table_scan_impl.cpp │ │ │ ├── column_between_table_scan_impl.hpp │ │ │ ├── column_is_null_table_scan_impl.cpp │ │ │ ├── column_is_null_table_scan_impl.hpp │ │ │ ├── column_like_table_scan_impl.cpp │ │ │ ├── column_like_table_scan_impl.hpp │ │ │ ├── column_vs_column_table_scan_impl.cpp │ │ │ ├── column_vs_column_table_scan_impl.hpp │ │ │ ├── column_vs_value_table_scan_impl.cpp │ │ │ ├── column_vs_value_table_scan_impl.hpp │ │ │ ├── expression_evaluator_table_scan_impl.cpp │ │ │ ├── expression_evaluator_table_scan_impl.hpp │ │ │ └── sorted_segment_search.hpp │ │ ├── table_wrapper.cpp │ │ ├── table_wrapper.hpp │ │ ├── union_all.cpp │ │ ├── union_all.hpp │ │ ├── union_positions.cpp │ │ ├── union_positions.hpp │ │ ├── update.cpp │ │ ├── update.hpp │ │ ├── validate.cpp │ │ └── validate.hpp │ ├── optimizer │ │ ├── join_ordering │ │ │ ├── abstract_join_ordering_algorithm.cpp │ │ │ ├── abstract_join_ordering_algorithm.hpp │ │ │ ├── dp_ccp.cpp │ │ │ ├── dp_ccp.hpp │ │ │ ├── enumerate_ccp.cpp │ │ │ ├── enumerate_ccp.hpp │ │ │ ├── greedy_operator_ordering.cpp │ │ │ ├── greedy_operator_ordering.hpp │ │ │ ├── join_graph.cpp │ │ │ ├── join_graph.hpp │ │ │ ├── join_graph_builder.cpp │ │ │ ├── join_graph_builder.hpp │ │ │ ├── join_graph_edge.cpp │ │ │ └── join_graph_edge.hpp │ │ ├── optimizer.cpp │ │ ├── optimizer.hpp │ │ └── strategy │ │ │ ├── abstract_rule.cpp │ │ │ ├── abstract_rule.hpp │ │ │ ├── between_composition_rule.cpp │ │ │ ├── between_composition_rule.hpp │ │ │ ├── chunk_pruning_rule.cpp │ │ │ ├── chunk_pruning_rule.hpp │ │ │ ├── column_pruning_rule.cpp │ │ │ ├── column_pruning_rule.hpp │ │ │ ├── dependent_group_by_reduction_rule.cpp │ │ │ ├── dependent_group_by_reduction_rule.hpp │ │ │ ├── expression_reduction_rule.cpp │ │ │ ├── expression_reduction_rule.hpp │ │ │ ├── in_expression_rewrite_rule.cpp │ │ │ ├── in_expression_rewrite_rule.hpp │ │ │ ├── index_scan_rule.cpp │ │ │ ├── index_scan_rule.hpp │ │ │ ├── join_ordering_rule.cpp │ │ │ ├── join_ordering_rule.hpp │ │ │ ├── join_predicate_ordering_rule.cpp │ │ │ ├── join_predicate_ordering_rule.hpp │ │ │ ├── predicate_merge_rule.cpp │ │ │ ├── predicate_merge_rule.hpp │ │ │ ├── predicate_placement_rule.cpp │ │ │ ├── predicate_placement_rule.hpp │ │ │ ├── predicate_reordering_rule.cpp │ │ │ ├── predicate_reordering_rule.hpp │ │ │ ├── predicate_split_up_rule.cpp │ │ │ ├── predicate_split_up_rule.hpp │ │ │ ├── semi_join_reduction_rule.cpp │ │ │ ├── semi_join_reduction_rule.hpp │ │ │ ├── stored_table_column_alignment_rule.cpp │ │ │ ├── stored_table_column_alignment_rule.hpp │ │ │ ├── subquery_to_join_rule.cpp │ │ │ └── subquery_to_join_rule.hpp │ ├── resolve_type.hpp │ ├── scheduler │ │ ├── abstract_scheduler.cpp │ │ ├── abstract_scheduler.hpp │ │ ├── abstract_task.cpp │ │ ├── abstract_task.hpp │ │ ├── immediate_execution_scheduler.cpp │ │ ├── immediate_execution_scheduler.hpp │ │ ├── job_task.cpp │ │ ├── job_task.hpp │ │ ├── node_queue_scheduler.cpp │ │ ├── node_queue_scheduler.hpp │ │ ├── operator_task.cpp │ │ ├── operator_task.hpp │ │ ├── task_queue.cpp │ │ ├── task_queue.hpp │ │ ├── topology.cpp │ │ ├── topology.hpp │ │ ├── worker.cpp │ │ └── worker.hpp │ ├── server │ │ ├── client_disconnect_exception.hpp │ │ ├── postgres_message_type.hpp │ │ ├── postgres_protocol_handler.cpp │ │ ├── postgres_protocol_handler.hpp │ │ ├── query_handler.cpp │ │ ├── query_handler.hpp │ │ ├── read_buffer.cpp │ │ ├── read_buffer.hpp │ │ ├── result_serializer.cpp │ │ ├── result_serializer.hpp │ │ ├── ring_buffer_iterator.hpp │ │ ├── server.cpp │ │ ├── server.hpp │ │ ├── server_types.hpp │ │ ├── session.cpp │ │ ├── session.hpp │ │ ├── write_buffer.cpp │ │ └── write_buffer.hpp │ ├── sql │ │ ├── create_sql_parser_error_message.cpp │ │ ├── create_sql_parser_error_message.hpp │ │ ├── parameter_id_allocator.cpp │ │ ├── parameter_id_allocator.hpp │ │ ├── sql_identifier.cpp │ │ ├── sql_identifier.hpp │ │ ├── sql_identifier_resolver.cpp │ │ ├── sql_identifier_resolver.hpp │ │ ├── sql_identifier_resolver_proxy.cpp │ │ ├── sql_identifier_resolver_proxy.hpp │ │ ├── sql_pipeline.cpp │ │ ├── sql_pipeline.hpp │ │ ├── sql_pipeline_builder.cpp │ │ ├── sql_pipeline_builder.hpp │ │ ├── sql_pipeline_statement.cpp │ │ ├── sql_pipeline_statement.hpp │ │ ├── sql_plan_cache.hpp │ │ ├── sql_translator.cpp │ │ └── sql_translator.hpp │ ├── statistics │ │ ├── abstract_cardinality_estimator.cpp │ │ ├── abstract_cardinality_estimator.hpp │ │ ├── attribute_statistics.cpp │ │ ├── attribute_statistics.hpp │ │ ├── base_attribute_statistics.cpp │ │ ├── base_attribute_statistics.hpp │ │ ├── cardinality_estimation_cache.hpp │ │ ├── cardinality_estimator.cpp │ │ ├── cardinality_estimator.hpp │ │ ├── generate_pruning_statistics.cpp │ │ ├── generate_pruning_statistics.hpp │ │ ├── join_graph_statistics_cache.cpp │ │ ├── join_graph_statistics_cache.hpp │ │ ├── statistics_objects │ │ │ ├── abstract_histogram.cpp │ │ │ ├── abstract_histogram.hpp │ │ │ ├── abstract_statistics_object.cpp │ │ │ ├── abstract_statistics_object.hpp │ │ │ ├── equal_distinct_count_histogram.cpp │ │ │ ├── equal_distinct_count_histogram.hpp │ │ │ ├── generic_histogram.cpp │ │ │ ├── generic_histogram.hpp │ │ │ ├── generic_histogram_builder.cpp │ │ │ ├── generic_histogram_builder.hpp │ │ │ ├── histogram_domain.cpp │ │ │ ├── histogram_domain.hpp │ │ │ ├── min_max_filter.cpp │ │ │ ├── min_max_filter.hpp │ │ │ ├── null_value_ratio_statistics.cpp │ │ │ ├── null_value_ratio_statistics.hpp │ │ │ ├── range_filter.cpp │ │ │ └── range_filter.hpp │ │ ├── table_statistics.cpp │ │ └── table_statistics.hpp │ ├── storage │ │ ├── abstract_encoded_segment.cpp │ │ ├── abstract_encoded_segment.hpp │ │ ├── abstract_segment.cpp │ │ ├── abstract_segment.hpp │ │ ├── abstract_table_constraint.cpp │ │ ├── abstract_table_constraint.hpp │ │ ├── base_dictionary_segment.hpp │ │ ├── base_segment_accessor.hpp │ │ ├── base_segment_encoder.hpp │ │ ├── base_value_segment.hpp │ │ ├── chunk.cpp │ │ ├── chunk.hpp │ │ ├── chunk_encoder.cpp │ │ ├── chunk_encoder.hpp │ │ ├── create_iterable_from_reference_segment.ipp │ │ ├── create_iterable_from_segment.hpp │ │ ├── create_iterable_from_segment.ipp │ │ ├── dictionary_segment.cpp │ │ ├── dictionary_segment.hpp │ │ ├── dictionary_segment │ │ │ ├── attribute_vector_iterable.hpp │ │ │ ├── dictionary_encoder.hpp │ │ │ └── dictionary_segment_iterable.hpp │ │ ├── encoding_type.cpp │ │ ├── encoding_type.hpp │ │ ├── fixed_string_dictionary_segment.cpp │ │ ├── fixed_string_dictionary_segment.hpp │ │ ├── fixed_string_dictionary_segment │ │ │ ├── fixed_string.cpp │ │ │ ├── fixed_string.hpp │ │ │ ├── fixed_string_vector.cpp │ │ │ ├── fixed_string_vector.hpp │ │ │ └── fixed_string_vector_iterator.hpp │ │ ├── frame_of_reference_segment.cpp │ │ ├── frame_of_reference_segment.hpp │ │ ├── frame_of_reference_segment │ │ │ ├── frame_of_reference_encoder.hpp │ │ │ └── frame_of_reference_segment_iterable.hpp │ │ ├── index │ │ │ ├── abstract_index.cpp │ │ │ ├── abstract_index.hpp │ │ │ ├── adaptive_radix_tree │ │ │ │ ├── adaptive_radix_tree_index.cpp │ │ │ │ ├── adaptive_radix_tree_index.hpp │ │ │ │ ├── adaptive_radix_tree_nodes.cpp │ │ │ │ └── adaptive_radix_tree_nodes.hpp │ │ │ ├── b_tree │ │ │ │ ├── b_tree_index.cpp │ │ │ │ ├── b_tree_index.hpp │ │ │ │ ├── b_tree_index_impl.cpp │ │ │ │ └── b_tree_index_impl.hpp │ │ │ ├── group_key │ │ │ │ ├── composite_group_key_index.cpp │ │ │ │ ├── composite_group_key_index.hpp │ │ │ │ ├── group_key_index.cpp │ │ │ │ ├── group_key_index.hpp │ │ │ │ ├── variable_length_key.cpp │ │ │ │ ├── variable_length_key.hpp │ │ │ │ ├── variable_length_key_base.cpp │ │ │ │ ├── variable_length_key_base.hpp │ │ │ │ ├── variable_length_key_proxy.cpp │ │ │ │ ├── variable_length_key_proxy.hpp │ │ │ │ ├── variable_length_key_store.cpp │ │ │ │ └── variable_length_key_store.hpp │ │ │ ├── index_statistics.cpp │ │ │ ├── index_statistics.hpp │ │ │ └── segment_index_type.hpp │ │ ├── lqp_view.cpp │ │ ├── lqp_view.hpp │ │ ├── lz4_segment.cpp │ │ ├── lz4_segment.hpp │ │ ├── lz4_segment │ │ │ ├── lz4_encoder.hpp │ │ │ └── lz4_segment_iterable.hpp │ │ ├── materialize.hpp │ │ ├── mvcc_data.cpp │ │ ├── mvcc_data.hpp │ │ ├── pos_lists │ │ │ ├── abstract_pos_list.cpp │ │ │ ├── abstract_pos_list.hpp │ │ │ ├── entire_chunk_pos_list.cpp │ │ │ ├── entire_chunk_pos_list.hpp │ │ │ ├── row_id_pos_list.cpp │ │ │ └── row_id_pos_list.hpp │ │ ├── prepared_plan.cpp │ │ ├── prepared_plan.hpp │ │ ├── reference_segment.cpp │ │ ├── reference_segment.hpp │ │ ├── reference_segment │ │ │ └── reference_segment_iterable.hpp │ │ ├── resolve_encoded_segment_type.hpp │ │ ├── run_length_segment.cpp │ │ ├── run_length_segment.hpp │ │ ├── run_length_segment │ │ │ ├── run_length_encoder.hpp │ │ │ └── run_length_segment_iterable.hpp │ │ ├── segment_access_counter.cpp │ │ ├── segment_access_counter.hpp │ │ ├── segment_accessor.cpp │ │ ├── segment_accessor.hpp │ │ ├── segment_encoding_utils.cpp │ │ ├── segment_encoding_utils.hpp │ │ ├── segment_iterables.hpp │ │ ├── segment_iterables │ │ │ ├── abstract_segment_iterators.hpp │ │ │ ├── any_segment_iterable.cpp │ │ │ ├── any_segment_iterable.hpp │ │ │ ├── any_segment_iterator.hpp │ │ │ ├── create_iterable_from_attribute_vector.hpp │ │ │ └── segment_positions.hpp │ │ ├── segment_iterate.hpp │ │ ├── split_pos_list_by_chunk_id.cpp │ │ ├── split_pos_list_by_chunk_id.hpp │ │ ├── storage_manager.cpp │ │ ├── storage_manager.hpp │ │ ├── table.cpp │ │ ├── table.hpp │ │ ├── table_column_definition.cpp │ │ ├── table_column_definition.hpp │ │ ├── table_key_constraint.cpp │ │ ├── table_key_constraint.hpp │ │ ├── value_segment.cpp │ │ ├── value_segment.hpp │ │ ├── value_segment │ │ │ ├── null_value_vector_iterable.hpp │ │ │ └── value_segment_iterable.hpp │ │ └── vector_compression │ │ │ ├── base_compressed_vector.hpp │ │ │ ├── base_vector_compressor.hpp │ │ │ ├── base_vector_decompressor.hpp │ │ │ ├── compressed_vector_type.hpp │ │ │ ├── fixed_size_byte_aligned │ │ │ ├── fixed_size_byte_aligned_compressor.cpp │ │ │ ├── fixed_size_byte_aligned_compressor.hpp │ │ │ ├── fixed_size_byte_aligned_decompressor.hpp │ │ │ ├── fixed_size_byte_aligned_utils.hpp │ │ │ └── fixed_size_byte_aligned_vector.hpp │ │ │ ├── resolve_compressed_vector_type.hpp │ │ │ ├── simd_bp128 │ │ │ ├── oversized_types.hpp │ │ │ ├── simd_bp128_compressor.cpp │ │ │ ├── simd_bp128_compressor.hpp │ │ │ ├── simd_bp128_decompressor.cpp │ │ │ ├── simd_bp128_decompressor.hpp │ │ │ ├── simd_bp128_iterator.cpp │ │ │ ├── simd_bp128_iterator.hpp │ │ │ ├── simd_bp128_packing.cpp │ │ │ ├── simd_bp128_packing.hpp │ │ │ ├── simd_bp128_vector.cpp │ │ │ └── simd_bp128_vector.hpp │ │ │ ├── vector_compression.cpp │ │ │ └── vector_compression.hpp │ ├── strong_typedef.hpp │ ├── tasks │ │ ├── chunk_compression_task.cpp │ │ └── chunk_compression_task.hpp │ ├── type_comparison.hpp │ ├── types.cpp │ ├── types.hpp │ ├── uid_allocator.hpp │ ├── utils │ │ ├── abstract_plugin.hpp │ │ ├── aligned_size.hpp │ │ ├── assert.hpp │ │ ├── boost_bimap_core_override.hpp │ │ ├── boost_curry_override.hpp │ │ ├── check_table_equal.cpp │ │ ├── check_table_equal.hpp │ │ ├── column_ids_after_pruning.cpp │ │ ├── column_ids_after_pruning.hpp │ │ ├── copyable_atomic.hpp │ │ ├── enum_constant.hpp │ │ ├── format_bytes.cpp │ │ ├── format_bytes.hpp │ │ ├── format_duration.cpp │ │ ├── format_duration.hpp │ │ ├── invalid_input_exception.hpp │ │ ├── list_directory.cpp │ │ ├── list_directory.hpp │ │ ├── load_table.cpp │ │ ├── load_table.hpp │ │ ├── log_manager.cpp │ │ ├── log_manager.hpp │ │ ├── lossless_predicate_cast.cpp │ │ ├── lossless_predicate_cast.hpp │ │ ├── make_bimap.hpp │ │ ├── meta_table_manager.cpp │ │ ├── meta_table_manager.hpp │ │ ├── meta_tables │ │ │ ├── abstract_meta_table.cpp │ │ │ ├── abstract_meta_table.hpp │ │ │ ├── meta_chunk_sort_orders_table.cpp │ │ │ ├── meta_chunk_sort_orders_table.hpp │ │ │ ├── meta_chunks_table.cpp │ │ │ ├── meta_chunks_table.hpp │ │ │ ├── meta_columns_table.cpp │ │ │ ├── meta_columns_table.hpp │ │ │ ├── meta_log_table.cpp │ │ │ ├── meta_log_table.hpp │ │ │ ├── meta_plugins_table.cpp │ │ │ ├── meta_plugins_table.hpp │ │ │ ├── meta_segments_accurate_table.cpp │ │ │ ├── meta_segments_accurate_table.hpp │ │ │ ├── meta_segments_table.cpp │ │ │ ├── meta_segments_table.hpp │ │ │ ├── meta_settings_table.cpp │ │ │ ├── meta_settings_table.hpp │ │ │ ├── meta_system_information_table.cpp │ │ │ ├── meta_system_information_table.hpp │ │ │ ├── meta_system_utilization_table.cpp │ │ │ ├── meta_system_utilization_table.hpp │ │ │ ├── meta_tables_table.cpp │ │ │ ├── meta_tables_table.hpp │ │ │ ├── segment_meta_data.cpp │ │ │ └── segment_meta_data.hpp │ │ ├── pausable_loop_thread.cpp │ │ ├── pausable_loop_thread.hpp │ │ ├── performance_warning.cpp │ │ ├── performance_warning.hpp │ │ ├── plugin_manager.cpp │ │ ├── plugin_manager.hpp │ │ ├── print_directed_acyclic_graph.hpp │ │ ├── settings │ │ │ ├── abstract_setting.cpp │ │ │ └── abstract_setting.hpp │ │ ├── settings_manager.cpp │ │ ├── settings_manager.hpp │ │ ├── singleton.hpp │ │ ├── size_estimation_utils.hpp │ │ ├── sqlite_add_indices.cpp │ │ ├── sqlite_add_indices.hpp │ │ ├── sqlite_wrapper.cpp │ │ ├── sqlite_wrapper.hpp │ │ ├── string_utils.cpp │ │ ├── string_utils.hpp │ │ ├── template_type.hpp │ │ ├── timer.cpp │ │ ├── timer.hpp │ │ └── tracing │ │ │ └── probes.hpp │ ├── version.hpp.in │ └── visualization │ │ ├── abstract_visualizer.hpp │ │ ├── join_graph_visualizer.cpp │ │ ├── join_graph_visualizer.hpp │ │ ├── lqp_visualizer.cpp │ │ ├── lqp_visualizer.hpp │ │ ├── pqp_visualizer.cpp │ │ ├── pqp_visualizer.hpp │ │ ├── viz_record_layout.cpp │ │ └── viz_record_layout.hpp ├── plugins │ ├── CMakeFiles │ │ ├── CMakeDirectoryInformation.cmake │ │ ├── hyriseMvccDeletePlugin.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseTestNonInstantiablePlugin.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseTestPlugin.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ ├── hyriseTieringPlugin.dir │ │ │ ├── DependInfo.cmake │ │ │ ├── build.make │ │ │ ├── cmake_clean.cmake │ │ │ ├── depend.make │ │ │ ├── flags.make │ │ │ ├── link.txt │ │ │ └── progress.make │ │ └── progress.marks │ ├── CMakeLists.txt │ ├── Makefile │ ├── cmake_install.cmake │ ├── mvcc_delete_plugin.cpp │ ├── mvcc_delete_plugin.hpp │ ├── non_instantiable_plugin.cpp │ ├── test_plugin.cpp │ └── test_plugin.hpp └── test │ ├── CMakeFiles │ ├── CMakeDirectoryInformation.cmake │ ├── hyriseSystemTest.dir │ │ ├── DependInfo.cmake │ │ ├── build.make │ │ ├── cmake_clean.cmake │ │ ├── depend.make │ │ ├── flags.make │ │ ├── link.txt │ │ └── progress.make │ ├── hyriseTest.dir │ │ ├── DependInfo.cmake │ │ ├── build.make │ │ ├── cmake_clean.cmake │ │ ├── cmake_pch.hxx │ │ ├── cmake_pch.hxx.cxx │ │ ├── depend.make │ │ ├── flags.make │ │ ├── link.txt │ │ └── progress.make │ └── progress.marks │ ├── CMakeLists.txt │ ├── Makefile │ ├── base_test.cpp │ ├── base_test.hpp │ ├── benchmarklib │ ├── sqlite_add_indices_test.cpp │ ├── synthetic_table_generator_test.cpp │ ├── table_builder_test.cpp │ ├── tpcc │ │ └── tpcc_test.cpp │ ├── tpcds │ │ └── tpcds_db_generator_test.cpp │ └── tpch │ │ └── tpch_db_generator_test.cpp │ ├── cmake_install.cmake │ ├── gtest_case_template.cpp │ ├── gtest_main.cpp │ ├── lib │ ├── all_parameter_variant_test.cpp │ ├── all_type_variant_test.cpp │ ├── cache │ │ └── cache_test.cpp │ ├── concurrency │ │ ├── commit_context_test.cpp │ │ ├── stress_test.cpp │ │ ├── transaction_context_test.cpp │ │ └── transaction_manager_test.cpp │ ├── cost_estimation │ │ └── abstract_cost_estimator_test.cpp │ ├── expression │ │ ├── evaluation │ │ │ ├── expression_result_test.cpp │ │ │ └── like_matcher_test.cpp │ │ ├── expression_evaluator_to_pos_list_test.cpp │ │ ├── expression_evaluator_to_values_test.cpp │ │ ├── expression_test.cpp │ │ ├── expression_utils_test.cpp │ │ ├── lqp_subquery_expression_test.cpp │ │ └── pqp_subquery_expression_test.cpp │ ├── hyrise_test.cpp │ ├── import_export │ │ ├── binary │ │ │ ├── binary_parser_test.cpp │ │ │ └── binary_writer_test.cpp │ │ └── csv │ │ │ ├── csv_meta_test.cpp │ │ │ ├── csv_parser_test.cpp │ │ │ └── csv_writer_test.cpp │ ├── logical_query_plan │ │ ├── aggregate_node_test.cpp │ │ ├── alias_node_test.cpp │ │ ├── change_meta_table_node_test.cpp │ │ ├── create_prepared_plan_node_test.cpp │ │ ├── create_table_node_test.cpp │ │ ├── create_view_node_test.cpp │ │ ├── delete_node_test.cpp │ │ ├── drop_table_node_test.cpp │ │ ├── drop_view_node_test.cpp │ │ ├── dummy_table_node_test.cpp │ │ ├── except_node_test.cpp │ │ ├── export_node_test.cpp │ │ ├── functional_dependency_test.cpp │ │ ├── import_node_test.cpp │ │ ├── insert_node_test.cpp │ │ ├── intersect_node_test.cpp │ │ ├── join_node_test.cpp │ │ ├── limit_node_test.cpp │ │ ├── logical_query_plan_test.cpp │ │ ├── lqp_find_subplan_mismatch_test.cpp │ │ ├── lqp_translator_test.cpp │ │ ├── lqp_unique_constraint_test.cpp │ │ ├── lqp_utils_test.cpp │ │ ├── mock_node_test.cpp │ │ ├── predicate_node_test.cpp │ │ ├── projection_node_test.cpp │ │ ├── sort_node_test.cpp │ │ ├── static_table_node_test.cpp │ │ ├── stored_table_node_test.cpp │ │ ├── union_node_test.cpp │ │ ├── update_node_test.cpp │ │ └── validate_node_test.cpp │ ├── lossless_cast_test.cpp │ ├── lossy_cast_test.cpp │ ├── memory │ │ └── segments_using_allocators_test.cpp │ ├── null_value_test.cpp │ ├── operators │ │ ├── aggregate_sort_test.cpp │ │ ├── aggregate_test.cpp │ │ ├── alias_operator_test.cpp │ │ ├── change_meta_table_test.cpp │ │ ├── delete_test.cpp │ │ ├── difference_test.cpp │ │ ├── export_test.cpp │ │ ├── get_table_test.cpp │ │ ├── import_test.cpp │ │ ├── index_scan_test.cpp │ │ ├── insert_test.cpp │ │ ├── join_hash │ │ │ ├── join_hash_steps_test.cpp │ │ │ ├── join_hash_traits_test.cpp │ │ │ └── join_hash_types_test.cpp │ │ ├── join_hash_test.cpp │ │ ├── join_index_test.cpp │ │ ├── join_nested_loop_test.cpp │ │ ├── join_sort_merge_test.cpp │ │ ├── join_test_runner.cpp │ │ ├── join_verification_test.cpp │ │ ├── limit_test.cpp │ │ ├── maintenance │ │ │ ├── create_prepared_plan_test.cpp │ │ │ ├── create_table_test.cpp │ │ │ ├── create_view_test.cpp │ │ │ ├── drop_table_test.cpp │ │ │ └── drop_view_test.cpp │ │ ├── operator_deep_copy_test.cpp │ │ ├── operator_join_predicate_test.cpp │ │ ├── operator_performance_data_test.cpp │ │ ├── operator_scan_predicate_test.cpp │ │ ├── pqp_utils_test.cpp │ │ ├── print_test.cpp │ │ ├── product_test.cpp │ │ ├── projection_test.cpp │ │ ├── sort_test.cpp │ │ ├── table_scan_between_test.cpp │ │ ├── table_scan_sorted_segment_search_test.cpp │ │ ├── table_scan_string_test.cpp │ │ ├── table_scan_test.cpp │ │ ├── typed_operator_base_test.hpp │ │ ├── union_all_test.cpp │ │ ├── union_positions_test.cpp │ │ ├── update_test.cpp │ │ ├── validate_test.cpp │ │ └── validate_visibility_test.cpp │ ├── optimizer │ │ ├── join_ordering │ │ │ ├── dp_ccp_test.cpp │ │ │ ├── enumerate_ccp_test.cpp │ │ │ ├── greedy_operator_ordering_test.cpp │ │ │ ├── join_graph_builder_test.cpp │ │ │ └── join_graph_test.cpp │ │ ├── optimizer_test.cpp │ │ └── strategy │ │ │ ├── between_composition_rule_test.cpp │ │ │ ├── chunk_pruning_rule_test.cpp │ │ │ ├── column_pruning_rule_test.cpp │ │ │ ├── dependent_group_by_reduction_rule_test.cpp │ │ │ ├── expression_reduction_rule_test.cpp │ │ │ ├── in_expression_rewrite_rule_test.cpp │ │ │ ├── index_scan_rule_test.cpp │ │ │ ├── join_ordering_rule_test.cpp │ │ │ ├── join_predicate_ordering_rule_test.cpp │ │ │ ├── predicate_merge_rule_test.cpp │ │ │ ├── predicate_placement_rule_test.cpp │ │ │ ├── predicate_reordering_rule_test.cpp │ │ │ ├── predicate_split_up_rule_test.cpp │ │ │ ├── semi_join_reduction_rule_test.cpp │ │ │ ├── stored_table_column_alignment_rule_test.cpp │ │ │ ├── strategy_base_test.cpp │ │ │ ├── strategy_base_test.hpp │ │ │ └── subquery_to_join_rule_test.cpp │ ├── scheduler │ │ ├── operator_task_test.cpp │ │ └── scheduler_test.cpp │ ├── server │ │ ├── mock_socket.hpp │ │ ├── postgres_protocol_handler_test.cpp │ │ ├── query_handler_test.cpp │ │ ├── read_buffer_test.cpp │ │ ├── result_serializer_test.cpp │ │ ├── server_test_runner.cpp │ │ ├── transaction_handling_test.cpp │ │ └── write_buffer_test.cpp │ ├── sql │ │ ├── sql_identifier_resolver_test.cpp │ │ ├── sql_pipeline_statement_test.cpp │ │ ├── sql_pipeline_test.cpp │ │ ├── sql_plan_cache_test.cpp │ │ ├── sql_translator_test.cpp │ │ └── sqlite_testrunner │ │ │ ├── sqlite_testrunner.cpp │ │ │ ├── sqlite_testrunner.hpp │ │ │ ├── sqlite_testrunner_encodings.cpp │ │ │ ├── sqlite_testrunner_unencoded.cpp │ │ │ └── sqlite_wrapper_test.cpp │ ├── statistics │ │ ├── attribute_statistics_test.cpp │ │ ├── cardinality_estimator_test.cpp │ │ ├── join_graph_statistics_cache_test.cpp │ │ ├── statistics_objects │ │ │ ├── equal_distinct_count_histogram_test.cpp │ │ │ ├── generic_histogram_test.cpp │ │ │ ├── min_max_filter_test.cpp │ │ │ ├── range_filter_test.cpp │ │ │ └── string_histogram_domain_test.cpp │ │ └── table_statistics_test.cpp │ ├── storage │ │ ├── any_segment_iterable_test.cpp │ │ ├── chunk_encoder_test.cpp │ │ ├── chunk_test.cpp │ │ ├── compressed_vector_test.cpp │ │ ├── dictionary_segment_test.cpp │ │ ├── encoded_segment_test.cpp │ │ ├── encoded_string_segment_test.cpp │ │ ├── encoding_test.hpp │ │ ├── fixed_string_dictionary_segment │ │ │ ├── fixed_string_test.cpp │ │ │ └── fixed_string_vector_test.cpp │ │ ├── fixed_string_dictionary_segment_test.cpp │ │ ├── index │ │ │ ├── adaptive_radix_tree │ │ │ │ └── adaptive_radix_tree_index_test.cpp │ │ │ ├── b_tree │ │ │ │ └── b_tree_index_test.cpp │ │ │ ├── group_key │ │ │ │ ├── composite_group_key_index_test.cpp │ │ │ │ ├── group_key_index_test.cpp │ │ │ │ ├── variable_length_key_base_test.cpp │ │ │ │ ├── variable_length_key_store_test.cpp │ │ │ │ └── variable_length_key_test.cpp │ │ │ ├── multi_segment_index_test.cpp │ │ │ └── single_segment_index_test.cpp │ │ ├── iterables_test.cpp │ │ ├── lz4_segment_test.cpp │ │ ├── materialize_test.cpp │ │ ├── pos_lists │ │ │ └── entire_chunk_pos_list_test.cpp │ │ ├── prepared_plan_test.cpp │ │ ├── reference_segment_test.cpp │ │ ├── segment_access_counter_test.cpp │ │ ├── segment_accessor_test.cpp │ │ ├── segment_iterators_test.cpp │ │ ├── storage_manager_test.cpp │ │ ├── table_column_definition_test.cpp │ │ ├── table_key_constraint_test.cpp │ │ ├── table_test.cpp │ │ ├── value_segment_test.cpp │ │ └── vector_compression │ │ │ └── simd_bp128 │ │ │ └── simd_bp128_test.cpp │ ├── tasks │ │ └── chunk_compression_task_test.cpp │ └── utils │ │ ├── check_table_equal_test.cpp │ │ ├── column_ids_after_pruning_test.cpp │ │ ├── format_bytes_test.cpp │ │ ├── format_duration_test.cpp │ │ ├── load_table_test.cpp │ │ ├── log_manager_test.cpp │ │ ├── lossless_predicate_cast_test.cpp │ │ ├── meta_table_manager_test.cpp │ │ ├── meta_tables │ │ ├── meta_log_table_test.cpp │ │ ├── meta_mock_table.cpp │ │ ├── meta_mock_table.hpp │ │ ├── meta_plugins_table_test.cpp │ │ ├── meta_settings_table_test.cpp │ │ ├── meta_system_utilization_table_test.cpp │ │ └── meta_table_test.cpp │ │ ├── mock_setting.cpp │ │ ├── mock_setting.hpp │ │ ├── plugin_manager_test.cpp │ │ ├── plugin_test_utils.cpp │ │ ├── plugin_test_utils.hpp │ │ ├── setting_test.cpp │ │ ├── settings_manager_test.cpp │ │ ├── singleton_test.cpp │ │ ├── size_estimation_utils_test.cpp │ │ └── string_utils_test.cpp │ ├── operators │ └── alias_operator_test.cpp │ ├── plugins │ ├── mvcc_delete_plugin_system_test.cpp │ └── mvcc_delete_plugin_test.cpp │ ├── testing_assert.cpp │ ├── testing_assert.hpp │ └── utils │ └── constraint_test_utils.hpp └── version.hpp /.gitignore: -------------------------------------------------------------------------------- 1 | cmake-build-* 2 | .idea/ 3 | venv/ 4 | dash/ 5 | .vscode/ 6 | 7 | # Created by .ignore support plugin (hsz.mobi) 8 | ### C++ template 9 | # Prerequisites 10 | *.d 11 | 12 | # Compiled Object files 13 | *.slo 14 | *.lo 15 | *.o 16 | *.obj 17 | 18 | # Precompiled Headers 19 | *.gch 20 | *.pch 21 | 22 | # Compiled Dynamic libraries 23 | *.so 24 | *.dylib 25 | *.dll 26 | 27 | # Fortran module files 28 | *.mod 29 | *.smod 30 | 31 | # Compiled Static libraries 32 | *.lai 33 | *.la 34 | *.a 35 | *.lib 36 | 37 | # Executables 38 | *.exe 39 | *.out 40 | *.app 41 | # Latex build files 42 | *.aux 43 | *.fdb_latexmk 44 | *.fls 45 | *.log 46 | *.gz 47 | *.bbl 48 | *.blg 49 | -------------------------------------------------------------------------------- /microbenchmarks/include/parsing.h: -------------------------------------------------------------------------------- 1 | #ifndef NVM_DB_BENCHMARK_INCLUDE_PARSING_H 2 | #define NVM_DB_BENCHMARK_INCLUDE_PARSING_H 3 | 4 | #include "common.h" 5 | 6 | int parse_input(int argc, char** argv, int* operation_count, struct access_info* p_ac_infos, int operation_limit); 7 | 8 | void set_thread_function(struct access_info *ac_info); 9 | 10 | #endif -------------------------------------------------------------------------------- /microbenchmarks/include/pmem_mapping.h: -------------------------------------------------------------------------------- 1 | #ifndef NVM_DB_BENCHMARK_INCLUDE_PMEM_MAPPING_H 2 | #define NVM_DB_BENCHMARK_INCLUDE_PMEM_MAPPING_H 3 | #include "common.h" 4 | 5 | void map_operation(struct access_info *ac_info); 6 | void unmap_operation(struct access_info *ac_info); 7 | 8 | #endif -------------------------------------------------------------------------------- /microbenchmarks/include/read_bw_benchmark.h: -------------------------------------------------------------------------------- 1 | #ifndef NVM_DB_BENCHMARK_READ_BW_BENCHMARK_H 2 | #define NVM_DB_BENCHMARK_READ_BW_BENCHMARK_H 3 | 4 | #include "common.h" 5 | 6 | void read_nt_random(struct thread_info* t_info); 7 | void read_nt(struct thread_info* t_info); 8 | void read_simd(struct thread_info* t_info); 9 | void read_memcpy(struct thread_info* t_info); 10 | void read_pointerinc(struct thread_info* t_info); 11 | void read_mov(struct thread_info* t_info); 12 | 13 | #endif -------------------------------------------------------------------------------- /microbenchmarks/include/thread_mapping.h: -------------------------------------------------------------------------------- 1 | #ifndef NVM_DB_BENCHMARK_INCLUDE_THREAD_MAPPING_H 2 | #define NVM_DB_BENCHMARK_INCLUDE_THREAD_MAPPING_H 3 | 4 | #include "common.h" 5 | void create_thread_mapping(struct access_info *ac_info); 6 | 7 | #endif -------------------------------------------------------------------------------- /microbenchmarks/include/write_bw_benchmark.h: -------------------------------------------------------------------------------- 1 | #ifndef NVM_DB_BENCHMARK_WRITE_BW_BENCHMARK_H 2 | #define NVM_DB_BENCHMARK_WRITE_BW_BENCHMARK_H 3 | 4 | #include "common.h" 5 | 6 | //#define SFENCE_AFTER_STORE 1 7 | 8 | #ifdef SFENCE_AFTER_STORE 9 | #define OPT_FENCE "sfence \n" 10 | #endif 11 | #ifndef SFENCE_AFTER_STORE 12 | #define OPT_FENCE "" 13 | #endif 14 | 15 | void write_nt(struct thread_info* t_info); 16 | void write_nt_random(struct thread_info * t_info); 17 | 18 | void write_clwb(struct thread_info* t_info); 19 | void write_clwb_random(struct thread_info* t_info); 20 | 21 | void write_store(struct thread_info* t_info); 22 | void write_store_random(struct thread_info* t_info); 23 | 24 | void write_nt_stride(struct thread_info* t_info); 25 | 26 | #endif -------------------------------------------------------------------------------- /microbenchmarks/mapping_files/socket_1_split: -------------------------------------------------------------------------------- 1 | 0 2 | 3 3 | 1 4 | 4 5 | 2 6 | 7 7 | 5 8 | 8 9 | 6 10 | 11 11 | 9 12 | 12 13 | 10 14 | 13 15 | 14 16 | 16 17 | 15 18 | 17 19 | 36 20 | 39 21 | 37 22 | 40 23 | 38 24 | 43 25 | 41 26 | 44 27 | 42 28 | 47 29 | 45 30 | 48 31 | 46 32 | 49 33 | 50 34 | 52 35 | 51 36 | 53 -------------------------------------------------------------------------------- /microbenchmarks/mapping_files/socket_2_linear: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 5 5 | 6 6 | 9 7 | 10 8 | 14 9 | 15 10 | 3 11 | 4 12 | 7 13 | 8 14 | 11 15 | 12 16 | 13 17 | 16 18 | 17 19 | 36 20 | 37 21 | 38 22 | 41 23 | 42 24 | 45 25 | 46 26 | 50 27 | 51 28 | 39 29 | 40 30 | 43 31 | 44 32 | 47 33 | 48 34 | 49 35 | 52 36 | 53 -------------------------------------------------------------------------------- /microbenchmarks/mapping_files/socket_2_split: -------------------------------------------------------------------------------- 1 | 18 2 | 21 3 | 19 4 | 22 5 | 20 6 | 25 7 | 23 8 | 26 9 | 24 10 | 29 11 | 27 12 | 30 13 | 28 14 | 31 15 | 32 16 | 34 17 | 33 18 | 35 19 | 54 20 | 57 21 | 55 22 | 58 23 | 56 24 | 61 25 | 59 26 | 62 27 | 60 28 | 65 29 | 63 30 | 66 31 | 64 32 | 67 33 | 68 34 | 70 35 | 69 36 | 71 -------------------------------------------------------------------------------- /plot_scripts/.gitignore: -------------------------------------------------------------------------------- 1 | venv/ 2 | __pycache__/ -------------------------------------------------------------------------------- /plot_scripts/README.md: -------------------------------------------------------------------------------- 1 | # Plot Scripts 2 | 3 | This directory contains the scripts that generate the graphics in the paper. 4 | Simply invoke a script by running 5 | ```sh 6 | python3 7 | ``` 8 | 9 | Each script will tell you how it expects its input. 10 | -------------------------------------------------------------------------------- /plot_scripts/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/hpides/pmem-olap/43ec98018858f6be9209d2f3546cb27eeddd05f9/plot_scripts/__init__.py -------------------------------------------------------------------------------- /plot_scripts/requirements.txt: -------------------------------------------------------------------------------- 1 | cycler==0.10.0 2 | kiwisolver==1.3.1 3 | matplotlib==3.3.3 4 | numpy==1.19.5 5 | Pillow==8.1.0 6 | pyparsing==2.4.7 7 | python-dateutil==2.8.1 8 | six==1.15.0 9 | -------------------------------------------------------------------------------- /scripts/microbenchmarks/benchmark.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | MIN_THREADS=1 4 | MAX_THREADS=100 5 | 6 | MIN_ACCESS_DISTANCE=2048 7 | MAX_ACCESS_DISTANCE=16384 8 | 9 | for (( threads=$MIN_THREADS; threads<=$MAX_THREADS; ++threads )) 10 | do 11 | for (( access_distance=$MIN_ACCESS_DISTANCE; access_distance<=$MAX_ACCESS_DISTANCE; access_distance+=256 )) 12 | do 13 | ./nvm_db_benchmark $threads $access_distance 14 | done 15 | done 16 | -------------------------------------------------------------------------------- /scripts/microbenchmarks/sequential_write.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | MIN_THREADS=36 3 | MAX_THREADS=36 4 | 5 | AS=64 6 | 7 | for (( AS=64; AS<=8192; AS*=2 )) 8 | do 9 | for(( TC=1; TC<=10; TC+=1 )) 10 | do 11 | numactl --cpunodebind=2,3 --membind=2,3 ../nvm_db_benchmark --write nt --threads $TC --ad $AS --package "/dev/dax1.0" --access_pattern log 12 | numactl --cpunodebind=2,3 --membind=2,3 ../nvm_db_benchmark --write nt --threads $TC --ad $AS --package "/dev/dax1.0" --access_pattern disjoint 13 | done 14 | done -------------------------------------------------------------------------------- /ssb/handcrafted/README.md: -------------------------------------------------------------------------------- 1 | # Benchmarking Source Code 2 | 3 | This directory contains the source code for the performed SSB benchmarks. 4 | 5 | ## Building 6 | 7 | ```sh 8 | ./init_dash # Dash is used as the hashmap for hashjoins 9 | make -DSOCKET_1_PATH= -DSOCKET_2_PATH= 10 | ``` 11 | 12 | This will give you three `ssb_pmem`, `ssb_dram` and `ssb_ssd` binaries which then can be used in the benchmarking scripts. 13 | 14 | ## Usage 15 | 16 | Please see the `scripts/ssb` directory for example usage. 17 | 18 | -------------------------------------------------------------------------------- /ssb/handcrafted/init_dash.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | git clone https://github.com/baotonglu/dash.git 4 | cd dash 5 | # Get older version used for paper 6 | git checkout 7e1551f03dfbd901b38af405b52d6b919235c379 7 | git clone https://github.com/XiangpengHao/VeryPM.git 8 | 9 | # Make small modifications 10 | git apply ../dash_ssb.patch 11 | sed -i -e "s#std::cout << \"Directory_Doubling#//#g" src/ex_finger.h 12 | 13 | cd .. 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/.clang-tidy-ignore: -------------------------------------------------------------------------------- 1 | # Used by clang_tidy_wrapper.sh, no wildcards etc. supported 2 | 3 | src/benchmarklib/tpcc/tpcc_table_generator.cpp # suggested fixes make compile time worse 4 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/.dockerignore: -------------------------------------------------------------------------------- 1 | * 2 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/PreLoad.cmake: -------------------------------------------------------------------------------- 1 | # avoid boost warnings: 2 | # https://stackoverflow.com/questions/35750089/why-cmake-ignores-the-boost-no-boost-cmake-environment-variable 3 | set(Boost_NO_BOOST_CMAKE TRUE CACHE BOOL "" FORCE) -------------------------------------------------------------------------------- /ssb/hyrise-dram/cmake/FindLibpmem.cmake: -------------------------------------------------------------------------------- 1 | FIND_PATH(LIBPMEM_INCLUDE_DIR NAME libpmem.h 2 | HINTS /scratch/pmem/pmdk/include/ 3 | NO_DEFAULT_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH 4 | ) 5 | 6 | FIND_LIBRARY(LIBPMEM_LIBRARY NAME pmem 7 | HINTS /scratch/pmem/pmdk/lib/ 8 | ) 9 | 10 | IF (LIBPMEM_INCLUDE_DIR) 11 | MESSAGE(STATUS "Found include") 12 | ENDIF () 13 | IF (LIBPMEM_LIBRARY) 14 | MESSAGE(STATUS "Found lib") 15 | 16 | ENDIF() 17 | 18 | IF (LIBPMEM_INCLUDE_DIR AND LIBPMEM_LIBRARY) 19 | SET(LIBPMEM_FOUND TRUE) 20 | MESSAGE(STATUS "Found libpmem library: inc=${LIBPMEM_INCLUDE_DIR}, lib=${LIBPMEM_LIBRARY}") 21 | ELSE () 22 | SET(LIBPMEM_FOUND FALSE) 23 | MESSAGE(STATUS "WARNING: libpmem library not found.") 24 | ENDIF () 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/cmake/FindLibpmem2.cmake: -------------------------------------------------------------------------------- 1 | FIND_PATH(LIBPMEM2_INCLUDE_DIR NAME libpmem2.h 2 | HINTS /scratch/pmem/pmdk/include/ 3 | NO_DEFAULT_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH 4 | ) 5 | 6 | FIND_LIBRARY(LIBPMEM2_LIBRARY NAME pmem2 7 | HINTS /scratch/pmem/pmdk/lib/ 8 | ) 9 | 10 | IF (LIBPMEM2_INCLUDE_DIR) 11 | MESSAGE(STATUS "Found include") 12 | ENDIF () 13 | IF (LIBPMEM2_LIBRARY) 14 | MESSAGE(STATUS "Found lib") 15 | 16 | ENDIF() 17 | 18 | IF (LIBPMEM2_INCLUDE_DIR AND LIBPMEM2_LIBRARY) 19 | SET(LIBPMEM2_FOUND TRUE) 20 | MESSAGE(STATUS "Found libpmem2 library: inc=${LIBPMEM2_INCLUDE_DIR}, lib=${LIBPMEM2_LIBRARY}") 21 | ELSE () 22 | SET(LIBPMEM2_FOUND FALSE) 23 | MESSAGE(STATUS "WARNING: libpmem2 library not found.") 24 | ENDIF () 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/cmake/FindMemkind.cmake: -------------------------------------------------------------------------------- 1 | FIND_PATH(MEMKIND_INCLUDE_DIR NAME memkind.h 2 | HINTS /scratch/lars.bollmeier/memkind/build/include 3 | NO_DEFAULT_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH 4 | ) 5 | 6 | FIND_LIBRARY(MEMKIND_LIBRARY NAME memkind 7 | HINTS /scratch/lars.bollmeier/memkind/build/lib 8 | ) 9 | 10 | IF (MEMKIND_INCLUDE_DIR AND MEMKIND_LIBRARY) 11 | SET(MEMKIND_FOUND TRUE) 12 | MESSAGE(STATUS "Found memkind library: inc=${MEMKIND_INCLUDE_DIR}, lib=${MEMKIND_LIBRARY}") 13 | ELSE () 14 | SET(MEMKIND_FOUND FALSE) 15 | MESSAGE(STATUS "WARNING: memkind library not found.") 16 | ENDIF () 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/cmake/FindTbb.cmake: -------------------------------------------------------------------------------- 1 | # Find the Intel Thread Building Blocks library. 2 | # Output variables: 3 | # TBB_INCLUDE_DIR : e.g., /usr/include/. 4 | # TBB_LIBRARY : Library path of Intel Threading Building Blocks library 5 | # TBB_FOUND : True if found. 6 | FIND_PATH(TBB_INCLUDE_DIR NAME tbb/tbb.h 7 | HINTS /opt/intel/oneapi/tbb/latest/include/) 8 | 9 | FIND_LIBRARY(TBB_LIBRARY NAME tbb 10 | HINTS /opt/intel/oneapi/tbb/latest/lib/intel64/gcc4.8/) 11 | 12 | IF (TBB_INCLUDE_DIR AND TBB_LIBRARY) 13 | SET(TBB_FOUND TRUE) 14 | MESSAGE(STATUS "Found tbb library: inc=${TBB_INCLUDE_DIR}, lib=${TBB_LIBRARY}") 15 | ELSE () 16 | SET(TBB_FOUND FALSE) 17 | MESSAGE(STATUS "WARNING: tbb library not found.") 18 | ENDIF () 19 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/cmake/TargetLinkLibrariesSystem.cmake: -------------------------------------------------------------------------------- 1 | # Similar to target_link_libraries, but uses -isystem instead of -I 2 | # https://stackoverflow.com/questions/51816807/in-cmake-how-do-i-make-target-link-libraries-suppress-warnings-from-3rd-party 3 | 4 | function(target_link_libraries_system target) 5 | set(libs ${ARGN}) 6 | foreach(lib ${libs}) 7 | get_target_property(lib_include_dirs ${lib} INTERFACE_INCLUDE_DIRECTORIES) 8 | target_include_directories(${target} SYSTEM PUBLIC ${lib_include_dirs}) 9 | target_link_libraries(${target} PUBLIC ${lib}) 10 | endforeach(lib) 11 | endfunction(target_link_libraries_system) 12 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/nvm.json: -------------------------------------------------------------------------------- 1 | { 2 | "pooldir": "/mnt/nvrams1/epic/md" 3 | } 4 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/requirements.txt: -------------------------------------------------------------------------------- 1 | black==19.10b0 2 | flake8==3.8.3 3 | matplotlib>=3.2.2 4 | numpy>=1.19.0 5 | pandas>=1.0.5 6 | pexpect>=4.8.0 7 | PyDriller>=1.15.2 8 | scipy>=1.5.0 9 | termcolor>=1.1.0 10 | terminaltables>=3.1.0 11 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/scripts/benchmark.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | if [ -z "$1" ] 4 | then 5 | echo "No build directory supplied" 6 | exit 1 7 | fi 8 | 9 | ./$1/hyriseBenchmark --benchmark_format=json > benchmark.json -------------------------------------------------------------------------------- /ssb/hyrise-dram/scripts/clang_tidy_wrapper.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # We need this wrapper because clang-tidy doesn't come with an option to ignore entire files 4 | 5 | cmake_source_dir=$1/ 6 | shift # Remove the source dir from $@ 7 | file=$1 8 | shift # Remove the file from $@ 9 | 10 | file_relative_to_source=${file//$cmake_source_dir/} # Remove the source dir from $file 11 | file_relative_to_source=${file_relative_to_source/..\/src/src} # Remove `../src`, which gets added by Ninja 12 | 13 | if grep "$file_relative_to_source" $cmake_source_dir/.clang-tidy-ignore > /dev/null; then 14 | echo "clang-tidy: Ignoring $file_relative_to_source" 15 | exit 0 16 | else 17 | if [ -x /usr/local/bin/brew ]; then 18 | exec $(brew --prefix llvm)/bin/clang-tidy $file $@ 19 | else 20 | exec clang-tidy-10 $file $@ 21 | fi 22 | fi 23 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/scripts/compare_coverage.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | master_branch=$(curl https://hyrise-ci.epic-hpi.de/job/Hyrise/job/hyrise/job/master/lastStableBuild/artifact/coverage_percent.txt) 4 | this_branch=$(cat coverage_percent.txt) 5 | 6 | if (( $(bc <<< "$master_branch < $this_branch") )) 7 | then 8 | echo -n increased by $(bc <<< "$this_branch - $master_branch") 9 | elif (( $(bc <<< "$master_branch == $this_branch") )) 10 | then 11 | echo -n stayed the same 12 | else 13 | echo -n decreased by $(bc <<< "$master_branch - $this_branch") 14 | fi 15 | 16 | echo " compared to master and is now $this_branch%" -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/micro_benchmark_basic_fixture.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "benchmark/benchmark.h" 6 | #include "micro_benchmark_utils.hpp" 7 | #include "types.hpp" 8 | 9 | namespace opossum { 10 | 11 | class TableWrapper; 12 | 13 | // Defining the base fixture class 14 | class MicroBenchmarkBasicFixture : public benchmark::Fixture { 15 | public: 16 | void SetUp(::benchmark::State& state) override; 17 | void TearDown(::benchmark::State&) override; 18 | 19 | protected: 20 | void _clear_cache(); 21 | 22 | protected: 23 | std::shared_ptr _table_wrapper_a; 24 | std::shared_ptr _table_wrapper_b; 25 | std::shared_ptr _table_dict_wrapper; 26 | }; 27 | 28 | } // namespace opossum 29 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/micro_benchmark_main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | BENCHMARK_MAIN(); 4 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/micro_benchmark_utils.cpp: -------------------------------------------------------------------------------- 1 | #include "micro_benchmark_utils.hpp" 2 | 3 | namespace opossum { 4 | 5 | void micro_benchmark_clear_cache() { 6 | std::vector clear = std::vector(); 7 | clear.resize(500 * 1000 * 1000, 42); 8 | for (size_t i = 0; i < clear.size(); i++) { 9 | clear[i] += 1; 10 | } 11 | clear.resize(0); 12 | } 13 | 14 | } // namespace opossum 15 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/micro_benchmark_utils.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | void micro_benchmark_clear_cache(); 8 | 9 | } // namespace opossum 10 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/operators/difference_benchmark.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "benchmark/benchmark.h" 4 | 5 | #include "../micro_benchmark_basic_fixture.hpp" 6 | #include "operators/difference.hpp" 7 | #include "operators/table_wrapper.hpp" 8 | 9 | namespace opossum { 10 | 11 | BENCHMARK_F(MicroBenchmarkBasicFixture, BM_Difference)(benchmark::State& state) { 12 | _clear_cache(); 13 | auto warm_up = std::make_shared(_table_wrapper_a, _table_wrapper_b); 14 | warm_up->execute(); 15 | for (auto _ : state) { 16 | auto difference = std::make_shared(_table_wrapper_a, _table_wrapper_b); 17 | difference->execute(); 18 | } 19 | } 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/operators/union_all_benchmark.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "../micro_benchmark_basic_fixture.hpp" 4 | #include "benchmark/benchmark.h" 5 | #include "operators/table_wrapper.hpp" 6 | #include "operators/union_all.hpp" 7 | 8 | namespace opossum { 9 | 10 | BENCHMARK_F(MicroBenchmarkBasicFixture, BM_UnionAll)(benchmark::State& state) { 11 | _clear_cache(); 12 | auto warm_up = std::make_shared(_table_wrapper_a, _table_wrapper_b); 13 | warm_up->execute(); 14 | for (auto _ : state) { 15 | auto union_all = std::make_shared(_table_wrapper_a, _table_wrapper_b); 16 | union_all->execute(); 17 | } 18 | } 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmark/tpch_table_generator_benchmark.cpp: -------------------------------------------------------------------------------- 1 | #include "benchmark/benchmark.h" 2 | 3 | #include "hyrise.hpp" 4 | #include "tpch/tpch_table_generator.hpp" 5 | 6 | namespace opossum { 7 | 8 | /** 9 | * This benchmark can only be use as a starting point for investigating TPCHTableGenerator performance, since secondary 10 | * invocations of 'TPCHTableGenerator(scale_factor, 1000).generate();' will profit from cached data in tpch-dbgen 11 | * @param state 12 | */ 13 | static void BM_TPCHTableGenerator(benchmark::State& state) { // NOLINT 14 | for (auto _ : state) { 15 | TPCHTableGenerator(0.5f, 1000).generate_and_store(); 16 | Hyrise::reset(); 17 | } 18 | } 19 | BENCHMARK(BM_TPCHTableGenerator); 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/benchmark_item_result.cpp: -------------------------------------------------------------------------------- 1 | #include "benchmark_item_result.hpp" 2 | 3 | namespace opossum { 4 | 5 | BenchmarkItemResult::BenchmarkItemResult() { 6 | successful_runs.reserve(1'000'000); 7 | unsuccessful_runs.reserve(1'000); 8 | } 9 | 10 | } // namespace opossum 11 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/benchmark_item_run_result.cpp: -------------------------------------------------------------------------------- 1 | #include "benchmark_item_run_result.hpp" 2 | 3 | namespace opossum { 4 | 5 | BenchmarkItemRunResult::BenchmarkItemRunResult(Duration init_begin, Duration init_duration, 6 | std::vector init_metrics) 7 | : begin(init_begin), duration(init_duration), metrics(std::move(init_metrics)) {} 8 | 9 | } // namespace opossum 10 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/benchmark_state.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "benchmark_config.hpp" 6 | 7 | namespace opossum { 8 | 9 | /** 10 | * Loosely copying the functionality of benchmark::State 11 | * keep_running() returns false once enough iterations or time has passed. 12 | */ 13 | struct BenchmarkState { 14 | enum class State { NotStarted, Running, Over }; 15 | 16 | explicit BenchmarkState(const Duration max_duration); 17 | BenchmarkState& operator=(const BenchmarkState& other); 18 | 19 | bool keep_running(); 20 | void set_done(); 21 | bool is_done() const; 22 | 23 | std::atomic state{State::NotStarted}; 24 | TimePoint benchmark_begin = TimePoint{}; 25 | Duration benchmark_duration = Duration{}; 26 | 27 | Duration max_duration; 28 | }; 29 | 30 | } // namespace opossum 31 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/benchmark_table_encoder.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | class EncodingConfig; 9 | class Table; 10 | 11 | class BenchmarkTableEncoder { 12 | public: 13 | // @param out stream for logging info 14 | // @return true, if any encoding operation was performed. 15 | // false, if the @param table was already encoded as required by @param encoding_config 16 | static bool encode(const std::string& table_name, const std::shared_ptr& table, 17 | const EncodingConfig& encoding_config); 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/cli_config_parser.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "cxxopts.hpp" 7 | 8 | #include "benchmark_config.hpp" 9 | #include "encoding_config.hpp" 10 | 11 | namespace opossum { 12 | 13 | class CLIConfigParser { 14 | public: 15 | static BenchmarkConfig parse_cli_options(const cxxopts::ParseResult& parse_result); 16 | 17 | static EncodingConfig parse_encoding_config(const std::string& encoding_file_str); 18 | 19 | // Returns whether --help or --full_help was requested - used to stop execution of the benchmark 20 | static bool print_help_if_requested(const cxxopts::Options& options, const cxxopts::ParseResult& parse_result); 21 | }; 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/file_based_table_generator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "abstract_table_generator.hpp" 7 | 8 | namespace opossum { 9 | 10 | class FileBasedTableGenerator : virtual public AbstractTableGenerator { 11 | public: 12 | FileBasedTableGenerator(const std::shared_ptr& benchmark_config, const std::string& path); 13 | 14 | std::unordered_map generate() override; 15 | 16 | protected: 17 | const std::string _path; 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/tpcc/defines.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | class OperatorTask; 9 | 10 | using TaskVector = std::vector>; 11 | 12 | } // namespace opossum 13 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/tpcc/procedures/tpcc_stock_level.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_tpcc_procedure.hpp" 4 | 5 | namespace opossum { 6 | 7 | class TPCCStockLevel : public AbstractTPCCProcedure { 8 | public: 9 | TPCCStockLevel(const int num_warehouses, BenchmarkSQLExecutor& sql_executor); 10 | 11 | [[nodiscard]] bool _on_execute() override; 12 | 13 | protected: 14 | // Values generated BEFORE the procedure is executed: 15 | int32_t w_id; // Home warehouse ID [1..num_warehouses] 16 | int32_t d_id; // District ID [1..10] 17 | int32_t threshold; // Minimum stock level [10..20] 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/tpcc/tpcc_benchmark_item_runner.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "abstract_benchmark_item_runner.hpp" 6 | 7 | namespace opossum { 8 | 9 | class TPCCBenchmarkItemRunner : public AbstractBenchmarkItemRunner { 10 | public: 11 | TPCCBenchmarkItemRunner(const std::shared_ptr& config, int num_warehouses); 12 | 13 | std::string item_name(const BenchmarkItemID item_id) const override; 14 | const std::vector& items() const override; 15 | 16 | const std::vector& weights() const override; 17 | 18 | protected: 19 | bool _on_execute_item(const BenchmarkItemID item_id, BenchmarkSQLExecutor& sql_executor) override; 20 | 21 | const int _num_warehouses; 22 | }; 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/benchmarklib/tpch/tpch_queries.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | /** 9 | * Contains all supported TPCH queries. Use ordered map to have queries sorted by query id. 10 | * This allows for guaranteed execution order when iterating over the queries. 11 | */ 12 | extern const std::map tpch_queries; 13 | 14 | } // namespace opossum 15 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/bin/client.cpp: -------------------------------------------------------------------------------- 1 | #include "client.hpp" 2 | 3 | // Files in the /bin folder are not tested. Everything that can be tested should be in the /lib folder and this file 4 | // should be as short as possible. 5 | 6 | int main(int argc, char** argv) { return 0; } 7 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/bin/client.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/bin/playground.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "types.hpp" 4 | 5 | using namespace opossum; // NOLINT 6 | 7 | int main() { 8 | std::cout << "Hello world!!" << std::endl; 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/all_parameter_variant.cpp: -------------------------------------------------------------------------------- 1 | #include "all_parameter_variant.hpp" 2 | 3 | #include 4 | #include 5 | 6 | #include "boost/lexical_cast.hpp" 7 | 8 | #include "all_type_variant.hpp" 9 | 10 | namespace opossum { 11 | 12 | std::ostream& operator<<(std::ostream& stream, const AllParameterVariant& variant) { 13 | if (is_parameter_id(variant)) { 14 | stream << "Placeholder #" << boost::get(variant); 15 | } else if (is_column_id(variant)) { 16 | stream << "Column #" << boost::get(variant); 17 | } else { 18 | stream << boost::get(variant); 19 | } 20 | 21 | return stream; 22 | } 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/all_type_variant.cpp: -------------------------------------------------------------------------------- 1 | #include "all_type_variant.hpp" 2 | 3 | #include 4 | 5 | #include "boost/functional/hash.hpp" 6 | 7 | #include "utils/assert.hpp" 8 | 9 | namespace opossum { 10 | 11 | bool is_floating_point_data_type(const DataType data_type) { 12 | return data_type == DataType::Float || data_type == DataType::Double; 13 | } 14 | 15 | } // namespace opossum 16 | 17 | namespace std { 18 | 19 | size_t hash::operator()(const opossum::AllTypeVariant& all_type_variant) const { 20 | return boost::hash_value(all_type_variant); 21 | } 22 | 23 | } // namespace std 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/cost_estimation/cost_estimator_logical.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_cost_estimator.hpp" 4 | 5 | namespace opossum { 6 | 7 | class AbstractExpression; 8 | 9 | /** 10 | * Cost model for logical complexity, i.e., approximate number of tuple accesses 11 | */ 12 | class CostEstimatorLogical : public AbstractCostEstimator { 13 | public: 14 | using AbstractCostEstimator::AbstractCostEstimator; 15 | 16 | std::shared_ptr new_instance() const override; 17 | 18 | Cost estimate_node_cost(const std::shared_ptr& node) const override; 19 | 20 | private: 21 | static float _get_expression_cost_multiplier(const std::shared_ptr& expression); 22 | }; 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/expression/abstract_predicate_expression.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_expression.hpp" 4 | #include "types.hpp" 5 | 6 | namespace opossum { 7 | 8 | /** 9 | * PredicateExpressions are those using a PredicateCondition. 10 | */ 11 | class AbstractPredicateExpression : public AbstractExpression { 12 | public: 13 | AbstractPredicateExpression(const PredicateCondition init_predicate_condition, 14 | const std::vector>& init_arguments); 15 | 16 | DataType data_type() const override; 17 | 18 | const PredicateCondition predicate_condition; 19 | 20 | protected: 21 | bool _shallow_equals(const AbstractExpression& expression) const override; 22 | size_t _shallow_hash() const override; 23 | }; 24 | 25 | } // namespace opossum 26 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/expression/expression_precedence.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | // Precedence levels for parenthesizing expression arguments. See AbstractExpression::_enclose_argument 8 | enum class ExpressionPrecedence : uint32_t { 9 | Highest = 0, 10 | UnaryPredicate, 11 | MultiplicationDivision, 12 | AdditionSubtraction, 13 | BinaryTernaryPredicate, 14 | Logical 15 | }; 16 | 17 | } // namespace opossum 18 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/expression/is_null_expression.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_expression.hpp" 4 | #include "abstract_predicate_expression.hpp" 5 | #include "types.hpp" 6 | 7 | namespace opossum { 8 | 9 | class IsNullExpression : public AbstractPredicateExpression { 10 | public: 11 | IsNullExpression(const PredicateCondition init_predicate_condition, 12 | const std::shared_ptr& operand); 13 | 14 | const std::shared_ptr& operand() const; 15 | 16 | std::shared_ptr deep_copy() const override; 17 | std::string description(const DescriptionMode mode) const override; 18 | 19 | protected: 20 | ExpressionPrecedence _precedence() const override; 21 | bool _on_is_nullable_on_lqp(const AbstractLQPNode& lqp) const override; 22 | }; 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/expression/unary_minus_expression.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_expression.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * Unary minus 9 | */ 10 | class UnaryMinusExpression : public AbstractExpression { 11 | public: 12 | explicit UnaryMinusExpression(const std::shared_ptr& argument); 13 | 14 | std::shared_ptr argument() const; 15 | 16 | std::shared_ptr deep_copy() const override; 17 | std::string description(const DescriptionMode mode) const override; 18 | DataType data_type() const override; 19 | 20 | protected: 21 | bool _shallow_equals(const AbstractExpression& expression) const override; 22 | }; 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/import_export/file_type.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "SQLParser.h" 4 | 5 | namespace opossum { 6 | 7 | enum class FileType { Csv, Tbl, Binary, Auto }; 8 | 9 | FileType import_type_to_file_type(const hsql::ImportType import_type); 10 | 11 | FileType file_type_from_filename(const std::string& filename); 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/logical_query_plan/drop_table_node.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_non_query_node.hpp" 4 | #include "enable_make_for_lqp_node.hpp" 5 | 6 | namespace opossum { 7 | 8 | class DropTableNode : public EnableMakeForLQPNode, public AbstractNonQueryNode { 9 | public: 10 | DropTableNode(const std::string& init_table_name, bool init_if_exists); 11 | 12 | std::string description(const DescriptionMode mode = DescriptionMode::Short) const override; 13 | 14 | const std::string table_name; 15 | const bool if_exists; 16 | 17 | protected: 18 | size_t _on_shallow_hash() const override; 19 | std::shared_ptr _on_shallow_copy(LQPNodeMapping& node_mapping) const override; 20 | bool _on_shallow_equals(const AbstractLQPNode& rhs, const LQPNodeMapping& node_mapping) const override; 21 | }; 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/logical_query_plan/validate_node.cpp: -------------------------------------------------------------------------------- 1 | #include "validate_node.hpp" 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | ValidateNode::ValidateNode() : AbstractLQPNode(LQPNodeType::Validate) {} 8 | 9 | std::string ValidateNode::description(const DescriptionMode mode) const { return "[Validate]"; } 10 | 11 | std::shared_ptr ValidateNode::unique_constraints() const { 12 | return _forward_left_unique_constraints(); 13 | } 14 | 15 | std::shared_ptr ValidateNode::_on_shallow_copy(LQPNodeMapping& node_mapping) const { 16 | return ValidateNode::make(); 17 | } 18 | 19 | bool ValidateNode::_on_shallow_equals(const AbstractLQPNode& rhs, const LQPNodeMapping& node_mapping) const { 20 | return true; 21 | } 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/memory/dram_memory_resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace opossum { 8 | 9 | class DRAMMemoryResource : public boost::container::pmr::memory_resource, public Singleton { 10 | public: 11 | virtual void* do_allocate(std::size_t bytes, std::size_t alignment); 12 | 13 | virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment); 14 | 15 | virtual bool do_is_equal(const memory_resource& other) const noexcept; 16 | 17 | memkind_t kind() const; 18 | 19 | protected: 20 | DRAMMemoryResource(); 21 | ~DRAMMemoryResource(); 22 | 23 | friend class Singleton; 24 | 25 | memkind_t _dram_kind; 26 | }; 27 | 28 | } // namespace opossum 29 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/memory/kind_memory_manager.cpp: -------------------------------------------------------------------------------- 1 | #include "kind_memory_manager.hpp" 2 | 3 | #include 4 | 5 | #include "nvm_memory_resource.hpp" 6 | 7 | namespace opossum { 8 | 9 | KindMemoryManager::KindMemoryManager() { 10 | for (auto purpose_idx = size_t{0}; purpose_idx < magic_enum::enum_count(); ++purpose_idx) { 11 | _mapping.emplace_back(*boost::container::pmr::get_default_resource()); 12 | } 13 | } 14 | 15 | boost::container::pmr::memory_resource& KindMemoryManager::get_resource(const AllocationPurpose purpose) const { 16 | return _mapping.at(magic_enum::enum_integer(purpose)); 17 | } 18 | 19 | void KindMemoryManager::set_resource(const AllocationPurpose purpose, boost::container::pmr::memory_resource& resource) { 20 | _mapping[magic_enum::enum_integer(purpose)] = resource; 21 | } 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/operators/abstract_read_only_operator.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_read_only_operator.hpp" 2 | 3 | #include 4 | 5 | #include "storage/table.hpp" 6 | 7 | namespace opossum { 8 | 9 | std::shared_ptr AbstractReadOnlyOperator::_on_execute(std::shared_ptr) { 10 | return _on_execute(); 11 | } 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/operators/operator_performance_data.cpp: -------------------------------------------------------------------------------- 1 | #include "operator_performance_data.hpp" 2 | 3 | #include 4 | 5 | #include "utils/format_duration.hpp" 6 | 7 | namespace opossum { 8 | 9 | std::ostream& operator<<(std::ostream& stream, const AbstractOperatorPerformanceData& performance_data) { 10 | performance_data.output_to_stream(stream, DescriptionMode::SingleLine); 11 | return stream; 12 | } 13 | 14 | } // namespace opossum 15 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/optimizer/join_ordering/join_graph_edge.cpp: -------------------------------------------------------------------------------- 1 | #include "join_graph_edge.hpp" 2 | 3 | #include "expression/abstract_expression.hpp" 4 | 5 | namespace opossum { 6 | 7 | JoinGraphEdge::JoinGraphEdge(const JoinGraphVertexSet& init_vertex_set, 8 | const std::vector>& init_predicates) 9 | : vertex_set(init_vertex_set), predicates(init_predicates) {} 10 | 11 | std::ostream& operator<<(std::ostream& stream, const JoinGraphEdge& join_graph_edge) { 12 | stream << "Vertices: " << join_graph_edge.vertex_set << "; " << join_graph_edge.predicates.size() << " predicates" 13 | << std::endl; 14 | for (const auto& predicate : join_graph_edge.predicates) { 15 | stream << predicate->as_column_name() << std::endl; 16 | } 17 | return stream; 18 | } 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/optimizer/strategy/abstract_rule.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_rule.hpp" 2 | 3 | #include 4 | 5 | #include "expression/expression_utils.hpp" 6 | #include "expression/lqp_subquery_expression.hpp" 7 | #include "logical_query_plan/abstract_lqp_node.hpp" 8 | #include "logical_query_plan/logical_plan_root_node.hpp" 9 | 10 | namespace opossum { 11 | 12 | void AbstractRule::_apply_to_inputs(std::shared_ptr node) const { // NOLINT 13 | if (node->left_input()) apply_to(node->left_input()); 14 | if (node->right_input()) apply_to(node->right_input()); 15 | } 16 | 17 | } // namespace opossum 18 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/optimizer/strategy/join_ordering_rule.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "abstract_rule.hpp" 6 | 7 | namespace opossum { 8 | 9 | class AbstractCostEstimator; 10 | 11 | /** 12 | * A rule that brings join operations into a (supposedly) efficient order. 13 | * Currently only the order of inner joins is modified using a single underlying algorithm, DpCcp. 14 | */ 15 | class JoinOrderingRule : public AbstractRule { 16 | public: 17 | void apply_to(const std::shared_ptr& root) const override; 18 | 19 | private: 20 | std::shared_ptr _perform_join_ordering_recursively( 21 | const std::shared_ptr& lqp) const; 22 | void _recurse_to_inputs(const std::shared_ptr& lqp) const; 23 | }; 24 | 25 | } // namespace opossum 26 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/scheduler/job_task.cpp: -------------------------------------------------------------------------------- 1 | #include "job_task.hpp" 2 | 3 | namespace opossum { 4 | 5 | void JobTask::_on_execute() { _fn(); } 6 | 7 | } // namespace opossum 8 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/server/client_disconnect_exception.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace opossum { 9 | 10 | // Server-specific exception used to handle errors when reading data from or writing data to the network socket. 11 | class ClientDisconnectException : public std::runtime_error { 12 | public: 13 | explicit ClientDisconnectException(const std::string& what_arg) : std::runtime_error(what_arg) {} 14 | }; 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/server/server_types.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | using Socket = boost::asio::ip::tcp::socket; 8 | 9 | enum class HasNullTerminator : bool { Yes = true, No = false }; 10 | 11 | enum class SendExecutionInfo : bool { Yes = true, No = false }; 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/create_sql_parser_error_message.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "SQLParser.h" 6 | 7 | namespace opossum { 8 | 9 | std::string create_sql_parser_error_message(const std::string& sql, const hsql::SQLParserResult& result); 10 | 11 | } // namespace opossum 12 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/parameter_id_allocator.cpp: -------------------------------------------------------------------------------- 1 | #include "parameter_id_allocator.hpp" 2 | 3 | namespace opossum { 4 | 5 | ParameterID ParameterIDAllocator::allocate() { return static_cast(_parameter_id_counter++); } 6 | 7 | ParameterID ParameterIDAllocator::allocate_for_value_placeholder(const ValuePlaceholderID value_placeholder_id) { 8 | const auto parameter_id = allocate(); 9 | const auto is_unique = _value_placeholders.emplace(value_placeholder_id, parameter_id).second; 10 | Assert(is_unique, "Duplicate ValuePlaceholderID"); 11 | 12 | return parameter_id; 13 | } 14 | 15 | const std::unordered_map& ParameterIDAllocator::value_placeholders() const { 16 | return _value_placeholders; 17 | } 18 | 19 | } // namespace opossum 20 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/parameter_id_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "types.hpp" 6 | 7 | STRONG_TYPEDEF(uint16_t, ValuePlaceholderID); 8 | 9 | namespace opossum { 10 | 11 | /** 12 | * Allocates ParameterIDs for ValuePlaceholders and correlated expressions during SQL translation 13 | */ 14 | class ParameterIDAllocator { 15 | public: 16 | ParameterID allocate(); 17 | ParameterID allocate_for_value_placeholder(const ValuePlaceholderID value_placeholder_id); 18 | 19 | const std::unordered_map& value_placeholders() const; 20 | 21 | private: 22 | ParameterID _parameter_id_counter{0}; 23 | std::unordered_map _value_placeholders; 24 | }; 25 | 26 | } // namespace opossum 27 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/sql_identifier.cpp: -------------------------------------------------------------------------------- 1 | #include "sql_identifier.hpp" 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | SQLIdentifier::SQLIdentifier(const std::string& init_column_name, const std::optional& init_table_name) 8 | : column_name(init_column_name), table_name(init_table_name) {} 9 | 10 | bool SQLIdentifier::operator==(const SQLIdentifier& rhs) const { 11 | return column_name == rhs.column_name && table_name == rhs.table_name; 12 | } 13 | 14 | std::string SQLIdentifier::as_string() const { 15 | std::stringstream ss; 16 | if (table_name) ss << *table_name << "."; 17 | ss << column_name; 18 | return ss.str(); 19 | } 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/sql_identifier.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | struct SQLIdentifier final { 9 | SQLIdentifier(const std::string& init_column_name, const std::optional& init_table_name = 10 | std::nullopt); // NOLINT - Implicit conversion is intended 11 | 12 | bool operator==(const SQLIdentifier& rhs) const; 13 | 14 | std::string as_string() const; 15 | 16 | std::string column_name; 17 | std::optional table_name = std::nullopt; 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/sql/sql_plan_cache.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "cache/gdfs_cache.hpp" 7 | 8 | namespace opossum { 9 | 10 | class AbstractOperator; 11 | class AbstractLQPNode; 12 | 13 | using SQLPhysicalPlanCache = GDFSCache>; 14 | using SQLLogicalPlanCache = GDFSCache>; 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/abstract_cardinality_estimator.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_cardinality_estimator.hpp" 2 | 3 | namespace opossum { 4 | 5 | void AbstractCardinalityEstimator::guarantee_join_graph(const JoinGraph& join_graph) { 6 | cardinality_estimation_cache.join_graph_statistics_cache.emplace( 7 | JoinGraphStatisticsCache::from_join_graph(join_graph)); 8 | } 9 | 10 | void AbstractCardinalityEstimator::guarantee_bottom_up_construction() { 11 | cardinality_estimation_cache.statistics_by_lqp.emplace(); 12 | } 13 | 14 | } // namespace opossum 15 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/base_attribute_statistics.cpp: -------------------------------------------------------------------------------- 1 | #include "base_attribute_statistics.hpp" 2 | 3 | namespace opossum { 4 | 5 | BaseAttributeStatistics::BaseAttributeStatistics(const DataType init_data_type) : data_type(init_data_type) {} 6 | 7 | std::shared_ptr BaseAttributeStatistics::pruned( 8 | const size_t num_values_pruned, const PredicateCondition predicate_condition, const AllTypeVariant& variant_value, 9 | const std::optional& variant_value2) const { 10 | Fail("Pruning has not yet been implemented for the given statistics object"); 11 | } 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/cardinality_estimation_cache.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "join_graph_statistics_cache.hpp" 4 | 5 | namespace opossum { 6 | 7 | // See `AbstractCardinalityEstimator::guarantee_join_graph()/guarantee_bottom_up_construction()` 8 | class CardinalityEstimationCache { 9 | public: 10 | std::optional join_graph_statistics_cache; 11 | 12 | using StatisticsByLQP = std::unordered_map, std::shared_ptr>; 13 | std::optional statistics_by_lqp; 14 | }; 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/generate_pruning_statistics.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | class Chunk; 9 | class Table; 10 | 11 | /** 12 | * Generate Pruning Filters for an immutable Chunk 13 | */ 14 | void generate_chunk_pruning_statistics(const std::shared_ptr& chunk); 15 | 16 | /** 17 | * Generate Pruning Filters for all immutable Chunks in this Table 18 | */ 19 | void generate_chunk_pruning_statistics(const std::shared_ptr
& table); 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/statistics_objects/abstract_statistics_object.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_statistics_object.hpp" 2 | 3 | namespace opossum { 4 | 5 | AbstractStatisticsObject::AbstractStatisticsObject(const DataType init_data_type) : data_type(init_data_type) {} 6 | 7 | std::shared_ptr AbstractStatisticsObject::pruned( 8 | const size_t num_values_pruned, const PredicateCondition predicate_condition, const AllTypeVariant& variant_value, 9 | const std::optional& variant_value2) const { 10 | Fail("Pruning has not yet been implemented for the given statistics object"); 11 | } 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/statistics_objects/null_value_ratio_statistics.cpp: -------------------------------------------------------------------------------- 1 | #include "null_value_ratio_statistics.hpp" 2 | 3 | #include "utils/assert.hpp" 4 | 5 | namespace opossum { 6 | 7 | NullValueRatioStatistics::NullValueRatioStatistics(const float init_ratio) 8 | : AbstractStatisticsObject(DataType::Null), ratio(init_ratio) {} 9 | 10 | std::shared_ptr NullValueRatioStatistics::sliced( 11 | const PredicateCondition predicate_condition, const AllTypeVariant& variant_value, 12 | const std::optional& variant_value2) const { 13 | return std::make_shared(ratio); 14 | } 15 | 16 | std::shared_ptr NullValueRatioStatistics::scaled(const Selectivity selectivity) const { 17 | return std::make_shared(ratio); 18 | } 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/statistics/statistics_objects/null_value_ratio_statistics.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_statistics_object.hpp" 4 | 5 | namespace opossum { 6 | 7 | // A single float value as an AbstractStatisticsObject, to keep architectures consistent.... 8 | class NullValueRatioStatistics : public AbstractStatisticsObject { 9 | public: 10 | explicit NullValueRatioStatistics(const float init_ratio); 11 | 12 | std::shared_ptr sliced( 13 | const PredicateCondition predicate_condition, const AllTypeVariant& variant_value, 14 | const std::optional& variant_value2 = std::nullopt) const override; 15 | 16 | std::shared_ptr scaled(const Selectivity selectivity) const override; 17 | 18 | float ratio; 19 | }; 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/abstract_encoded_segment.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_encoded_segment.hpp" 2 | 3 | #include "storage/vector_compression/compressed_vector_type.hpp" 4 | #include "utils/assert.hpp" 5 | 6 | namespace opossum {} // namespace opossum 7 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/abstract_segment.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_segment.hpp" 2 | 3 | namespace opossum { 4 | 5 | AbstractSegment::AbstractSegment(const DataType data_type) : _data_type(data_type) {} 6 | 7 | DataType AbstractSegment::data_type() const { return _data_type; } 8 | 9 | } // namespace opossum 10 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/abstract_table_constraint.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_table_constraint.hpp" 2 | 3 | namespace opossum { 4 | 5 | AbstractTableConstraint::AbstractTableConstraint(std::unordered_set init_columns) 6 | : _columns(std::move(init_columns)) {} 7 | 8 | const std::unordered_set& AbstractTableConstraint::columns() const { return _columns; } 9 | 10 | bool AbstractTableConstraint::operator==(const AbstractTableConstraint& rhs) const { 11 | if (this == &rhs) return true; 12 | if (typeid(*this) != typeid(rhs)) return false; 13 | if (columns() != rhs.columns()) return false; 14 | return _on_equals(rhs); 15 | } 16 | 17 | bool AbstractTableConstraint::operator!=(const AbstractTableConstraint& rhs) const { return !(rhs == *this); } 18 | 19 | } // namespace opossum 20 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/base_segment_accessor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "resolve_type.hpp" 8 | #include "types.hpp" 9 | 10 | namespace opossum { 11 | 12 | class BaseSegmentAccessor { 13 | public: 14 | BaseSegmentAccessor() = default; 15 | BaseSegmentAccessor(const BaseSegmentAccessor&) = default; 16 | BaseSegmentAccessor(BaseSegmentAccessor&&) = default; 17 | 18 | virtual ~BaseSegmentAccessor() {} 19 | }; 20 | 21 | /** 22 | * This is the base class for all SegmentAccessor types. 23 | * It provides the common interface to access individual values of a segment. 24 | */ 25 | template 26 | class AbstractSegmentAccessor : public BaseSegmentAccessor { 27 | public: 28 | virtual const std::optional access(ChunkOffset offset) const = 0; 29 | }; 30 | 31 | } // namespace opossum 32 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/create_iterable_from_reference_segment.ipp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "storage/reference_segment/reference_segment_iterable.hpp" 4 | 5 | namespace opossum { 6 | 7 | template 8 | auto create_iterable_from_segment(const ReferenceSegment& segment) { 9 | if constexpr (EraseSegmentType) { 10 | return create_any_segment_iterable(segment); 11 | } else { 12 | return ReferenceSegmentIterable{segment}; 13 | } 14 | } 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/index/index_statistics.cpp: -------------------------------------------------------------------------------- 1 | #include "storage/index/index_statistics.hpp" 2 | 3 | namespace opossum { 4 | 5 | bool operator==(const IndexStatistics& left, const IndexStatistics& right) { 6 | return std::tie(left.column_ids, left.name, left.type) == std::tie(right.column_ids, right.name, right.type); 7 | } 8 | 9 | } // namespace opossum 10 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/index/index_statistics.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "segment_index_type.hpp" 6 | #include "types.hpp" 7 | 8 | namespace opossum { 9 | 10 | struct IndexStatistics { 11 | std::vector column_ids; 12 | std::string name; 13 | SegmentIndexType type; 14 | }; 15 | 16 | // For googletest 17 | bool operator==(const IndexStatistics& left, const IndexStatistics& right); 18 | 19 | } // namespace opossum 20 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/lqp_view.cpp: -------------------------------------------------------------------------------- 1 | #include "lqp_view.hpp" 2 | 3 | #include "logical_query_plan/abstract_lqp_node.hpp" 4 | #include "logical_query_plan/lqp_utils.hpp" 5 | 6 | namespace opossum { 7 | 8 | LQPView::LQPView(const std::shared_ptr& init_lqp, 9 | std::unordered_map init_column_names = {}) 10 | : lqp(init_lqp), column_names(std::move(init_column_names)) {} 11 | 12 | std::shared_ptr LQPView::deep_copy() const { 13 | return std::make_shared(lqp->deep_copy(), column_names); 14 | } 15 | 16 | bool LQPView::deep_equals(const LQPView& other) const { 17 | return *lqp == *other.lqp && column_names == other.column_names; 18 | } 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/lqp_view.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "types.hpp" 7 | 8 | namespace opossum { 9 | 10 | class AbstractLQPNode; 11 | 12 | /** 13 | * A SQL View represented by an LQP. 14 | * When used in an SQL query, the SQLTranslator hooks a copy of this LQP into the LQP it creates 15 | */ 16 | class LQPView { 17 | public: 18 | LQPView(const std::shared_ptr& lqp, std::unordered_map column_names); 19 | 20 | std::shared_ptr deep_copy() const; 21 | bool deep_equals(const LQPView& other) const; 22 | 23 | const std::shared_ptr lqp; 24 | const std::unordered_map column_names; 25 | }; 26 | 27 | } // namespace opossum 28 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/pos_lists/abstract_pos_list.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_pos_list.hpp" 2 | 3 | namespace opossum { 4 | AbstractPosList::PosListIterator<> AbstractPosList::begin() const { 5 | PerformanceWarning("Unresolved iterator created for AbstractPosList"); 6 | return PosListIterator<>(this, ChunkOffset{0}); 7 | } 8 | 9 | AbstractPosList::PosListIterator<> AbstractPosList::end() const { 10 | return PosListIterator<>(this, static_cast(size())); 11 | } 12 | 13 | AbstractPosList::PosListIterator<> AbstractPosList::cbegin() const { return begin(); } 14 | 15 | AbstractPosList::PosListIterator<> AbstractPosList::cend() const { return end(); } 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/table_key_constraint.cpp: -------------------------------------------------------------------------------- 1 | #include "table_key_constraint.hpp" 2 | 3 | namespace opossum { 4 | 5 | TableKeyConstraint::TableKeyConstraint(std::unordered_set init_columns, KeyConstraintType init_key_type) 6 | : AbstractTableConstraint(std::move(init_columns)), _key_type(init_key_type) {} 7 | 8 | KeyConstraintType TableKeyConstraint::key_type() const { return _key_type; } 9 | 10 | bool TableKeyConstraint::_on_equals(const AbstractTableConstraint& table_constraint) const { 11 | DebugAssert(dynamic_cast(&table_constraint), 12 | "Different table_constraint type should have been caught by AbstractTableConstraint::operator=="); 13 | return key_type() == static_cast(table_constraint).key_type(); 14 | } 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/table_key_constraint.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "abstract_table_constraint.hpp" 4 | 5 | namespace opossum { 6 | 7 | enum class KeyConstraintType { PRIMARY_KEY, UNIQUE }; 8 | 9 | /** 10 | * Container class to define uniqueness constraints for tables. 11 | * As defined by SQL, two types of keys are supported: PRIMARY KEY and UNIQUE keys. 12 | */ 13 | class TableKeyConstraint final : public AbstractTableConstraint { 14 | public: 15 | TableKeyConstraint(std::unordered_set init_columns, KeyConstraintType init_key_type); 16 | 17 | KeyConstraintType key_type() const; 18 | 19 | protected: 20 | bool _on_equals(const AbstractTableConstraint& table_constraint) const override; 21 | 22 | private: 23 | KeyConstraintType _key_type; 24 | }; 25 | 26 | using TableKeyConstraints = std::vector; 27 | 28 | } // namespace opossum 29 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/storage/vector_compression/simd_bp128/oversized_types.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * @defgroup Oversized unsigned integer types 9 | * 10 | * Used to store aligned __m128i and __m256i in containers, 11 | * because __128i and __256i cannot be used as template parameters 12 | * with GCC v7. 13 | */ 14 | struct alignas(16) uint128_t { 15 | uint32_t data[4]; 16 | }; 17 | 18 | struct alignas(32) uint256_t { 19 | uint32_t data[8]; 20 | }; 21 | /**@}*/ 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/uid_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | /** 9 | * Thread-safe allocation of ids unique in some context (e.g. TaskIDs, WorkerIDs...) starting from 0 and incrementing 10 | */ 11 | class UidAllocator { 12 | public: 13 | std::uint32_t allocate() { return _incrementor++; } 14 | 15 | private: 16 | std::atomic _incrementor{0}; 17 | }; 18 | } // namespace opossum 19 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/aligned_size.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace opossum { 4 | 5 | // returns the actually used size by an object of type T 6 | template 7 | constexpr size_t aligned_size() { 8 | // next multiple of alignof(T), based on https://stackoverflow.com/a/4073700/2204581 9 | return sizeof(T) + alignof(T) - 1 - (sizeof(T) - 1) % alignof(T); 10 | } 11 | 12 | } // namespace opossum 13 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/column_ids_after_pruning.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "types.hpp" 4 | 5 | namespace opossum { 6 | 7 | // Stores the updated ColumnID at the index of the original ID if the original column was not pruned. 8 | // If the original column with ColumnID c was pruned, the id_mapping vector contains nullopt at index c. 9 | std::vector> column_ids_after_pruning(const size_t original_table_column_count, 10 | const std::vector& pruned_column_ids); 11 | 12 | } // namespace opossum 13 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/format_bytes.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | /** 9 | * @returns a string with 'bytes' formatted using a unit such as "3.405KB" or "360.420GB" 10 | */ 11 | std::string format_bytes(size_t bytes); 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/format_duration.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | // "3h 42min" instead of "2,53×10¹²ns" 9 | std::string format_duration(const std::chrono::nanoseconds& total_nanoseconds); 10 | 11 | } // namespace opossum 12 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/invalid_input_exception.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace opossum { 9 | 10 | /* 11 | * Hyrise specific exception used to handle errors related to wrong user input. 12 | * The console will catch this exception when parsing a sql string. 13 | * Also thrown by the macro AssertInput(expr, msg) to easily check user input related constraints. 14 | */ 15 | class InvalidInputException : public std::runtime_error { 16 | public: 17 | explicit InvalidInputException(const std::string& what_arg) : std::runtime_error(what_arg) {} 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/list_directory.cpp: -------------------------------------------------------------------------------- 1 | #include "list_directory.hpp" 2 | 3 | namespace opossum { 4 | 5 | std::vector list_directory(const std::string& directory) { 6 | std::vector files; 7 | 8 | for (const auto& directory_entry : std::filesystem::recursive_directory_iterator(directory)) { 9 | if (!std::filesystem::is_regular_file(directory_entry)) continue; 10 | 11 | files.emplace_back(directory_entry.path()); 12 | } 13 | 14 | return files; 15 | } 16 | 17 | } // namespace opossum 18 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/list_directory.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace opossum { 7 | 8 | // This is a hack to work around https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91067 9 | // By putting the iterator into its own compilation unit, we can set its optimization level to -O0. This hides the bug. 10 | // TODO(anyone): Replace callers with the directory_iterator once gcc 9.3 fixes the stdlibc++ bug. 11 | std::vector list_directory(const std::string& directory); 12 | 13 | } // namespace opossum 14 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/log_manager.cpp: -------------------------------------------------------------------------------- 1 | #include "log_manager.hpp" 2 | 3 | namespace opossum { 4 | 5 | void LogManager::add_message(const std::string& reporter, const std::string& message, const LogLevel log_level) { 6 | const auto now = std::chrono::system_clock::now(); 7 | const LogEntry log_entry{now, log_level, reporter, message}; 8 | std::cout << reporter << ": " << message << std::endl; 9 | _log_entries.emplace_back(log_entry); 10 | } 11 | 12 | const tbb::concurrent_vector& LogManager::log_entries() const { return _log_entries; } 13 | 14 | } // namespace opossum 15 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/log_manager.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "types.hpp" 8 | 9 | namespace opossum { 10 | 11 | struct LogEntry { 12 | std::chrono::system_clock::time_point timestamp; 13 | LogLevel log_level; 14 | std::string reporter; 15 | std::string message; 16 | }; 17 | 18 | class LogManager : public Noncopyable { 19 | public: 20 | void add_message(const std::string& reporter, const std::string& message, const LogLevel log_level = LogLevel::Debug); 21 | 22 | const tbb::concurrent_vector& log_entries() const; 23 | 24 | protected: 25 | friend class Hyrise; 26 | friend class LogManagerTest; 27 | 28 | private: 29 | tbb::concurrent_vector _log_entries; 30 | }; 31 | 32 | } // namespace opossum 33 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/make_bimap.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace opossum { 8 | 9 | /* 10 | * boost::bimap does not support initializer_lists. 11 | * Instead we use this helper function to have an initializer_list-friendly interface. 12 | */ 13 | template 14 | boost::bimap make_bimap(std::initializer_list::value_type> list) { 15 | return boost::bimap(list.begin(), list.end()); 16 | } 17 | 18 | } // namespace opossum 19 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_chunk_sort_orders_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing all sort orders of stored chunks via a meta table. 9 | */ 10 | class MetaChunkSortOrdersTable : public AbstractMetaTable { 11 | public: 12 | MetaChunkSortOrdersTable(); 13 | 14 | const std::string& name() const final; 15 | 16 | protected: 17 | std::shared_ptr
_on_generate() const final; 18 | }; 19 | } // namespace opossum 20 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_chunks_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing all stored chunks via a meta table. 9 | */ 10 | class MetaChunksTable : public AbstractMetaTable { 11 | public: 12 | MetaChunksTable(); 13 | 14 | const std::string& name() const final; 15 | 16 | protected: 17 | std::shared_ptr
_on_generate() const final; 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_columns_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing all stored columns via a meta table. 9 | */ 10 | class MetaColumnsTable : public AbstractMetaTable { 11 | public: 12 | MetaColumnsTable(); 13 | 14 | const std::string& name() const final; 15 | 16 | protected: 17 | std::shared_ptr
_on_generate() const final; 18 | }; 19 | 20 | } // namespace opossum 21 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_log_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | class MetaLogTable : public AbstractMetaTable { 8 | public: 9 | MetaLogTable(); 10 | 11 | const std::string& name() const final; 12 | 13 | protected: 14 | friend class MetaLogTest; 15 | std::shared_ptr
_on_generate() const final; 16 | }; 17 | 18 | } // namespace opossum 19 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_plugins_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for plugin control via a meta table. 9 | * Inserting loads a plugin, deleting unloads it. 10 | */ 11 | class MetaPluginsTable : public AbstractMetaTable { 12 | public: 13 | MetaPluginsTable(); 14 | 15 | const std::string& name() const final; 16 | 17 | bool can_insert() const final; 18 | bool can_delete() const final; 19 | 20 | protected: 21 | std::shared_ptr
_on_generate() const final; 22 | 23 | void _on_insert(const std::vector& values) final; 24 | void _on_remove(const std::vector& values) final; 25 | }; 26 | 27 | } // namespace opossum 28 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_segments_accurate_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing information of all stored segments via a meta table. 9 | * Here, we provide the distinct value count per segment. 10 | * It is which is expensive to get, as we need to interate over the values of all stored segments. 11 | * For faster results without that information use MetaSegmentsTable. 12 | */ 13 | class MetaSegmentsAccurateTable : public AbstractMetaTable { 14 | public: 15 | MetaSegmentsAccurateTable(); 16 | 17 | const std::string& name() const final; 18 | 19 | protected: 20 | std::shared_ptr
_on_generate() const final; 21 | }; 22 | 23 | } // namespace opossum 24 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_segments_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing information of all stored segments via a meta table. 9 | * Here, we do not provide the distinct value count per segment. 10 | * For slower results with that information use MetaSegmentsAccurateTable. 11 | */ 12 | class MetaSegmentsTable : public AbstractMetaTable { 13 | public: 14 | MetaSegmentsTable(); 15 | 16 | const std::string& name() const final; 17 | 18 | protected: 19 | std::shared_ptr
_on_generate() const final; 20 | }; 21 | 22 | } // namespace opossum 23 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_settings_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This meta table controls settings, such as, the available memory budget for an index plugin. 9 | */ 10 | class MetaSettingsTable : public AbstractMetaTable { 11 | public: 12 | MetaSettingsTable(); 13 | 14 | const std::string& name() const final; 15 | 16 | bool can_update() const final; 17 | 18 | protected: 19 | friend class MetaSettingsTest; 20 | std::shared_ptr
_on_generate() const final; 21 | 22 | void _on_update(const std::vector& selected_values, 23 | const std::vector& update_values) final; 24 | }; 25 | 26 | } // namespace opossum 27 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_system_information_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing information about static system properties such as hardware capabilities. 9 | */ 10 | class MetaSystemInformationTable : public AbstractMetaTable { 11 | public: 12 | MetaSystemInformationTable(); 13 | 14 | const std::string& name() const final; 15 | 16 | protected: 17 | std::shared_ptr
_on_generate() const final; 18 | 19 | static size_t _cpu_count(); 20 | static size_t _ram_size(); 21 | static std::string _cpu_model(); 22 | }; 23 | 24 | } // namespace opossum 25 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/meta_tables_table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/meta_tables/abstract_meta_table.hpp" 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * This is a class for showing all stored tables via a meta table. 9 | */ 10 | class MetaTablesTable : public AbstractMetaTable { 11 | public: 12 | MetaTablesTable(); 13 | const std::string& name() const final; 14 | 15 | protected: 16 | friend class MetaTableManager; 17 | 18 | std::shared_ptr
_on_generate() const final; 19 | }; 20 | 21 | } // namespace opossum 22 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/meta_tables/segment_meta_data.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "storage/table.hpp" 4 | 5 | namespace opossum { 6 | 7 | // Methods for collecting information about all stored segments, 8 | // used at MetaSegmentsTable and MetaSegmentsAccurateTable. 9 | 10 | /** 11 | * Fills the table with table name, chunk and column ID, column name, data type, 12 | * encoding, compression and estimated size. With full mode, also the number of disctinct values is included. 13 | */ 14 | void gather_segment_meta_data(const std::shared_ptr
& meta_table, const MemoryUsageCalculationMode mode); 15 | 16 | size_t get_distinct_value_count(const std::shared_ptr& segment); 17 | 18 | } // namespace opossum 19 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/performance_warning.cpp: -------------------------------------------------------------------------------- 1 | #include "performance_warning.hpp" 2 | 3 | namespace opossum { 4 | 5 | bool PerformanceWarningClass::_disabled = []() { // NOLINT 6 | // static initializer hack to print some warnings in various binaries 7 | 8 | if constexpr (HYRISE_DEBUG) { 9 | PerformanceWarning("Hyrise is running as a debug build."); 10 | } 11 | 12 | return false; 13 | }(); 14 | 15 | } // namespace opossum 16 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/settings/abstract_setting.cpp: -------------------------------------------------------------------------------- 1 | #include "abstract_setting.hpp" 2 | 3 | #include "hyrise.hpp" 4 | #include "utils/assert.hpp" 5 | 6 | namespace opossum { 7 | 8 | AbstractSetting::AbstractSetting(const std::string& init_name) : name(init_name) {} 9 | 10 | void AbstractSetting::register_at_settings_manager() { 11 | Hyrise::get().settings_manager._add(std::static_pointer_cast(shared_from_this())); 12 | } 13 | 14 | void AbstractSetting::unregister_at_settings_manager() { Hyrise::get().settings_manager._remove(name); } 15 | 16 | } // namespace opossum 17 | -------------------------------------------------------------------------------- /ssb/hyrise-dram/src/lib/utils/template_type.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace opossum { 6 | 7 | /** 8 | * Wraps a class template so that 9 | * it can be stored in a hana::type 10 | */ 11 | template