duckdb 0.7.1-dev2.0 → 0.7.1-dev284.0

package/src/duckdb/src/planner/binder/statement/bind_copy.cpp

@@ -97,17 +97,20 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	for (auto &option : original_options) {
 		auto loption = StringUtil::Lower(option.first);
 		if (loption == "use_tmp_file") {
-			use_tmp_file = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			use_tmp_file =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			user_set_use_tmp_file = true;
 			continue;
 		}
 		if (loption == "allow_overwrite") {
-			allow_overwrite = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			allow_overwrite =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
 
 		if (loption == "per_thread_output") {
-			per_thread_output = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			per_thread_output =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
 		if (loption == "partition_by") {

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -12,13 +12,11 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_database_info.hpp"
-#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/operator/logical_create.hpp"
@@ -26,13 +24,13 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/parsed_data/bound_create_function_info.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/parser/constraints/list.hpp"
@@ -651,23 +649,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
 		auto &base = (CreateDatabaseInfo &)*stmt.info;
-		string extension_name = base.extension_name;
 		string database_name = base.name;
 		string source_path = base.path;
 
 		auto &config = DBConfig::GetConfig(context);
-		for (auto &extension : config.create_database_extensions) {
-			auto create_database_function_ref =
-			    extension.function(context, extension_name, database_name, source_path, extension.data.get());
-			if (create_database_function_ref) {
-				auto bound_create_database_func = Bind(*create_database_function_ref);
-				result.plan = CreatePlan(*bound_create_database_func);
-				break;
-			}
-		}
-		if (!result.plan) {
+
+		if (config.storage_extensions.empty()) {
 			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
 		}
+		// for now assume only one storage extension provides the custom create_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->create_database != nullptr) {
+				auto &storage_extension = extension_entry.second;
+				auto create_database_function_ref = storage_extension->create_database(
+				    storage_extension->storage_info.get(), context, database_name, source_path);
+				if (create_database_function_ref) {
+					auto bound_create_database_func = Bind(*create_database_function_ref);
+					result.plan = CreatePlan(*bound_create_database_func);
+					break;
+				}
+			}
+		}
 		break;
 	}
 	default:

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -16,6 +16,8 @@
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/common/index_map.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/expression_binder/index_binder.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
 
 #include <algorithm>
 
@@ -300,4 +302,15 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 	return BindCreateTableInfo(std::move(info), schema);
 }
 
+vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
+	vector<unique_ptr<Expression>> expressions;
+
+	auto index_binder = IndexBinder(*this, this->context, table, info);
+	for (auto &expr : info->expressions) {
+		expressions.push_back(index_binder.Bind(expr));
+	}
+
+	return expressions;
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_detach.cpp

@@ -0,0 +1,19 @@
+#include "duckdb/parser/statement/detach_statement.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+BoundStatement Binder::Bind(DetachStatement &stmt) {
+	BoundStatement result;
+
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
+	result.names = {"Success"};
+	result.types = {LogicalType::BOOLEAN};
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -1,9 +1,13 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/standard_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 
 namespace duckdb {
 
@@ -43,10 +47,31 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->schema->name;
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY:
-		// attaching and detaching is read-only
-		stmt.info->catalog = SYSTEM_CATALOG;
-		break;
+	case CatalogType::DATABASE_ENTRY: {
+		auto &base = (DropInfo &)*stmt.info;
+		string database_name = base.name;
+
+		auto &config = DBConfig::GetConfig(context);
+		// for now assume only one storage extension provides the custom drop_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->drop_database != nullptr) {
+				continue;
+			}
+			auto &storage_extension = extension_entry.second;
+			auto drop_database_function_ref =
+			    storage_extension->drop_database(storage_extension->storage_info.get(), context, database_name);
+			if (drop_database_function_ref) {
+				auto bound_drop_database_func = Bind(*drop_database_function_ref);
+				result.plan = CreatePlan(*bound_drop_database_func);
+				result.names = {"Success"};
+				result.types = {LogicalType::BOOLEAN};
+				properties.allow_stream_result = false;
+				properties.return_type = StatementReturnType::NOTHING;
+				return result;
+			}
+		}
+		throw BinderException("Drop is not supported for this database!");
+	}
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -301,7 +301,28 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		insert.on_conflict_condition = std::move(condition);
 	}
 
-	auto projection_index = insert.children[0]->GetTableIndex()[0];
+	auto bindings = insert.children[0]->GetColumnBindings();
+	idx_t projection_index = DConstants::INVALID_INDEX;
+	std::vector<unique_ptr<LogicalOperator>> *insert_child_operators;
+	insert_child_operators = &insert.children;
+	while (projection_index == DConstants::INVALID_INDEX) {
+		if (insert_child_operators->empty()) {
+			// No further children to visit
+			break;
+		}
+		D_ASSERT(insert_child_operators->size() >= 1);
+		auto &current_child = (*insert_child_operators)[0];
+		auto table_indices = current_child->GetTableIndex();
+		if (table_indices.empty()) {
+			// This operator does not have a table index to refer to, we have to visit its children
+			insert_child_operators = &current_child->children;
+			continue;
+		}
+		projection_index = table_indices[0];
+	}
+	if (projection_index == DConstants::INVALID_INDEX) {
+		throw InternalException("Could not locate a table_index from the children of the insert");
+	}
 
 	string unused;
 	auto original_binding = bind_context.GetBinding(table_alias, unused);

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -128,6 +128,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	{
 		LateralBinder binder(left_binder, context);
 		result->right = right_binder.Bind(*ref.right);
+		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
+
 		result->lateral = binder.HasCorrelatedColumns();
 		if (result->lateral) {
 			// lateral join: can only be an INNER or LEFT join
@@ -135,7 +137,6 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 				throw BinderException("The combining JOIN type must be INNER or LEFT for a LATERAL reference");
 			}
 		}
-		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
 	}
 
 	vector<unique_ptr<ParsedExpression>> extra_conditions;

package/src/duckdb/src/planner/binder.cpp

@@ -90,6 +90,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind((LogicalPlanStatement &)statement);
 	case StatementType::ATTACH_STATEMENT:
 		return Bind((AttachStatement &)statement);
+	case StatementType::DETACH_STATEMENT:
+		return Bind((DetachStatement &)statement);
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));

package/src/duckdb/src/planner/expression_binder/index_binder.cpp

@@ -1,8 +1,14 @@
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/column_binding.hpp"
+
 namespace duckdb {
 
-IndexBinder::IndexBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
+IndexBinder::IndexBinder(Binder &binder, ClientContext &context, TableCatalogEntry *table, CreateIndexInfo *info)
+    : ExpressionBinder(binder, context), table(table), info(info) {
 }
 
 BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
@@ -12,6 +18,31 @@ BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 		return BindResult("window functions are not allowed in index expressions");
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in index expressions");
+	case ExpressionClass::COLUMN_REF: {
+		if (table) {
+			// WAL replay
+			// we assume that the parsed expressions have qualified column names
+			// and that the columns exist in the table
+			auto &col_ref = (ColumnRefExpression &)expr;
+			auto col_idx = table->GetColumnIndex(col_ref.column_names.back());
+			auto col_type = table->GetColumn(col_idx).GetType();
+
+			// find the col_idx in the index.column_ids
+			auto col_id_idx = DConstants::INVALID_INDEX;
+			for (idx_t i = 0; i < info->column_ids.size(); i++) {
+				if (col_idx.index == info->column_ids[i]) {
+					col_id_idx = i;
+				}
+			}
+
+			if (col_id_idx == DConstants::INVALID_INDEX) {
+				throw InternalException("failed to replay CREATE INDEX statement - column id not found");
+			}
+			return BindResult(
+			    make_unique<BoundColumnRefExpression>(col_ref.alias, col_type, ColumnBinding(0, col_id_idx)));
+		}
+		return ExpressionBinder::BindExpression(expr_ptr, depth);
+	}
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -39,14 +39,30 @@ BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr,
 }
 
 vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &binder) {
+
+	if (correlated_columns.empty()) {
+		return binder.correlated_columns;
+	}
+
+	// clear outer
+	correlated_columns.clear();
 	auto all_correlated_columns = binder.correlated_columns;
-	for (auto &correlated : correlated_columns) {
-		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), correlated);
-		if (entry == binder.correlated_columns.end()) {
-			throw InternalException("Lateral Binder: could not find correlated column in binder");
+
+	// remove outer from inner
+	for (auto &corr_column : correlated_columns) {
+		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), corr_column);
+		if (entry != binder.correlated_columns.end()) {
+			binder.correlated_columns.erase(entry);
 		}
-		binder.correlated_columns.erase(entry);
 	}
+
+	// add inner to outer
+	for (auto &corr_column : binder.correlated_columns) {
+		correlated_columns.push_back(corr_column);
+	}
+
+	// clear inner
+	binder.correlated_columns.clear();
 	return all_correlated_columns;
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -57,6 +57,7 @@ void LogicalOperator::ResolveOperatorTypes() {
 
 vector<ColumnBinding> LogicalOperator::GenerateColumnBindings(idx_t table_idx, idx_t column_count) {
 	vector<ColumnBinding> result;
+	result.reserve(column_count);
 	for (idx_t i = 0; i < column_count; i++) {
 		result.emplace_back(table_idx, i);
 	}
@@ -84,6 +85,7 @@ vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &
 		vector<ColumnBinding> result_bindings;
 		result_bindings.reserve(projection_map.size());
 		for (auto index : projection_map) {
+			D_ASSERT(index < bindings.size());
 			result_bindings.push_back(bindings[index]);
 		}
 		return result_bindings;
@@ -338,6 +340,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_DROP:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_DETACH:
+		throw SerializationException("Logical Detach does not support serialization");
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		result = LogicalExtensionOperator::Deserialize(state, reader);
 		break;

package/src/duckdb/src/planner/planner.cpp

@@ -133,6 +133,7 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::EXECUTE_STATEMENT:
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 	case StatementType::ATTACH_STATEMENT:
+	case StatementType::DETACH_STATEMENT:
 		CreatePlan(*statement);
 		break;
 	default:

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -447,8 +447,8 @@ public:
 
 		static void ReserveSpace(BitpackingCompressState<T> *state, idx_t data_bytes) {
 			idx_t meta_bytes = sizeof(bitpacking_metadata_encoded_t);
-			state->FlushAndCreateSegmentIfFull(data_bytes + meta_bytes);
-			D_ASSERT(data_bytes + meta_bytes <= state->RemainingSize());
+			state->FlushAndCreateSegmentIfFull(data_bytes, meta_bytes);
+			D_ASSERT(state->CanStore(data_bytes, meta_bytes));
 		}
 
 		static void UpdateStats(BitpackingCompressState<T> *state, idx_t count) {
@@ -461,9 +461,12 @@ public:
 		}
 	};
 
-	// Space remaining between the metadata_ptr growing down and data ptr growing up
-	idx_t RemainingSize() {
-		return metadata_ptr - data_ptr;
+	bool CanStore(idx_t data_bytes, idx_t meta_bytes) {
+		auto required_data_bytes = AlignValue<idx_t>((data_ptr + data_bytes) - data_ptr);
+		auto required_meta_bytes = Storage::BLOCK_SIZE - (metadata_ptr - data_ptr) + meta_bytes;
+
+		return required_data_bytes + required_meta_bytes <=
+		       Storage::BLOCK_SIZE - BitpackingPrimitives::BITPACKING_HEADER_SIZE;
 	}
 
 	void CreateEmptySegment(idx_t row_start) {
@@ -489,8 +492,8 @@ public:
 		}
 	}
 
-	void FlushAndCreateSegmentIfFull(idx_t required_space) {
-		if (RemainingSize() < required_space) {
+	void FlushAndCreateSegmentIfFull(idx_t required_data_bytes, idx_t required_meta_bytes) {
+		if (!CanStore(required_data_bytes, required_meta_bytes)) {
 			auto row_start = current_segment->start + current_segment->count;
 			FlushSegment();
 			CreateEmptySegment(row_start);
@@ -505,6 +508,12 @@ public:
 		idx_t metadata_offset = AlignValue(data_ptr - base_ptr);
 		idx_t metadata_size = base_ptr + Storage::BLOCK_SIZE - metadata_ptr;
 		idx_t total_segment_size = metadata_offset + metadata_size;
+
+		// Asserting things are still sane here
+		if (!CanStore(0, 0)) {
+			throw InternalException("Error in bitpacking size calculation");
+		}
+
 		memmove(base_ptr + metadata_offset, metadata_ptr, metadata_size);
 
 		// Store the offset of the metadata of the first group (which is at the highest address).

package/src/duckdb/src/storage/data_table.cpp

@@ -1144,15 +1144,78 @@ void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, V
 }
 
 //===--------------------------------------------------------------------===//
-// Create Index Scan
+// Index Scan
 //===--------------------------------------------------------------------===//
-void DataTable::InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids) {
+void DataTable::InitializeWALCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids) {
 	// we grab the append lock to make sure nothing is appended until AFTER we finish the index scan
 	state.append_lock = std::unique_lock<mutex>(append_lock);
-	row_groups->InitializeCreateIndexScan(state);
 	InitializeScan(state, column_ids);
 }
 
+void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
+                            const vector<unique_ptr<Expression>> &expressions) {
+
+	// if the data table is empty
+	if (row_groups->IsEmpty()) {
+		info->indexes.AddIndex(std::move(index));
+		return;
+	}
+
+	auto &allocator = Allocator::Get(db);
+
+	DataChunk result;
+	result.Initialize(allocator, index->logical_types);
+
+	DataChunk intermediate;
+	vector<LogicalType> intermediate_types;
+	auto column_ids = index->column_ids;
+	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
+	for (auto &id : index->column_ids) {
+		auto &col = column_definitions[id];
+		intermediate_types.push_back(col.Type());
+	}
+	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
+	intermediate.Initialize(allocator, intermediate_types);
+
+	// initialize an index scan
+	CreateIndexScanState state;
+	InitializeWALCreateIndexScan(state, column_ids);
+
+	if (!is_root) {
+		throw InternalException("Error during WAL replay. Cannot add an index to a table that has been altered.");
+	}
+
+	// now start incrementally building the index
+	{
+		IndexLock lock;
+		index->InitializeLock(lock);
+
+		while (true) {
+			intermediate.Reset();
+			result.Reset();
+			// scan a new chunk from the table to index
+			CreateIndexScan(state, intermediate, TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
+			if (intermediate.size() == 0) {
+				// finished scanning for index creation
+				// release all locks
+				break;
+			}
+			// resolve the expressions for this chunk
+			index->ExecuteExpressions(intermediate, result);
+
+			// insert into the index
+			if (!index->Insert(lock, result, intermediate.data[intermediate.ColumnCount() - 1])) {
+				throw InternalException("Error during WAL replay. Can't create unique index, table contains "
+				                        "duplicate data on indexed column(s).");
+			}
+		}
+	}
+	info->indexes.AddIndex(std::move(index));
+}
+
+//===--------------------------------------------------------------------===//
+// Statistics
+//===--------------------------------------------------------------------===//
 unique_ptr<BaseStatistics> DataTable::GetStatistics(ClientContext &context, column_t column_id) {
 	if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
 		return nullptr;

package/src/duckdb/src/storage/index.cpp

@@ -86,7 +86,7 @@ bool Index::IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const {
 	return false;
 }
 
-BlockPointer Index::Serialize(duckdb::MetaBlockWriter &writer) {
+BlockPointer Index::Serialize(MetaBlockWriter &writer) {
 	throw NotImplementedException("The implementation of this index serialization does not exist.");
 }
 

package/src/duckdb/src/storage/local_storage.cpp

@@ -127,7 +127,7 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 				unbound_expressions.push_back(expr->Copy());
 			}
 			indexes.AddIndex(make_unique<ART>(art.column_ids, art.table_io_manager, std::move(unbound_expressions),
-			                                  art.constraint_type, art.db, false));
+			                                  art.constraint_type, art.db, true));
 		}
 		return false;
 	});

package/src/duckdb/src/storage/storage_info.cpp

@@ -9,7 +9,8 @@ struct StorageVersionInfo {
 	idx_t storage_version;
 };
 
-static StorageVersionInfo storage_version_info[] = {{"v0.6.0 or v0.6.1", 39},
+static StorageVersionInfo storage_version_info[] = {{"v0.7.0", 43},
+                                                    {"v0.6.0 or v0.6.1", 39},
                                                     {"v0.5.0 or v0.5.1", 38},
                                                     {"v0.3.3, v0.3.4 or v0.4.0", 33},
                                                     {"v0.3.2", 31},

package/src/duckdb/src/storage/table/column_data.cpp

@@ -27,8 +27,10 @@ ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t c
 
 ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
     : block_manager(other.block_manager), info(other.info), column_index(other.column_index), start(start),
-      type(std::move(other.type)), parent(parent), updates(std::move(other.updates)),
-      version(parent ? parent->version + 1 : 0) {
+      type(std::move(other.type)), parent(parent), version(parent ? parent->version + 1 : 0) {
+	if (other.updates) {
+		updates = make_unique<UpdateSegment>(*other.updates, *this);
+	}
 	idx_t offset = 0;
 	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
 		auto &other = (ColumnSegment &)*segment;

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -36,6 +36,21 @@ UpdateSegment::UpdateSegment(ColumnData &column_data)
 	this->statistics_update_function = GetStatisticsUpdateFunction(physical_type);
 }
 
+UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
+    : column_data(owner), root(std::move(other.root)), stats(std::move(other.stats)), type_size(other.type_size) {
+
+	this->heap.Move(other.heap);
+
+	initialize_update_function = other.initialize_update_function;
+	merge_update_function = other.merge_update_function;
+	fetch_update_function = other.fetch_update_function;
+	fetch_committed_function = other.fetch_committed_function;
+	fetch_committed_range = other.fetch_committed_range;
+	fetch_row_function = other.fetch_row_function;
+	rollback_update_function = other.rollback_update_function;
+	statistics_update_function = other.statistics_update_function;
+}
+
 UpdateSegment::~UpdateSegment() {
 }
 

package/src/duckdb/src/storage/table_index_list.cpp

@@ -60,8 +60,7 @@ void TableIndexList::VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, Data
 		throw InternalException("Internal Foreign Key error: could not find index to verify...");
 	}
 	conflict_manager.SetIndexCount(1);
-
-	index->LookupValues(chunk, conflict_manager);
+	index->CheckConstraintsForChunk(chunk, conflict_manager);
 }
 
 vector<column_t> TableIndexList::GetRequiredColumns() {