duckdb 0.7.2-dev1901.0 → 0.7.2-dev2144.0

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -2,11 +2,13 @@
 
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/partition_state.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
-#include "duckdb/common/types/column_data_consumer.hpp"
-#include "duckdb/common/types/row_data_collection_scanner.hpp"
+#include "duckdb/common/types/column/column_data_consumer.hpp"
+#include "duckdb/common/types/row/row_data_collection_scanner.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -17,8 +19,6 @@
 #include "duckdb/parallel/base_pipeline_event.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/optional_ptr.hpp"
 
 #include <algorithm>
 #include <cmath>

package/src/duckdb/src/execution/operator/helper/physical_execute.cpp

@@ -4,12 +4,12 @@
 
 namespace duckdb {
 
-PhysicalExecute::PhysicalExecute(PhysicalOperator *plan)
-    : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan->types, -1), plan(plan) {
+PhysicalExecute::PhysicalExecute(PhysicalOperator &plan)
+    : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan.types, -1), plan(plan) {
 }
 
 vector<PhysicalOperator *> PhysicalExecute::GetChildren() const {
-	return {plan};
+	return {&plan};
 }
 
 void PhysicalExecute::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {

package/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/execution/operator/helper/physical_limit_percent.hpp"
-#include "duckdb/execution/operator/helper/physical_limit.hpp"
 
 #include "duckdb/common/algorithm.hpp"
-
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/execution/operator/helper/physical_limit.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp

@@ -12,7 +12,7 @@ namespace duckdb {
 
 PhysicalResultCollector::PhysicalResultCollector(PreparedStatementData &data)
     : PhysicalOperator(PhysicalOperatorType::RESULT_COLLECTOR, {LogicalType::BOOLEAN}, 0),
-      statement_type(data.statement_type), properties(data.properties), plan(data.plan.get()), names(data.names) {
+      statement_type(data.statement_type), properties(data.properties), plan(*data.plan), names(data.names) {
 	this->types = data.types;
 }
 
@@ -32,7 +32,7 @@ unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(
 }
 
 vector<PhysicalOperator *> PhysicalResultCollector::GetChildren() const {
-	return {plan};
+	return {&plan};
 }
 
 void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
@@ -40,7 +40,6 @@ void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &me
 	sink_state.reset();
 
 	D_ASSERT(children.empty());
-	D_ASSERT(plan);
 
 	// single operator: the operator becomes the data source of the current pipeline
 	auto &state = meta_pipeline.GetState();

package/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/execution/operator/join/perfect_hash_join_executor.hpp"
 
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
 #include "duckdb/execution/operator/join/physical_hash_join.hpp"
 
 namespace duckdb {
@@ -23,32 +23,41 @@ bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
 	for (const auto &type : ht.build_types) {
 		perfect_hash_table.emplace_back(type, build_size);
 	}
+
 	// and for duplicate_checking
 	bitmap_build_idx = unique_ptr<bool[]>(new bool[build_size]);
 	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
 
-	// pin all fixed-size blocks (variable-sized should still be pinned)
-	ht.PinAllBlocks();
-
 	// Now fill columns with build data
-	JoinHTScanState join_ht_state;
-	return FullScanHashTable(join_ht_state, key_type);
+
+	return FullScanHashTable(key_type);
 }
 
-bool PerfectHashJoinExecutor::FullScanHashTable(JoinHTScanState &state, LogicalType &key_type) {
-	Vector tuples_addresses(LogicalType::POINTER, ht.Count());              // allocate space for all the tuples
-	auto key_locations = FlatVector::GetData<data_ptr_t>(tuples_addresses); // get a pointer to vector data
+bool PerfectHashJoinExecutor::FullScanHashTable(LogicalType &key_type) {
+	auto &data_collection = ht.GetDataCollection();
+
 	// TODO: In a parallel finalize: One should exclusively lock and each thread should do one part of the code below.
-	// Go through all the blocks and fill the keys addresses
-	auto keys_count = ht.FillWithHTOffsets(key_locations, state);
+	Vector tuples_addresses(LogicalType::POINTER, ht.Count()); // allocate space for all the tuples
+
+	idx_t key_count = 0;
+	if (data_collection.ChunkCount() > 0) {
+		JoinHTScanState join_ht_state(data_collection, 0, data_collection.ChunkCount(),
+		                              TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
+
+		// Go through all the blocks and fill the keys addresses
+		key_count = ht.FillWithHTOffsets(join_ht_state, tuples_addresses);
+	}
+
 	// Scan the build keys in the hash table
-	Vector build_vector(key_type, keys_count);
-	RowOperations::FullScanColumn(ht.layout, tuples_addresses, build_vector, keys_count, 0);
+	Vector build_vector(key_type, key_count);
+	RowOperations::FullScanColumn(ht.layout, tuples_addresses, build_vector, key_count, 0);
+
 	// Now fill the selection vector using the build keys and create a sequential vector
-	// todo: add check for fast pass when probe is part of build domain
-	SelectionVector sel_build(keys_count + 1);
-	SelectionVector sel_tuples(keys_count + 1);
-	bool success = FillSelectionVectorSwitchBuild(build_vector, sel_build, sel_tuples, keys_count);
+	// TODO: add check for fast pass when probe is part of build domain
+	SelectionVector sel_build(key_count + 1);
+	SelectionVector sel_tuples(key_count + 1);
+	bool success = FillSelectionVectorSwitchBuild(build_vector, sel_build, sel_tuples, key_count);
+
 	// early out
 	if (!success) {
 		return false;
@@ -56,16 +65,22 @@ bool PerfectHashJoinExecutor::FullScanHashTable(JoinHTScanState &state, LogicalT
 	if (unique_keys == perfect_join_statistics.build_range + 1 && !ht.has_null) {
 		perfect_join_statistics.is_build_dense = true;
 	}
-	keys_count = unique_keys; // do not consider keys out of the range
+	key_count = unique_keys; // do not consider keys out of the range
+
 	// Full scan the remaining build columns and fill the perfect hash table
+	const auto build_size = perfect_join_statistics.build_range + 1;
 	for (idx_t i = 0; i < ht.build_types.size(); i++) {
-		auto build_size = perfect_join_statistics.build_range + 1;
 		auto &vector = perfect_hash_table[i];
 		D_ASSERT(vector.GetType() == ht.build_types[i]);
+		if (build_size > STANDARD_VECTOR_SIZE) {
+			auto &col_mask = FlatVector::Validity(vector);
+			col_mask.Initialize(build_size);
+		}
+
 		const auto col_no = ht.condition_types.size() + i;
-		RowOperations::Gather(tuples_addresses, sel_tuples, vector, sel_build, keys_count, ht.layout, col_no,
-		                      build_size);
+		data_collection.Gather(tuples_addresses, sel_tuples, key_count, col_no, vector, sel_build);
 	}
+
 	return true;
 }
 

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -1,10 +1,10 @@
 #include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
 
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
 #include "duckdb/execution/operator/join/outer_join_marker.hpp"
+#include "duckdb/execution/operator/join/physical_comparison_join.hpp"
 #include "duckdb/execution/operator/join/physical_cross_product.hpp"
 
 namespace duckdb {

package/src/duckdb/src/execution/operator/join/physical_cross_product.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/execution/operator/join/physical_cross_product.hpp"
 
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/operator/join/physical_join.hpp"
 

package/src/duckdb/src/execution/operator/join/physical_delim_join.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/execution/operator/join/physical_delim_join.hpp"
 
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
 #include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
@@ -125,7 +125,7 @@ void PhysicalDelimJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pip
 	sink_state.reset();
 
 	auto child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	child_meta_pipeline->Build(children[0].get());
+	child_meta_pipeline->Build(*children[0]);
 
 	if (type == PhysicalOperatorType::DELIM_JOIN) {
 		// recurse into the actual join