duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -10,7 +10,7 @@ PhysicalFilter::PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expr
 	D_ASSERT(select_list.size() > 0);
 	if (select_list.size() > 1) {
 		// create a big AND out of the expressions
-		auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
+		auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
 		for (auto &expr : select_list) {
 			conjunction->children.push_back(std::move(expr));
 		}
@@ -30,13 +30,13 @@ public:
 	SelectionVector sel;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &executor, "filter", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, executor, "filter", 0);
 	}
 };
 
 unique_ptr<OperatorState> PhysicalFilter::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<FilterState>(context, *expression);
+	return make_uniq<FilterState>(context, *expression);
 }
 
 OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,

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

@@ -31,15 +31,15 @@ public:
 
 SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate,
                                             LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &state = (BatchCollectorLocalState &)lstate_p;
+	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
 	state.data.Append(input, state.batch_index);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                      LocalSinkState &lstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
-	auto &state = (BatchCollectorLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
+	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.data.Merge(state.data);
@@ -47,25 +47,25 @@ void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState
 
 SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
 	auto collection = gstate.data.FetchCollection();
 	D_ASSERT(collection);
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
-	                                                   context.GetClientProperties());
+	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
+	                                                 context.GetClientProperties());
 	gstate.result = std::move(result);
 	return SinkFinalizeType::READY;
 }
 
 unique_ptr<LocalSinkState> PhysicalBatchCollector::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<BatchCollectorLocalState>(context.client, *this);
+	return make_uniq<BatchCollectorLocalState>(context.client, *this);
 }
 
 unique_ptr<GlobalSinkState> PhysicalBatchCollector::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<BatchCollectorGlobalState>(context, *this);
+	return make_uniq<BatchCollectorGlobalState>(context, *this);
 }
 
 unique_ptr<QueryResult> PhysicalBatchCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (BatchCollectorGlobalState &)state;
+	auto &gstate = state.Cast<BatchCollectorGlobalState>();
 	D_ASSERT(gstate.result);
 	return std::move(gstate.result);
 }

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

@@ -4,19 +4,14 @@
 
 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 {
+vector<const_reference<PhysicalOperator>> PhysicalExecute::GetChildren() const {
 	return {plan};
 }
 
-bool PhysicalExecute::AllOperatorsPreserveOrder() const {
-	D_ASSERT(plan);
-	return plan->AllOperatorsPreserveOrder();
-}
-
 void PhysicalExecute::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
 	// EXECUTE statement: build pipeline on child
 	meta_pipeline.Build(plan);

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

@@ -19,14 +19,14 @@ SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSin
 
 SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<ExplainAnalyzeStateGlobalState>();
 	auto &profiler = QueryProfiler::Get(context);
 	gstate.analyzed_plan = profiler.ToString();
 	return SinkFinalizeType::READY;
 }
 
 unique_ptr<GlobalSinkState> PhysicalExplainAnalyze::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<ExplainAnalyzeStateGlobalState>();
+	return make_uniq<ExplainAnalyzeStateGlobalState>();
 }
 
 //===--------------------------------------------------------------------===//
@@ -41,13 +41,13 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalExplainAnalyze::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<ExplainAnalyzeState>();
+	return make_uniq<ExplainAnalyzeState>();
 }
 
 void PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &source_state,
                                      LocalSourceState &lstate) const {
 	auto &state = (ExplainAnalyzeState &)source_state;
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<ExplainAnalyzeStateGlobalState>();
 	if (state.finished) {
 		return;
 	}

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

@@ -47,11 +47,11 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalLimit::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<LimitGlobalState>(context, *this);
+	return make_uniq<LimitGlobalState>(context, *this);
 }
 
 unique_ptr<LocalSinkState> PhysicalLimit::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<LimitLocalState>(context.client, *this);
+	return make_uniq<LimitLocalState>(context.client, *this);
 }
 
 bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset,
@@ -96,7 +96,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
                                    DataChunk &input) const {
 
 	D_ASSERT(input.size() > 0);
-	auto &state = (LimitLocalState &)lstate;
+	auto &state = lstate.Cast<LimitLocalState>();
 	auto &limit = state.limit;
 	auto &offset = state.offset;
 
@@ -111,12 +111,15 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
 	}
 	state.data.Append(input, lstate.batch_index);
 	state.current_offset += input.size();
+	if (state.current_offset == max_element) {
+		return SinkResultType::FINISHED;
+	}
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalLimit::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (LimitGlobalState &)gstate_p;
-	auto &state = (LimitLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<LimitGlobalState>();
+	auto &state = lstate_p.Cast<LimitLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.limit = state.limit;
@@ -140,13 +143,13 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalLimit::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<LimitSourceState>();
+	return make_uniq<LimitSourceState>();
 }
 
 void PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                             LocalSourceState &lstate) const {
-	auto &gstate = (LimitGlobalState &)*sink_state;
-	auto &state = (LimitSourceState &)gstate_p;
+	auto &gstate = sink_state->Cast<LimitGlobalState>();
+	auto &state = gstate_p.Cast<LimitSourceState>();
 	while (state.current_offset < gstate.limit + gstate.offset) {
 		if (!state.initialized) {
 			gstate.data.InitializeScan(state.scan_state);

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 {
 
@@ -40,13 +39,13 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<LimitPercentGlobalState>(context, *this);
+	return make_uniq<LimitPercentGlobalState>(context, *this);
 }
 
 SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
                                           DataChunk &input) const {
 	D_ASSERT(input.size() > 0);
-	auto &state = (LimitPercentGlobalState &)gstate;
+	auto &state = gstate.Cast<LimitPercentGlobalState>();
 	auto &limit_percent = state.limit_percent;
 	auto &offset = state.offset;
 
@@ -88,7 +87,7 @@ public:
 	explicit LimitPercentOperatorState(const PhysicalLimitPercent &op)
 	    : limit(DConstants::INVALID_INDEX), current_offset(0) {
 		D_ASSERT(op.sink_state);
-		auto &gstate = (LimitPercentGlobalState &)*op.sink_state;
+		auto &gstate = op.sink_state->Cast<LimitPercentGlobalState>();
 		gstate.data.InitializeScan(scan_state);
 	}
 
@@ -98,13 +97,13 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalLimitPercent::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<LimitPercentOperatorState>(*this);
+	return make_uniq<LimitPercentOperatorState>(*this);
 }
 
 void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                    LocalSourceState &lstate) const {
-	auto &gstate = (LimitPercentGlobalState &)*sink_state;
-	auto &state = (LimitPercentOperatorState &)gstate_p;
+	auto &gstate = sink_state->Cast<LimitPercentGlobalState>();
+	auto &state = gstate_p.Cast<LimitPercentOperatorState>();
 	auto &percent_limit = gstate.limit_percent;
 	auto &offset = gstate.offset;
 	auto &limit = state.limit;

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

@@ -27,15 +27,15 @@ public:
 
 SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
                                                    LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = (MaterializedCollectorLocalState &)lstate_p;
+	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
 	lstate.collection->Append(lstate.append_state, input);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                             LocalSinkState &lstate_p) const {
-	auto &gstate = (MaterializedCollectorGlobalState &)gstate_p;
-	auto &lstate = (MaterializedCollectorLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<MaterializedCollectorGlobalState>();
+	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
 	if (lstate.collection->Count() == 0) {
 		return;
 	}
@@ -49,25 +49,25 @@ void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSin
 }
 
 unique_ptr<GlobalSinkState> PhysicalMaterializedCollector::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_unique<MaterializedCollectorGlobalState>();
+	auto state = make_uniq<MaterializedCollectorGlobalState>();
 	state->context = context.shared_from_this();
 	return std::move(state);
 }
 
 unique_ptr<LocalSinkState> PhysicalMaterializedCollector::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_unique<MaterializedCollectorLocalState>();
-	state->collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+	auto state = make_uniq<MaterializedCollectorLocalState>();
+	state->collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	state->collection->InitializeAppend(state->append_state);
 	return std::move(state);
 }
 
 unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (MaterializedCollectorGlobalState &)state;
+	auto &gstate = state.Cast<MaterializedCollectorGlobalState>();
 	if (!gstate.collection) {
-		gstate.collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+		gstate.collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	}
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, std::move(gstate.collection),
-	                                                   gstate.context->GetClientProperties());
+	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(gstate.collection),
+	                                                 gstate.context->GetClientProperties());
 	return std::move(result);
 }
 
@@ -75,4 +75,8 @@ bool PhysicalMaterializedCollector::ParallelSink() const {
 	return parallel;
 }
 
+bool PhysicalMaterializedCollector::SinkOrderDependent() const {
+	return true;
+}
+
 } // namespace duckdb

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

@@ -14,13 +14,13 @@ public:
 			if (percentage == 0) {
 				return;
 			}
-			sample = make_unique<ReservoirSamplePercentage>(allocator, percentage, options.seed);
+			sample = make_uniq<ReservoirSamplePercentage>(allocator, percentage, options.seed);
 		} else {
 			auto size = options.sample_size.GetValue<int64_t>();
 			if (size == 0) {
 				return;
 			}
-			sample = make_unique<ReservoirSample>(allocator, size, options.seed);
+			sample = make_uniq<ReservoirSample>(allocator, size, options.seed);
 		}
 	}
 
@@ -31,12 +31,12 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalReservoirSample::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<SampleGlobalSinkState>(Allocator::Get(context), *options);
+	return make_uniq<SampleGlobalSinkState>(Allocator::Get(context), *options);
 }
 
 SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                              DataChunk &input) const {
-	auto &gstate = (SampleGlobalSinkState &)state;
+	auto &gstate = state.Cast<SampleGlobalSinkState>();
 	if (!gstate.sample) {
 		return SinkResultType::FINISHED;
 	}
@@ -53,7 +53,7 @@ SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSi
 //===--------------------------------------------------------------------===//
 void PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                       LocalSourceState &lstate) const {
-	auto &sink = (SampleGlobalSinkState &)*this->sink_state;
+	auto &sink = this->sink_state->Cast<SampleGlobalSinkState>();
 	if (!sink.sample) {
 		return;
 	}

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;
 }
 
@@ -20,40 +20,34 @@ unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(
                                                                                 PreparedStatementData &data) {
 	if (!PhysicalPlanGenerator::PreserveInsertionOrder(context, *data.plan)) {
 		// the plan is not order preserving, so we just use the parallel materialized collector
-		return make_unique_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, true);
+		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, true);
 	} else if (!PhysicalPlanGenerator::UseBatchIndex(context, *data.plan)) {
 		// the plan is order preserving, but we cannot use the batch index: use a single-threaded result collector
-		return make_unique_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, false);
+		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, false);
 	} else {
 		// we care about maintaining insertion order and the sources all support batch indexes
 		// use a batch collector
-		return make_unique_base<PhysicalResultCollector, PhysicalBatchCollector>(data);
+		return make_uniq_base<PhysicalResultCollector, PhysicalBatchCollector>(data);
 	}
 }
 
-vector<PhysicalOperator *> PhysicalResultCollector::GetChildren() const {
+vector<const_reference<PhysicalOperator>> PhysicalResultCollector::GetChildren() const {
 	return {plan};
 }
 
-bool PhysicalResultCollector::AllOperatorsPreserveOrder() const {
-	D_ASSERT(plan);
-	return plan->AllOperatorsPreserveOrder();
-}
-
 void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
 	// operator is a sink, build a pipeline
 	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();
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 
 	// we create a new pipeline starting from the child
-	auto child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	child_meta_pipeline->Build(plan);
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	child_meta_pipeline.Build(plan);
 }
 
 } // namespace duckdb

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

@@ -35,17 +35,17 @@ public:
 };
 
 unique_ptr<OperatorState> PhysicalStreamingLimit::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingLimitOperatorState>(*this);
+	return make_uniq<StreamingLimitOperatorState>(*this);
 }
 
 unique_ptr<GlobalOperatorState> PhysicalStreamingLimit::GetGlobalOperatorState(ClientContext &context) const {
-	return make_unique<StreamingLimitGlobalState>();
+	return make_uniq<StreamingLimitGlobalState>();
 }
 
 OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingLimitGlobalState &)gstate_p;
-	auto &state = (StreamingLimitOperatorState &)state_p;
+	auto &gstate = gstate_p.Cast<StreamingLimitGlobalState>();
+	auto &state = state_p.Cast<StreamingLimitOperatorState>();
 	auto &limit = state.limit;
 	auto &offset = state.offset;
 	idx_t current_offset = gstate.current_offset.fetch_add(input.size());
@@ -60,8 +60,8 @@ OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, Da
 	return OperatorResultType::NEED_MORE_INPUT;
 }
 
-bool PhysicalStreamingLimit::IsOrderDependent() const {
-	return !parallel;
+OrderPreservationType PhysicalStreamingLimit::OperatorOrder() const {
+	return OrderPreservationType::FIXED_ORDER;
 }
 
 bool PhysicalStreamingLimit::ParallelOperator() const {

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

@@ -23,7 +23,7 @@ public:
 
 void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
 	// system sampling: we throw one dice per chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
+	auto &state = state_p.Cast<StreamingSampleOperatorState>();
 	double rand = state.random.NextRandom();
 	if (rand <= percentage) {
 		// rand is smaller than sample_size: output chunk
@@ -34,7 +34,7 @@ void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result,
 void PhysicalStreamingSample::BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
 	// bernoulli sampling: we throw one dice per tuple
 	// then slice the result chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
+	auto &state = state_p.Cast<StreamingSampleOperatorState>();
 	idx_t result_count = 0;
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	for (idx_t i = 0; i < input.size(); i++) {
@@ -49,7 +49,7 @@ void PhysicalStreamingSample::BernoulliSample(DataChunk &input, DataChunk &resul
 }
 
 unique_ptr<OperatorState> PhysicalStreamingSample::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingSampleOperatorState>(seed);
+	return make_uniq<StreamingSampleOperatorState>(seed);
 }
 
 OperatorResultType PhysicalStreamingSample::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,

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

@@ -16,7 +16,7 @@ class VacuumLocalSinkState : public LocalSinkState {
 public:
 	explicit VacuumLocalSinkState(VacuumInfo &info) {
 		for (idx_t col_idx = 0; col_idx < info.columns.size(); col_idx++) {
-			column_distinct_stats.push_back(make_unique<DistinctStatistics>());
+			column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
 		}
 	};
 
@@ -24,14 +24,14 @@ public:
 };
 
 unique_ptr<LocalSinkState> PhysicalVacuum::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<VacuumLocalSinkState>(*info);
+	return make_uniq<VacuumLocalSinkState>(*info);
 }
 
 class VacuumGlobalSinkState : public GlobalSinkState {
 public:
 	explicit VacuumGlobalSinkState(VacuumInfo &info) {
 		for (idx_t col_idx = 0; col_idx < info.columns.size(); col_idx++) {
-			column_distinct_stats.push_back(make_unique<DistinctStatistics>());
+			column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
 		}
 	};
 
@@ -40,15 +40,18 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<VacuumGlobalSinkState>(*info);
+	return make_uniq<VacuumGlobalSinkState>(*info);
 }
 
 SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                     DataChunk &input) const {
-	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+	auto &lstate = lstate_p.Cast<VacuumLocalSinkState>();
 	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		if (!DistinctStatistics::TypeIsSupported(input.data[col_idx].GetType())) {
+			continue;
+		}
 		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
 	}
 
@@ -56,8 +59,8 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (VacuumGlobalSinkState &)gstate_p;
-	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<VacuumGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<VacuumLocalSinkState>();
 
 	lock_guard<mutex> lock(gstate.stats_lock);
 	D_ASSERT(gstate.column_distinct_stats.size() == lstate.column_distinct_stats.size());
@@ -68,13 +71,12 @@ void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &gstate) const {
-	auto &sink = (VacuumGlobalSinkState &)gstate;
+	auto &sink = gstate.Cast<VacuumGlobalSinkState>();
 
 	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		table->GetStorage().SetStatistics(info->column_id_map.at(col_idx), [&](BaseStatistics &stats) {
-			stats.distinct_stats = std::move(sink.column_distinct_stats[col_idx]);
-		});
+		table->GetStorage().SetDistinct(info->column_id_map.at(col_idx),
+		                                std::move(sink.column_distinct_stats[col_idx]));
 	}
 
 	return SinkFinalizeType::READY;

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;
 }
 
@@ -147,7 +162,7 @@ public:
 };
 
 unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionContext &context) {
-	auto state = make_unique<PerfectHashJoinState>(context.client, join);
+	auto state = make_uniq<PerfectHashJoinState>(context.client, join);
 	return std::move(state);
 }