duckdb 1.1.2-dev2.0 → 1.1.2-dev6.0

package/src/duckdb/src/execution/operator/persistent/physical_export.cpp

@@ -19,6 +19,12 @@ using std::stringstream;
 
 void ReorderTableEntries(catalog_entry_vector_t &tables);
 
+PhysicalExport::PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
+                               idx_t estimated_cardinality, unique_ptr<BoundExportData> exported_tables)
+    : PhysicalOperator(PhysicalOperatorType::EXPORT, std::move(types), estimated_cardinality),
+      function(std::move(function)), info(std::move(info)), exported_tables(std::move(exported_tables)) {
+}
+
 static void WriteCatalogEntries(stringstream &ss, catalog_entry_vector_t &entries) {
 	for (auto &entry : entries) {
 		if (entry.get().internal) {
@@ -121,6 +127,10 @@ void PhysicalExport::ExtractEntries(ClientContext &context, vector<reference<Sch
                                     ExportEntries &result) {
 	for (auto &schema_p : schema_list) {
 		auto &schema = schema_p.get();
+		auto &catalog = schema.ParentCatalog();
+		if (catalog.IsSystemCatalog() || catalog.IsTemporaryCatalog()) {
+			continue;
+		}
 		if (!schema.internal) {
 			result.schemas.push_back(schema);
 		}
@@ -225,8 +235,8 @@ SourceResultType PhysicalExport::GetData(ExecutionContext &context, DataChunk &c
 
 	// consider the order of tables because of foreign key constraint
 	entries.tables.clear();
-	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
-		entries.tables.push_back(exported_tables.data[i].entry);
+	for (idx_t i = 0; i < exported_tables->data.size(); i++) {
+		entries.tables.push_back(exported_tables->data[i].entry);
 	}
 
 	// order macro's by timestamp so nested macro's are imported nicely
@@ -252,8 +262,8 @@ SourceResultType PhysicalExport::GetData(ExecutionContext &context, DataChunk &c
 	// write the load.sql file
 	// for every table, we write COPY INTO statement with the specified options
 	stringstream load_ss;
-	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
-		auto exported_table_info = exported_tables.data[i].table_data;
+	for (idx_t i = 0; i < exported_tables->data.size(); i++) {
+		auto exported_table_info = exported_tables->data[i].table_data;
 		WriteCopyStatement(fs, load_ss, *info, exported_table_info, function);
 	}
 	WriteStringStreamToFile(fs, load_ss, fs.JoinPath(info->file_path, "load.sql"));

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -0,0 +1,207 @@
+#include "duckdb/execution/operator/schema/physical_create_index.hpp"
+
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/storage/index.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/storage/table/append_state.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
+
+namespace duckdb {
+
+PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table_p,
+                                         const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
+                                         vector<unique_ptr<Expression>> unbound_expressions,
+                                         idx_t estimated_cardinality, const bool sorted)
+    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
+      table(table_p.Cast<DuckTableEntry>()), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)),
+      sorted(sorted) {
+	// convert virtual column ids to storage column ids
+	for (auto &column_id : column_ids) {
+		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Sink
+//===--------------------------------------------------------------------===//
+
+class CreateIndexGlobalSinkState : public GlobalSinkState {
+public:
+	//! Global index to be added to the table
+	unique_ptr<Index> global_index;
+};
+
+class CreateIndexLocalSinkState : public LocalSinkState {
+public:
+	explicit CreateIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
+
+	unique_ptr<Index> local_index;
+	ArenaAllocator arena_allocator;
+	vector<ARTKey> keys;
+	DataChunk key_chunk;
+	vector<column_t> key_column_ids;
+};
+
+unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContext &context) const {
+	auto state = make_uniq<CreateIndexGlobalSinkState>();
+
+	// create the global index
+	switch (info->index_type) {
+	case IndexType::ART: {
+		auto &storage = table.GetStorage();
+		state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+		                                     info->constraint_type, storage.db);
+		break;
+	}
+	default:
+		throw InternalException("Unimplemented index type");
+	}
+	return (std::move(state));
+}
+
+unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionContext &context) const {
+	auto state = make_uniq<CreateIndexLocalSinkState>(context.client);
+
+	// create the local index
+	switch (info->index_type) {
+	case IndexType::ART: {
+		auto &storage = table.GetStorage();
+		state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+		                                    info->constraint_type, storage.db);
+		break;
+	}
+	default:
+		throw InternalException("Unimplemented index type");
+	}
+	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
+	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
+
+	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
+		state->key_column_ids.push_back(i);
+	}
+	return std::move(state);
+}
+
+SinkResultType PhysicalCreateIndex::SinkUnsorted(Vector &row_identifiers, OperatorSinkInput &input) const {
+
+	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto count = l_state.key_chunk.size();
+
+	// get the corresponding row IDs
+	row_identifiers.Flatten(count);
+	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
+
+	// insert the row IDs
+	auto &art = l_state.local_index->Cast<ART>();
+	for (idx_t i = 0; i < count; i++) {
+		if (!art.Insert(*art.tree, l_state.keys[i], 0, row_ids[i])) {
+			throw ConstraintException("Data contains duplicates on indexed column(s)");
+		}
+	}
+
+	return SinkResultType::NEED_MORE_INPUT;
+}
+
+SinkResultType PhysicalCreateIndex::SinkSorted(Vector &row_identifiers, OperatorSinkInput &input) const {
+
+	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &storage = table.GetStorage();
+	auto &l_index = l_state.local_index;
+
+	// create an ART from the chunk
+	auto art = make_uniq<ART>(l_index->column_ids, l_index->table_io_manager, l_index->unbound_expressions,
+	                          l_index->constraint_type, storage.db, l_index->Cast<ART>().allocators);
+	if (!art->ConstructFromSorted(l_state.key_chunk.size(), l_state.keys, row_identifiers)) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
+
+	// merge into the local ART
+	if (!l_index->MergeIndexes(*art)) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
+
+	return SinkResultType::NEED_MORE_INPUT;
+}
+
+SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+
+	D_ASSERT(chunk.ColumnCount() >= 2);
+
+	// generate the keys for the given input
+	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	l_state.key_chunk.ReferenceColumns(chunk, l_state.key_column_ids);
+	l_state.arena_allocator.Reset();
+	ART::GenerateKeys(l_state.arena_allocator, l_state.key_chunk, l_state.keys);
+
+	// insert the keys and their corresponding row IDs
+	auto &row_identifiers = chunk.data[chunk.ColumnCount() - 1];
+	if (sorted) {
+		return SinkSorted(row_identifiers, input);
+	}
+	return SinkUnsorted(row_identifiers, input);
+}
+
+SinkCombineResultType PhysicalCreateIndex::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+
+	auto &gstate = input.global_state.Cast<CreateIndexGlobalSinkState>();
+	auto &lstate = input.local_state.Cast<CreateIndexLocalSinkState>();
+
+	// merge the local index into the global index
+	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
+
+	return SinkCombineResultType::FINISHED;
+}
+
+SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+                                               OperatorSinkFinalizeInput &input) const {
+
+	// here, we set the resulting global index as the newly created index of the table
+	auto &state = input.global_state.Cast<CreateIndexGlobalSinkState>();
+
+	// vacuum excess memory and verify
+	state.global_index->Vacuum();
+	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
+
+	auto &storage = table.GetStorage();
+	if (!storage.IsRoot()) {
+		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
+	}
+
+	auto &schema = table.schema;
+	auto index_entry = schema.CreateIndex(context, *info, table).get();
+	if (!index_entry) {
+		D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
+		// index already exists, but error ignored because of IF NOT EXISTS
+		return SinkFinalizeType::READY;
+	}
+	auto &index = index_entry->Cast<DuckIndexEntry>();
+
+	index.index = state.global_index.get();
+	index.info = storage.info;
+	for (auto &parsed_expr : info->parsed_expressions) {
+		index.parsed_expressions.push_back(parsed_expr->Copy());
+	}
+
+	// add index to storage
+	storage.info->indexes.AddIndex(std::move(state.global_index));
+	return SinkFinalizeType::READY;
+}
+
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
+
+SourceResultType PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSourceInput &input) const {
+	return SourceResultType::FINISHED;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/partitionable_hashtable.cpp

@@ -0,0 +1,207 @@
+#include "duckdb/execution/partitionable_hashtable.hpp"
+
+#include "duckdb/common/radix_partitioning.hpp"
+
+namespace duckdb {
+
+RadixPartitionInfo::RadixPartitionInfo(const idx_t n_partitions_upper_bound)
+    : n_partitions(PreviousPowerOfTwo(n_partitions_upper_bound)),
+      radix_bits(RadixPartitioning::RadixBits(n_partitions)), radix_mask(RadixPartitioning::Mask(radix_bits)),
+      radix_shift(RadixPartitioning::Shift(radix_bits)) {
+
+	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
+	D_ASSERT(n_partitions > 0);
+	D_ASSERT(n_partitions == RadixPartitioning::NumberOfPartitions(radix_bits));
+	D_ASSERT(IsPowerOfTwo(n_partitions));
+}
+
+PartitionableHashTable::PartitionableHashTable(ClientContext &context, Allocator &allocator,
+                                               RadixPartitionInfo &partition_info_p, vector<LogicalType> group_types_p,
+                                               vector<LogicalType> payload_types_p,
+                                               vector<BoundAggregateExpression *> bindings_p)
+    : context(context), allocator(allocator), group_types(std::move(group_types_p)),
+      payload_types(std::move(payload_types_p)), bindings(std::move(bindings_p)), is_partitioned(false),
+      partition_info(partition_info_p), hashes(LogicalType::HASH), hashes_subset(LogicalType::HASH) {
+
+	sel_vectors.resize(partition_info.n_partitions);
+	sel_vector_sizes.resize(partition_info.n_partitions);
+	group_subset.Initialize(allocator, group_types);
+	if (!payload_types.empty()) {
+		payload_subset.Initialize(allocator, payload_types);
+	}
+
+	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
+		sel_vectors[r].Initialize();
+	}
+
+	RowLayout layout;
+	layout.Initialize(group_types, AggregateObject::CreateAggregateObjects(bindings));
+	tuple_size = layout.GetRowWidth();
+}
+
+HtEntryType PartitionableHashTable::GetHTEntrySize() {
+	// we need at least STANDARD_VECTOR_SIZE entries to fit in the hash table
+	if (GroupedAggregateHashTable::GetMaxCapacity(HtEntryType::HT_WIDTH_32, tuple_size) < STANDARD_VECTOR_SIZE) {
+		return HtEntryType::HT_WIDTH_64;
+	}
+	return HtEntryType::HT_WIDTH_32;
+}
+
+bool OverMemoryLimit(ClientContext &context, const bool is_partitioned, const RadixPartitionInfo &partition_info,
+                     const GroupedAggregateHashTable &ht) {
+	const auto n_partitions = is_partitioned ? partition_info.n_partitions : 1;
+	const auto max_memory = BufferManager::GetBufferManager(context).GetMaxMemory();
+	const auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+	const auto memory_per_partition = 0.6 * max_memory / num_threads / n_partitions;
+	return ht.TotalSize() > memory_per_partition;
+}
+
+idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes,
+                                           DataChunk &payload, const unsafe_vector<idx_t> &filter) {
+	// If this is false, a single AddChunk would overflow the max capacity
+	D_ASSERT(list.empty() || groups.size() <= list.back()->MaxCapacity());
+	if (list.empty() || list.back()->Count() + groups.size() >= list.back()->MaxCapacity() ||
+	    OverMemoryLimit(context, is_partitioned, partition_info, *list.back())) {
+		idx_t new_capacity = GroupedAggregateHashTable::InitialCapacity();
+		if (!list.empty()) {
+			new_capacity = list.back()->Capacity();
+			// early release first part of ht and prevent adding of more data
+			list.back()->Finalize();
+		}
+		list.push_back(make_uniq<GroupedAggregateHashTable>(context, allocator, group_types, payload_types, bindings,
+		                                                    GetHTEntrySize(), new_capacity));
+	}
+	return list.back()->AddChunk(append_state, groups, group_hashes, payload, filter);
+}
+
+idx_t PartitionableHashTable::AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition,
+                                       const unsafe_vector<idx_t> &filter) {
+	groups.Hash(hashes);
+
+	// we partition when we are asked to or when the unpartitioned ht runs out of space
+	if (!IsPartitioned() && do_partition) {
+		Partition(false);
+	}
+
+	if (!IsPartitioned()) {
+		return ListAddChunk(unpartitioned_hts, groups, hashes, payload, filter);
+	}
+
+	// makes no sense to do this with 1 partition
+	D_ASSERT(partition_info.n_partitions > 0);
+
+	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
+		sel_vector_sizes[r] = 0;
+	}
+
+	hashes.Flatten(groups.size());
+	auto hashes_ptr = FlatVector::GetData<hash_t>(hashes);
+
+	// Determine for every partition how much data will be sinked into it
+	for (idx_t i = 0; i < groups.size(); i++) {
+		auto partition = partition_info.GetHashPartition(hashes_ptr[i]);
+		D_ASSERT(partition < partition_info.n_partitions);
+		sel_vectors[partition].set_index(sel_vector_sizes[partition]++, i);
+	}
+
+#ifdef DEBUG
+	// make sure we have lost no rows
+	idx_t total_count = 0;
+	for (idx_t r = 0; r < partition_info.n_partitions; r++) {
+		total_count += sel_vector_sizes[r];
+	}
+	D_ASSERT(total_count == groups.size());
+#endif
+	idx_t group_count = 0;
+	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
+		group_subset.Slice(groups, sel_vectors[r], sel_vector_sizes[r]);
+		if (!payload_types.empty()) {
+			payload_subset.Slice(payload, sel_vectors[r], sel_vector_sizes[r]);
+		} else {
+			payload_subset.SetCardinality(sel_vector_sizes[r]);
+		}
+		hashes_subset.Slice(hashes, sel_vectors[r], sel_vector_sizes[r]);
+
+		group_count += ListAddChunk(radix_partitioned_hts[r], group_subset, hashes_subset, payload_subset, filter);
+	}
+	return group_count;
+}
+
+void PartitionableHashTable::Partition(bool sink_done) {
+	D_ASSERT(!IsPartitioned());
+	D_ASSERT(radix_partitioned_hts.empty());
+	D_ASSERT(partition_info.n_partitions > 1);
+
+	vector<GroupedAggregateHashTable *> partition_hts(partition_info.n_partitions);
+	radix_partitioned_hts.resize(partition_info.n_partitions);
+	for (auto &unpartitioned_ht : unpartitioned_hts) {
+		for (idx_t r = 0; r < partition_info.n_partitions; r++) {
+			radix_partitioned_hts[r].push_back(make_uniq<GroupedAggregateHashTable>(
+			    context, allocator, group_types, payload_types, bindings, GetHTEntrySize()));
+			partition_hts[r] = radix_partitioned_hts[r].back().get();
+		}
+		unpartitioned_ht->Partition(partition_hts, partition_info.radix_bits, sink_done);
+		unpartitioned_ht.reset();
+	}
+	unpartitioned_hts.clear();
+	is_partitioned = true;
+}
+
+bool PartitionableHashTable::IsPartitioned() {
+	return is_partitioned;
+}
+
+HashTableList PartitionableHashTable::GetPartition(idx_t partition) {
+	D_ASSERT(IsPartitioned());
+	D_ASSERT(partition < partition_info.n_partitions);
+	D_ASSERT(radix_partitioned_hts.size() > partition);
+	return std::move(radix_partitioned_hts[partition]);
+}
+
+HashTableList PartitionableHashTable::GetUnpartitioned() {
+	D_ASSERT(!IsPartitioned());
+	return std::move(unpartitioned_hts);
+}
+
+idx_t PartitionableHashTable::GetPartitionCount(idx_t partition) const {
+	idx_t total_size = 0;
+	for (const auto &ht : radix_partitioned_hts[partition]) {
+		total_size += ht->Count();
+	}
+	return total_size;
+}
+
+idx_t PartitionableHashTable::GetPartitionSize(idx_t partition) const {
+	idx_t total_size = 0;
+	for (const auto &ht : radix_partitioned_hts[partition]) {
+		total_size += ht->DataSize();
+	}
+	return total_size;
+}
+
+void PartitionableHashTable::Finalize() {
+	if (IsPartitioned()) {
+		for (auto &ht_list : radix_partitioned_hts) {
+			for (auto &ht : ht_list) {
+				D_ASSERT(ht);
+				ht->Finalize();
+			}
+		}
+	} else {
+		for (auto &ht : unpartitioned_hts) {
+			D_ASSERT(ht);
+			ht->Finalize();
+		}
+	}
+}
+
+void PartitionableHashTable::Append(GroupedAggregateHashTable &ht) {
+	if (unpartitioned_hts.empty()) {
+		unpartitioned_hts.push_back(make_uniq<GroupedAggregateHashTable>(context, allocator, group_types, payload_types,
+		                                                                 bindings, GetHTEntrySize(),
+		                                                                 GroupedAggregateHashTable::InitialCapacity()));
+	}
+	unpartitioned_hts.back()->Append(ht);
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -130,7 +130,12 @@ void PerfectAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload)
 	// compute the actual pointer to the data by adding it to the base HT pointer and multiplying by the tuple size
 	for (idx_t i = 0; i < groups.size(); i++) {
 		const auto group = address_data[i];
-		D_ASSERT(group < total_groups);
+		if (group >= total_groups) {
+			throw InvalidInputException("Perfect hash aggregate: aggregate group %llu exceeded total groups %llu. This "
+			                            "likely means that the statistics in your data source are corrupt.\n* PRAGMA "
+			                            "disable_optimizer to disable optimizations that rely on correct statistics",
+			                            group, total_groups);
+		}
 		group_is_set[group] = true;
 		address_data[i] = uintptr_t(data) + group * tuple_size;
 	}

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -117,10 +117,6 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	if (join_state.build_range > MAX_BUILD_SIZE) {
 		return;
 	}
-	if (NumericStats::Min(stats_build) <= NumericStats::Min(stats_probe) &&
-	    NumericStats::Max(stats_probe) <= NumericStats::Max(stats_build)) {
-		join_state.is_probe_in_domain = true;
-	}
 	join_state.is_build_small = true;
 	return;
 }

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -1,24 +1,16 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
 #include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
-#include "duckdb/execution/operator/order/physical_order.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/expression/bound_operator_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/table_filter.hpp"
+
+#include "duckdb/main/database.hpp"
+#include "duckdb/execution/index/index_type.hpp"
+#include "duckdb/execution/index/bound_index.hpp"
 
 namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateIndex &op) {
-	// generate a physical plan for the parallel index creation which consists of the following operators
-	// table scan - projection (for expression execution) - filter (NOT NULL) - order (if applicable) - create index
-
-	D_ASSERT(op.children.size() == 1);
-	auto table_scan = CreatePlan(*op.children[0]);
 
 	// validate that all expressions contain valid scalar functions
 	// e.g. get_current_timestamp(), random(), and sequence values are not allowed as index keys
@@ -30,12 +22,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 		}
 	}
 
-	// if we get here and the index type is not ART, we throw an exception
-	// because we don't support any other index type yet. However, an operator extension could have
-	// replaced this part of the plan with a different index creation operator.
-	if (op.info->index_type != ART::TYPE_NAME) {
+	// Do we have a valid index type?
+	const auto index_type = context.db->config.GetIndexTypes().FindByName(op.info->index_type);
+	if (!index_type) {
 		throw BinderException("Unknown index type: " + op.info->index_type);
 	}
+	if (!index_type->create_plan) {
+		throw InternalException("Index type '%s' is missing a create_plan function", op.info->index_type);
+	}
 
 	// table scan operator for index key columns and row IDs
 	dependencies.AddDependency(op.table);
@@ -43,78 +37,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->column_ids.size());
 
-	// projection to execute expressions on the key columns
-
-	vector<LogicalType> new_column_types;
-	vector<unique_ptr<Expression>> select_list;
-	for (idx_t i = 0; i < op.expressions.size(); i++) {
-		new_column_types.push_back(op.expressions[i]->return_type);
-		select_list.push_back(std::move(op.expressions[i]));
-	}
-	new_column_types.emplace_back(LogicalType::ROW_TYPE);
-	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
-
-	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
-	projection->children.push_back(std::move(table_scan));
-
-	// filter operator for IS_NOT_NULL on each key column
-
-	vector<LogicalType> filter_types;
-	vector<unique_ptr<Expression>> filter_select_list;
-
-	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
-		filter_types.push_back(new_column_types[i]);
-		auto is_not_null_expr =
-		    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-		auto bound_ref = make_uniq<BoundReferenceExpression>(new_column_types[i], i);
-		is_not_null_expr->children.push_back(std::move(bound_ref));
-		filter_select_list.push_back(std::move(is_not_null_expr));
-	}
-
-	auto null_filter =
-	    make_uniq<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
-	null_filter->types.emplace_back(LogicalType::ROW_TYPE);
-	null_filter->children.push_back(std::move(projection));
-
-	// determine if we sort the data prior to index creation
-	// we don't sort, if either VARCHAR or compound key
-	auto perform_sorting = true;
-	if (op.unbound_expressions.size() > 1) {
-		perform_sorting = false;
-	} else if (op.unbound_expressions[0]->return_type.InternalType() == PhysicalType::VARCHAR) {
-		perform_sorting = false;
-	}
-
-	// actual physical create index operator
-
-	auto physical_create_index =
-	    make_uniq<PhysicalCreateARTIndex>(op, op.table, op.info->column_ids, std::move(op.info),
-	                                      std::move(op.unbound_expressions), op.estimated_cardinality, perform_sorting);
-
-	if (perform_sorting) {
-
-		// optional order operator
-		vector<BoundOrderByNode> orders;
-		vector<idx_t> projections;
-		for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
-			auto col_expr = make_uniq_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
-			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(col_expr));
-			projections.emplace_back(i);
-		}
-		projections.emplace_back(new_column_types.size() - 1);
-
-		auto physical_order = make_uniq<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections),
-		                                               op.estimated_cardinality);
-		physical_order->children.push_back(std::move(null_filter));
-
-		physical_create_index->children.push_back(std::move(physical_order));
-	} else {
-
-		// no ordering
-		physical_create_index->children.push_back(std::move(null_filter));
-	}
+	D_ASSERT(op.children.size() == 1);
+	auto table_scan = CreatePlan(*op.children[0]);
 
-	return std::move(physical_create_index);
+	PlanIndexInput input(context, op, table_scan);
+	return index_type->create_plan(input);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_export.cpp

@@ -11,7 +11,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExport &op
 		throw PermissionException("Export is disabled through configuration");
 	}
 	auto export_node = make_uniq<PhysicalExport>(op.types, op.function, std::move(op.copy_info),
-	                                             op.estimated_cardinality, op.exported_tables);
+	                                             op.estimated_cardinality, std::move(op.exported_tables));
 	// plan the underlying copy statements, if any
 	if (!op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);

package/src/duckdb/src/execution/physical_plan/plan_get.cpp

@@ -159,7 +159,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
 		vector<unique_ptr<Expression>> expressions;
 		for (auto &column_id : column_ids) {
 			if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-				types.emplace_back(LogicalType::BIGINT);
+				types.emplace_back(LogicalType::ROW_TYPE);
 				expressions.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(0)));
 			} else {
 				auto type = op.returned_types[column_id];

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -79,7 +79,7 @@ unique_ptr<DataChunk> ReservoirSample::GetChunk() {
 		for (idx_t i = samples_remaining; i < collected_sample_count; i++) {
 			sel.set_index(i - samples_remaining, i);
 		}
-		ret->Initialize(allocator, reservoir_types.begin(), reservoir_types.end(), STANDARD_VECTOR_SIZE);
+		ret->Initialize(allocator, reservoir_types);
 		ret->Slice(*reservoir_data_chunk, sel, STANDARD_VECTOR_SIZE);
 		ret->SetCardinality(STANDARD_VECTOR_SIZE);
 		// reduce capacity and cardinality of the sample data chunk

package/src/duckdb/src/execution/window_executor.cpp

@@ -1671,23 +1671,23 @@ void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate,
 		// else offset is zero, so don't move.
 
 		if (can_shift) {
+			const auto target_limit = MinValue(partition_end[i], row_end) - row_idx;
 			if (!delta) {
 				//	Copy source[index:index+width] => result[i:]
 				const auto index = NumericCast<idx_t>(val_idx);
 				const auto source_limit = partition_end[i] - index;
-				const auto target_limit = MinValue(partition_end[i], row_end) - row_idx;
 				const auto width = MinValue(source_limit, target_limit);
 				auto &source = payload_collection.data[0];
 				VectorOperations::Copy(source, result, index + width, index, i);
 				i += width;
 				row_idx += width;
 			} else if (wexpr.default_expr) {
-				const auto width = MinValue(delta, count - i);
+				const auto width = MinValue(delta, target_limit);
 				llstate.leadlag_default.CopyCell(result, i, width);
 				i += width;
 				row_idx += width;
 			} else {
-				for (idx_t nulls = MinValue(delta, count - i); nulls--; ++i, ++row_idx) {
+				for (idx_t nulls = MinValue(delta, target_limit); nulls--; ++i, ++row_idx) {
 					FlatVector::SetNull(result, i, true);
 				}
 			}