duckdb 0.7.2-dev2867.0 → 0.7.2-dev3117.0

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -46,47 +46,3 @@ string SelectStatement::ToString() const {
 }
 
 } // namespace duckdb
-
-/*
- json_serialize_sql('SELECT BLOB ''\x01\x10'';', format := CAST('t' AS BOOLEAN)){
-"error": false,
-"statements": [
-    {
-        "node": {
-            "type": "SELECT_NODE",
-            "modifiers": [],
-            "cte_map": {
-                "map": []
-            },
-            "select_list": [
-                {
-                    "class": "CONSTANT",
-                    "type": "CONSTANT",
-                    "alias": "",
-                    "value": {
-                        "type": {
-                            "id": "BLOB",
-                            "type_info": null
-                        },
-                        "is_null": false,
-                        "value": "\u0001\u0010"
-                    }
-                }
-            ],
-            "from_table": {
-                "type": "EMPTY",
-                "alias": "",
-                "sample": null
-            },
-            "where_clause": null,
-            "group_expressions": [],
-            "group_sets": [],
-            "aggregate_handling": "STANDARD_HANDLING",
-            "having": null,
-            "sample": null,
-            "qualify": null
-        }
-    }
-]
-}
- */

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -12,15 +12,15 @@ string JoinRef::ToString() const {
 	result = left->ToString() + " ";
 	switch (ref_type) {
 	case JoinRefType::REGULAR:
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::NATURAL:
 		result += "NATURAL ";
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::ASOF:
 		result += "ASOF ";
-		result += JoinTypeToString(type) + " JOIN ";
+		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::CROSS:
 		result += ", ";

package/src/duckdb/src/parser/tableref.cpp

@@ -30,7 +30,7 @@ string TableRef::BaseToString(string result, const vector<string> &column_name_a
 		result += ")";
 	}
 	if (sample) {
-		result += " TABLESAMPLE " + SampleMethodToString(sample->method);
+		result += " TABLESAMPLE " + EnumUtil::ToString(sample->method);
 		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
 		if (sample->seed >= 0) {
 			result += "REPEATABLE (" + to_string(sample->seed) + ")";

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
@@ -305,8 +305,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		auto arg_expr = children[0].get();
 		auto &order_by = order_bys->orders[0];
 		if (arg_expr->Equals(order_by.expression.get())) {
-			auto sense = make_uniq<ConstantExpression>(EnumSerializer::EnumToString(order_by.type));
-			auto nulls = make_uniq<ConstantExpression>(EnumSerializer::EnumToString(order_by.null_order));
+			auto sense = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.type));
+			auto nulls = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.null_order));
 			order_bys = nullptr;
 			auto unordered = make_uniq<FunctionExpression>(catalog, schema, lowercase_name.c_str(), std::move(children),
 			                                               std::move(filter_expr), std::move(order_bys),

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

@@ -388,4 +388,10 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 	return result;
 }
 
+bool ExpressionBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
+	// Only BaseSelectBinder will have a valid col alias map,
+	// otherwise just return false
+	return false;
+}
+
 } // namespace duckdb

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

@@ -45,7 +45,10 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 				colref = make_uniq<ColumnRefExpression>(function.schema, function.catalog);
 			}
 			auto new_colref = QualifyColumnName(*colref, error);
-			if (error.empty()) {
+			bool is_col = error.empty() ? true : false;
+			bool is_col_alias = QualifyColumnAlias(*colref);
+
+			if (is_col || is_col_alias) {
 				// we can! transform this into a function call on the column
 				// i.e. "x.lower()" becomes "lower(x)"
 				function.children.insert(function.children.begin(), std::move(colref));

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -1,8 +1,8 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -35,11 +35,25 @@ bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
 	return other.binding == binding && other.depth == depth;
 }
 
+string BoundColumnRefExpression::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return binding.ToString();
+	}
+#endif
+	return Expression::GetName();
+}
+
 string BoundColumnRefExpression::ToString() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return binding.ToString();
+	}
+#endif
 	if (!alias.empty()) {
 		return alias;
 	}
-	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "]";
+	return binding.ToString();
 }
 
 void BoundColumnRefExpression::Serialize(FieldWriter &writer) const {

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -1,9 +1,10 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 
+#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
-#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -16,6 +17,11 @@ BoundReferenceExpression::BoundReferenceExpression(LogicalType type, idx_t index
 }
 
 string BoundReferenceExpression::ToString() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return "#" + to_string(index);
+	}
+#endif
 	if (!alias.empty()) {
 		return alias;
 	}

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

@@ -143,4 +143,11 @@ BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_
 	                                                      ColumnBinding(node.group_index, group_index), depth));
 }
 
+bool BaseSelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
+	if (!colref.IsQualified()) {
+		return alias_map.find(colref.column_names[0]) != alias_map.end() ? true : false;
+	}
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_aggregate.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/common/string_util.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -87,7 +89,7 @@ unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(LogicalDeserialization
 	for (idx_t i = 0; i < grouping_sets_size; i++) {
 		grouping_sets.push_back(reader.ReadRequiredSet<idx_t>());
 	}
-	vector<vector<idx_t>> grouping_functions;
+	vector<unsafe_vector<idx_t>> grouping_functions;
 	auto grouping_functions_size = reader.ReadRequired<idx_t>();
 	for (idx_t i = 0; i < grouping_functions_size; i++) {
 		grouping_functions.push_back(reader.ReadRequiredList<idx_t>());
@@ -117,4 +119,14 @@ vector<idx_t> LogicalAggregate::GetTableIndex() const {
 	return result;
 }
 
+string LogicalAggregate::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() +
+		       StringUtil::Format(" #%llu, #%llu, #%llu", group_index, aggregate_index, groupings_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_column_data_get.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
+
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -42,4 +44,13 @@ vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalColumnDataGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_comparison_join.cpp

@@ -2,7 +2,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
-
+#include "duckdb/common/enum_util.hpp"
 namespace duckdb {
 
 LogicalComparisonJoin::LogicalComparisonJoin(JoinType join_type, LogicalOperatorType logical_type)
@@ -10,7 +10,7 @@ LogicalComparisonJoin::LogicalComparisonJoin(JoinType join_type, LogicalOperator
 }
 
 string LogicalComparisonJoin::ParamsToString() const {
-	string result = JoinTypeToString(join_type);
+	string result = EnumUtil::ToChars(join_type);
 	for (auto &condition : conditions) {
 		result += "\n";
 		auto expr =

package/src/duckdb/src/planner/operator/logical_cteref.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -22,4 +24,13 @@ vector<idx_t> LogicalCTERef::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalCTERef::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/planner/operator/logical_delete.hpp"
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 
 namespace duckdb {
@@ -51,4 +52,13 @@ void LogicalDelete::ResolveTypes() {
 	}
 }
 
+string LogicalDelete::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delim_get.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalDelimGet::Serialize(FieldWriter &writer) const {
@@ -18,4 +20,13 @@ vector<idx_t> LogicalDelimGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalDelimGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_dummy_scan.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalDummyScan::Serialize(FieldWriter &writer) const {
@@ -16,4 +18,13 @@ vector<idx_t> LogicalDummyScan::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalDummyScan::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_expression_get.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalExpressionGet::Serialize(FieldWriter &writer) const {
@@ -30,4 +32,13 @@ vector<idx_t> LogicalExpressionGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalExpressionGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 #include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/storage/data_table.hpp"
 
 namespace duckdb {
@@ -16,10 +17,6 @@ LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<Fun
       bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)) {
 }
 
-string LogicalGet::GetName() const {
-	return StringUtil::Upper(function.name);
-}
-
 optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
 	return TableScanFunction::GetTableEntry(function, bind_data.get());
 }
@@ -201,4 +198,13 @@ vector<idx_t> LogicalGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return StringUtil::Upper(function.name) + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return StringUtil::Upper(function.name);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -1,6 +1,8 @@
+#include "duckdb/planner/operator/logical_insert.hpp"
+
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
-#include "duckdb/planner/operator/logical_insert.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 
 namespace duckdb {
@@ -78,4 +80,13 @@ void LogicalInsert::ResolveTypes() {
 	}
 }
 
+string LogicalInsert::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_pivot.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_pivot.hpp"
 
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
@@ -32,4 +34,13 @@ void LogicalPivot::ResolveTypes() {
 	this->types = bound_pivot.types;
 }
 
+string LogicalPivot::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", pivot_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_projection.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -32,4 +34,13 @@ vector<idx_t> LogicalProjection::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalProjection::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_recursive_cte.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_recursive_cte.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -21,4 +23,13 @@ vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalRecursiveCTE::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_set_operation.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_set_operation.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -19,4 +21,13 @@ vector<idx_t> LogicalSetOperation::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalSetOperation::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_unnest.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_unnest.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 vector<ColumnBinding> LogicalUnnest::GetColumnBindings() {
@@ -35,4 +37,13 @@ vector<idx_t> LogicalUnnest::GetTableIndex() const {
 	return vector<idx_t> {unnest_index};
 }
 
+string LogicalUnnest::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", unnest_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_update.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -52,4 +53,13 @@ void LogicalUpdate::ResolveTypes() {
 	}
 }
 
+string LogicalUpdate::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_window.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_window.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -34,4 +36,13 @@ vector<idx_t> LogicalWindow::GetTableIndex() const {
 	return vector<idx_t> {window_index};
 }
 
+string LogicalWindow::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", window_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -37,7 +37,7 @@ namespace duckdb {
 void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables);
 
 SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager)
-    : CheckpointWriter(db), partial_block_manager(block_manager) {
+    : CheckpointWriter(db), partial_block_manager(block_manager, CheckpointType::FULL_CHECKPOINT) {
 }
 
 BlockManager &SingleFileCheckpointWriter::GetBlockManager() {

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

@@ -665,6 +665,11 @@ OptimisticDataWriter &DataTable::CreateOptimisticWriter(ClientContext &context)
 	return local_storage.CreateOptimisticWriter(*this);
 }
 
+void DataTable::FinalizeOptimisticWriter(ClientContext &context, OptimisticDataWriter &writer) {
+	auto &local_storage = LocalStorage::Get(context, db);
+	local_storage.FinalizeOptimisticWriter(*this, writer);
+}
+
 void DataTable::LocalMerge(ClientContext &context, RowGroupCollection &collection) {
 	auto &local_storage = LocalStorage::Get(context, db);
 	local_storage.LocalMerge(*this, collection);