duckdb 1.1.2-dev4.0 → 1.1.2-dev6.0

package/src/duckdb/src/parser/transform/helpers/transform_typename.cpp

@@ -71,12 +71,7 @@ vector<Value> Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName
 	return type_mods;
 }
 
-LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) {
-	if (type_name.type != duckdb_libpgquery::T_PGTypeName) {
-		throw ParserException("Expected a type");
-	}
-	auto stack_checker = StackCheck();
-
+LogicalType Transformer::TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &type_name) {
 	if (type_name.names->length > 1) {
 		// qualified typename
 		vector<string> names;
@@ -85,24 +80,27 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		}
 		vector<Value> type_mods = TransformTypeModifiers(type_name);
 		switch (type_name.names->length) {
-		case 2:
+		case 2: {
 			return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]), std::move(type_mods));
-		case 3:
+		}
+		case 3: {
 			return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]),
 			                         std::move(type_mods));
+		}
 		default:
 			throw ParserException(
 			    "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]");
 		}
 	}
+
 	auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
 	// transform it to the SQL type
 	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
 
-	LogicalType result_type;
 	if (base_type == LogicalTypeId::LIST) {
 		throw ParserException("LIST is not valid as a stand-alone type");
-	} else if (base_type == LogicalTypeId::ENUM) {
+	}
+	if (base_type == LogicalTypeId::ENUM) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Enum needs a set of entries");
 		}
@@ -118,7 +116,8 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str);
 		}
 		return LogicalType::ENUM(enum_vector, NumericCast<idx_t>(type_name.typmods->length));
-	} else if (base_type == LogicalTypeId::STRUCT) {
+	}
+	if (base_type == LogicalTypeId::STRUCT) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");
 		}
@@ -148,9 +147,9 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			children.push_back(make_pair(entry_name, entry_type));
 		}
 		D_ASSERT(!children.empty());
-		result_type = LogicalType::STRUCT(children);
-
-	} else if (base_type == LogicalTypeId::MAP) {
+		return LogicalType::STRUCT(children);
+	}
+	if (base_type == LogicalTypeId::MAP) {
 		if (!type_name.typmods || type_name.typmods->length != 2) {
 			throw ParserException("Map type needs exactly two entries, key and value type");
 		}
@@ -159,8 +158,9 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		auto value_type =
 		    TransformTypeName(*PGPointerCast<duckdb_libpgquery::PGTypeName>(type_name.typmods->tail->data.ptr_value));
 
-		result_type = LogicalType::MAP(std::move(key_type), std::move(value_type));
-	} else if (base_type == LogicalTypeId::UNION) {
+		return LogicalType::MAP(std::move(key_type), std::move(value_type));
+	}
+	if (base_type == LogicalTypeId::UNION) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Union type needs at least one member");
 		}
@@ -195,81 +195,83 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			children.push_back(make_pair(entry_name, entry_type));
 		}
 		D_ASSERT(!children.empty());
-		result_type = LogicalType::UNION(std::move(children));
-	} else if (base_type == LogicalTypeId::USER) {
+		return LogicalType::UNION(std::move(children));
+	}
+	if (base_type == LogicalTypeId::USER) {
 		string user_type_name {name};
 		vector<Value> type_mods = TransformTypeModifiers(type_name);
-		result_type = LogicalType::USER(user_type_name, type_mods);
-	} else {
-		SizeModifiers modifiers = GetSizeModifiers(type_name, base_type);
-		switch (base_type) {
-		case LogicalTypeId::VARCHAR:
-			if (modifiers.count > 1) {
-				throw ParserException("VARCHAR only supports a single modifier");
-			}
-			// FIXME: create CHECK constraint based on varchar width
-			modifiers.width = 0;
-			result_type = LogicalType::VARCHAR;
-			break;
-		case LogicalTypeId::DECIMAL:
-			if (modifiers.count > 2) {
-				throw ParserException("DECIMAL only supports a maximum of two modifiers");
-			}
-			if (modifiers.count == 1) {
-				// only width is provided: set scale to 0
-				modifiers.scale = 0;
-			}
-			if (modifiers.width <= 0 || modifiers.width > Decimal::MAX_WIDTH_DECIMAL) {
-				throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL);
-			}
-			if (modifiers.scale > modifiers.width) {
-				throw ParserException("Scale cannot be bigger than width");
-			}
-			result_type =
-			    LogicalType::DECIMAL(NumericCast<uint8_t>(modifiers.width), NumericCast<uint8_t>(modifiers.scale));
-			break;
-		case LogicalTypeId::INTERVAL:
-			if (modifiers.count > 1) {
-				throw ParserException("INTERVAL only supports a single modifier");
-			}
-			modifiers.width = 0;
-			result_type = LogicalType::INTERVAL;
-			break;
-		case LogicalTypeId::BIT:
-			if (!modifiers.width && type_name.typmods) {
-				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
-			}
-			result_type = LogicalType(base_type);
-			break;
-		case LogicalTypeId::TIMESTAMP:
-			if (modifiers.count == 0) {
-				result_type = LogicalType::TIMESTAMP;
-			} else {
-				if (modifiers.count > 1) {
-					throw ParserException("TIMESTAMP only supports a single modifier");
-				}
-				if (modifiers.width > 10) {
-					throw ParserException("TIMESTAMP only supports until nano-second precision (9)");
-				}
-				if (modifiers.width == 0) {
-					result_type = LogicalType::TIMESTAMP_S;
-				} else if (modifiers.width <= 3) {
-					result_type = LogicalType::TIMESTAMP_MS;
-				} else if (modifiers.width <= 6) {
-					result_type = LogicalType::TIMESTAMP;
-				} else {
-					result_type = LogicalType::TIMESTAMP_NS;
-				}
-			}
-			break;
-		default:
-			if (modifiers.count > 0) {
-				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
-			}
-			result_type = LogicalType(base_type);
-			break;
+		return LogicalType::USER(user_type_name, type_mods);
+	}
+
+	SizeModifiers modifiers = GetSizeModifiers(type_name, base_type);
+	switch (base_type) {
+	case LogicalTypeId::VARCHAR:
+		if (modifiers.count > 1) {
+			throw ParserException("VARCHAR only supports a single modifier");
+		}
+		// FIXME: create CHECK constraint based on varchar width
+		modifiers.width = 0;
+		return LogicalType::VARCHAR;
+	case LogicalTypeId::DECIMAL:
+		if (modifiers.count > 2) {
+			throw ParserException("DECIMAL only supports a maximum of two modifiers");
+		}
+		if (modifiers.count == 1) {
+			// only width is provided: set scale to 0
+			modifiers.scale = 0;
+		}
+		if (modifiers.width <= 0 || modifiers.width > Decimal::MAX_WIDTH_DECIMAL) {
+			throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL);
+		}
+		if (modifiers.scale > modifiers.width) {
+			throw ParserException("Scale cannot be bigger than width");
+		}
+		return LogicalType::DECIMAL(NumericCast<uint8_t>(modifiers.width), NumericCast<uint8_t>(modifiers.scale));
+	case LogicalTypeId::INTERVAL:
+		if (modifiers.count > 1) {
+			throw ParserException("INTERVAL only supports a single modifier");
+		}
+		modifiers.width = 0;
+		return LogicalType::INTERVAL;
+	case LogicalTypeId::BIT:
+		if (!modifiers.width && type_name.typmods) {
+			throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
+		}
+		return LogicalType(base_type);
+	case LogicalTypeId::TIMESTAMP:
+		if (modifiers.count == 0) {
+			return LogicalType::TIMESTAMP;
+		}
+		if (modifiers.count > 1) {
+			throw ParserException("TIMESTAMP only supports a single modifier");
 		}
+		if (modifiers.width > 10) {
+			throw ParserException("TIMESTAMP only supports until nano-second precision (9)");
+		}
+		if (modifiers.width == 0) {
+			return LogicalType::TIMESTAMP_S;
+		}
+		if (modifiers.width <= 3) {
+			return LogicalType::TIMESTAMP_MS;
+		}
+		if (modifiers.width <= 6) {
+			return LogicalType::TIMESTAMP;
+		}
+		return LogicalType::TIMESTAMP_NS;
+	default:
+		if (modifiers.count > 0) {
+			throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
+		}
+		return LogicalType(base_type);
+	}
+}
+
+LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) {
+	if (type_name.type != duckdb_libpgquery::T_PGTypeName) {
+		throw ParserException("Expected a type");
 	}
+	auto stack_checker = StackCheck();
+	auto result_type = TransformTypeNameInternal(type_name);
 	if (type_name.arrayBounds) {
 		// array bounds: turn the type into a list
 		idx_t extra_stack = 0;

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -15,6 +15,7 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/common/types/uuid.hpp"
 
 namespace duckdb {
 
@@ -168,7 +169,6 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
 	bool is_pivot = !pivot->unpivots;
 	auto columns = TransformPivotList(*pivot->columns, is_pivot);
-	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
 		if (!col.pivot_enum.empty() || !col.entries.empty()) {
@@ -177,7 +177,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		if (col.pivot_expressions.size() != 1) {
 			throw InternalException("PIVOT statement with multiple names in pivot entry!?");
 		}
-		auto enum_name = "__pivot_enum_" + std::to_string(pivot_idx) + "_" + std::to_string(c);
+		auto enum_name = "__pivot_enum_" + UUID::ToString(UUID::GenerateRandomUUID());
 
 		auto new_select = make_uniq<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);

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

@@ -1,4 +1,5 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
 #include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
@@ -26,12 +27,8 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi
 
 		if (!error_message.empty()) {
 			// Possibly a JSON function, replace both LHS and RHS.
-			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr<ParsedExpression> &child) {
-				ReplaceMacroParameters(child, lambda_params);
-			});
-			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
-				ReplaceMacroParameters(child, lambda_params);
-			});
+			ReplaceMacroParameters(lambda_expr.lhs, lambda_params);
+			ReplaceMacroParameters(lambda_expr.expr, lambda_params);
 			continue;
 		}
 
@@ -43,9 +40,7 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi
 		}
 
 		// Only replace in the RHS of the expression.
-		ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
-			ReplaceMacroParameters(child, lambda_params);
-		});
+		ReplaceMacroParameters(lambda_expr.expr, lambda_params);
 
 		lambda_params.pop_back();
 	}

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

@@ -140,6 +140,7 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 					    make_uniq<ConstantExpression>(Value::INTEGER(UnsafeNumericCast<int32_t>(1 + i))));
 				}
 			}
+			order_binder.SetQueryComponent("DISTINCT ON");
 			for (auto &distinct_on_target : distinct.distinct_on_targets) {
 				auto expr = BindOrderExpression(order_binder, std::move(distinct_on_target));
 				if (!expr) {
@@ -147,10 +148,13 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 				}
 				bound_distinct->target_distincts.push_back(std::move(expr));
 			}
+			order_binder.SetQueryComponent();
+
 			bound_modifier = std::move(bound_distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
+
 			auto &order = mod->Cast<OrderModifier>();
 			auto bound_order = make_uniq<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);

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

@@ -52,7 +52,7 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 					for (auto &type : new_column_types) {
 						logical_get.returned_types[type.first] = type.second;
 					}
-					return op;
+					return std::move(op->children[0]);
 				}
 			}
 		}
@@ -132,7 +132,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	                                node.right_binder->has_unplanned_dependent_joins;
 
 	// create actual logical ops for setops
-	LogicalOperatorType logical_type;
+	LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_INVALID;
 	switch (node.setop_type) {
 	case SetOperationType::UNION:
 	case SetOperationType::UNION_BY_NAME:

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

@@ -228,7 +228,10 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 
 		auto bound_expression = expr_binder.Bind(expression);
 		D_ASSERT(bound_expression);
-		D_ASSERT(!bound_expression->HasSubquery());
+		if (bound_expression->HasSubquery()) {
+			throw BinderException("Failed to bind generated column '%s' because the expression contains a subquery",
+			                      col.Name());
+		}
 		if (col.Type().id() == LogicalTypeId::ANY) {
 			// Do this before changing the type, so we know it's the first time the type is set
 			col.ChangeGeneratedExpressionType(bound_expression->return_type);

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

@@ -192,7 +192,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// now generate the COPY statements for each of the tables
 	auto &fs = FileSystem::GetFileSystem(context);
 
-	BoundExportData exported_tables;
+	auto exported_tables = make_uniq<BoundExportData>();
 
 	unordered_set<string> table_name_index;
 	vector<unique_ptr<LogicalOperator>> export_nodes;
@@ -245,7 +245,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		exported_data.file_path = info->file_path;
 
 		ExportedTableInfo table_info(table, std::move(exported_data), not_null_columns);
-		exported_tables.data.push_back(table_info);
+		exported_tables->data.push_back(table_info);
 		id++;
 
 		// generate the copy statement and bind it
@@ -270,7 +270,8 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	stmt.info->catalog = catalog;
 	// create the export node
-	auto export_node = make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), exported_tables);
+	auto export_node =
+	    make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), std::move(exported_tables));
 
 	if (child_operator) {
 		export_node->children.push_back(std::move(child_operator));

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

@@ -61,8 +61,10 @@ optional_idx OrderBinder::TryGetProjectionReference(ParsedExpression &expr) cons
 			// this is disabled by default (matching Postgres) - but we can control this with a setting
 			auto &config = ClientConfig::GetConfig(binders[0].get().context);
 			if (!config.order_by_non_integer_literal) {
-				throw BinderException(expr, "ORDER BY non-integer literal has no effect.\n* SET "
-				                            "order_by_non_integer_literal=true to allow this behavior.");
+				throw BinderException(expr,
+				                      "%s non-integer literal has no effect.\n* SET "
+				                      "order_by_non_integer_literal=true to allow this behavior.",
+				                      query_component);
 			}
 			break;
 		}
@@ -94,6 +96,14 @@ optional_idx OrderBinder::TryGetProjectionReference(ParsedExpression &expr) cons
 	return optional_idx();
 }
 
+void OrderBinder::SetQueryComponent(string component) {
+	if (component.empty()) {
+		query_component = "ORDER BY";
+	} else {
+		query_component = std::move(component);
+	}
+}
+
 unique_ptr<Expression> OrderBinder::BindConstant(ParsedExpression &expr) {
 	auto index = TryGetProjectionReference(expr);
 	if (!index.IsValid()) {
@@ -130,7 +140,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		break;
 	}
 	case ExpressionClass::PARAMETER: {
-		throw ParameterNotAllowedException("Parameter not supported in ORDER BY clause");
+		throw ParameterNotAllowedException("Parameter not supported in %s clause", query_component);
 	}
 	case ExpressionClass::COLLATE: {
 		auto &collation = expr->Cast<CollateExpression>();

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

@@ -169,7 +169,7 @@ static bool CombineMissingColumns(ErrorData &current, ErrorData new_error) {
 	// get query location
 	QueryErrorContext context;
 	current_entry = current_info.find("position");
-	new_entry = current_info.find("position");
+	new_entry = new_info.find("position");
 	uint64_t position;
 	if (current_entry != current_info.end() &&
 	    TryCast::Operation<string_t, uint64_t>(current_entry->second, position)) {

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

@@ -0,0 +1,28 @@
+#include "duckdb/planner/operator/logical_export.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
+
+namespace duckdb {
+
+LogicalExport::LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info,
+                             unique_ptr<BoundExportData> exported_tables)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), copy_info(std::move(copy_info)),
+      function(std::move(function)), exported_tables(std::move(exported_tables)) {
+}
+
+LogicalExport::LogicalExport(ClientContext &context, unique_ptr<ParseInfo> copy_info_p,
+                             unique_ptr<ParseInfo> exported_tables_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT),
+      copy_info(unique_ptr_cast<ParseInfo, CopyInfo>(std::move(copy_info_p))),
+      function(GetCopyFunction(context, *copy_info)),
+      exported_tables(unique_ptr_cast<ParseInfo, BoundExportData>(std::move(exported_tables_p))) {
+}
+
+CopyFunction LogicalExport::GetCopyFunction(ClientContext &context, CopyInfo &info) {
+	auto &copy_entry =
+	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.format);
+	return copy_entry.function;
+}
+
+} // namespace duckdb

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

@@ -202,8 +202,7 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	// fetch the type of the column
 	LogicalType col_type;
 	if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-		// row id: BIGINT type
-		col_type = LogicalType::BIGINT;
+		col_type = LogicalType::ROW_TYPE;
 	} else {
 		// normal column: fetch type from base column
 		col_type = types[column_index];

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

@@ -26,6 +26,10 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	}
 }
 
+string TableFilter::DebugToString() {
+	return ToString("c0");
+}
+
 void DynamicTableFilterSet::ClearFilters(const PhysicalOperator &op) {
 	lock_guard<mutex> l(lock);
 	filters.erase(op);
@@ -57,7 +61,7 @@ DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
 	auto result = make_uniq<TableFilterSet>();
 	if (existing_filters) {
 		for (auto &entry : existing_filters->filters) {
-			result->filters[entry.first] = entry.second->Copy();
+			result->PushFilter(entry.first, entry.second->Copy());
 		}
 	}
 	for (auto &entry : filters) {
@@ -66,7 +70,7 @@ DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
 				// skip row id filters
 				continue;
 			}
-			result->filters[filter.first] = filter.second->Copy();
+			result->PushFilter(filter.first, filter.second->Copy());
 		}
 	}
 	if (result->filters.empty()) {

package/src/duckdb/src/storage/buffer/buffer_pool.cpp

@@ -342,7 +342,8 @@ idx_t BufferPool::PurgeAgedBlocksInternal(EvictionQueue &queue, uint32_t max_age
 		bool is_fresh = handle->lru_timestamp_msec >= limit && handle->lru_timestamp_msec <= now;
 		purged_bytes += handle->GetMemoryUsage();
 		handle->Unload();
-		return is_fresh;
+		// Return false to stop iterating if the current block is_fresh
+		return !is_fresh;
 	});
 	return purged_bytes;
 }

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

@@ -445,7 +445,7 @@ void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &d
 	auto &table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table)->Cast<DuckTableEntry>();
 
 	// we also need to make sure the index type is loaded
-	// backwards compatability:
+	// backwards compatibility:
 	// if the index type is not specified, we default to ART
 	if (info.index_type.empty()) {
 		info.index_type = ART::TYPE_NAME;

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

@@ -264,10 +264,14 @@ public:
 				                  delta_required_bitwidth, static_cast<T>(minimum_delta), delta_offset,
 				                  compression_buffer, compression_buffer_idx, data_ptr);
 
+				// FOR (frame of reference).
+				total_size += sizeof(T);
+				// Aligned bitpacking width.
+				total_size += AlignValue(sizeof(bitpacking_width_t));
+				// Delta offset.
+				total_size += sizeof(T);
+				// Compressed data size.
 				total_size += BitpackingPrimitives::GetRequiredSize(compression_buffer_idx, delta_required_bitwidth);
-				total_size += sizeof(T);                              // FOR value
-				total_size += sizeof(T);                              // Delta offset value
-				total_size += AlignValue(sizeof(bitpacking_width_t)); // FOR value
 
 				return true;
 			}

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

@@ -127,7 +127,7 @@ struct DictionaryCompressionStorage {
 // contains the offsets into the dictionary which are also used to determine the string lengths. Each value in the
 // dictionary gets a single unique index in the index buffer. Secondly, the selection buffer maps the tuples to an index
 // in the index buffer. The selection buffer is compressed with bitpacking. Finally, the dictionary contains simply all
-// the unique strings without lenghts or null termination as we can deduce the lengths from the index buffer. The
+// the unique strings without lengths or null termination as we can deduce the lengths from the index buffer. The
 // addition of the selection buffer is done for two reasons: firstly, to allow the scan to emit dictionary vectors by
 // scanning the whole dictionary at once and then scanning the selection buffer for each emitted vector. Secondly, it
 // allows for efficient bitpacking compression as the selection values should remain relatively small.

package/src/duckdb/src/storage/metadata/metadata_manager.cpp

@@ -50,7 +50,7 @@ MetadataHandle MetadataManager::AllocateHandle() {
 	return Pin(pointer);
 }
 
-MetadataHandle MetadataManager::Pin(MetadataPointer pointer) {
+MetadataHandle MetadataManager::Pin(const MetadataPointer &pointer) {
 	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
 	auto &block = blocks[UnsafeNumericCast<int64_t>(pointer.block_index)];
 
@@ -111,7 +111,7 @@ void MetadataManager::AddAndRegisterBlock(MetadataBlock block) {
 	AddBlock(std::move(block), true);
 }
 
-MetaBlockPointer MetadataManager::GetDiskPointer(MetadataPointer pointer, uint32_t offset) {
+MetaBlockPointer MetadataManager::GetDiskPointer(const MetadataPointer &pointer, uint32_t offset) {
 	idx_t block_pointer = idx_t(pointer.block_index);
 	block_pointer |= idx_t(pointer.index) << 56ULL;
 	return MetaBlockPointer(block_pointer, offset);

package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp

@@ -106,6 +106,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
 		result = LogicalExplain::Deserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_EXPORT:
+		result = LogicalExport::Deserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
 		result = LogicalExpressionGet::Deserialize(deserializer);
 		break;
@@ -442,6 +445,19 @@ unique_ptr<LogicalOperator> LogicalExplain::Deserialize(Deserializer &deserializ
 	return std::move(result);
 }
 
+void LogicalExport::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
+	serializer.WritePropertyWithDefault<unique_ptr<CopyInfo>>(200, "copy_info", copy_info);
+	serializer.WritePropertyWithDefault<unique_ptr<BoundExportData>>(201, "exported_tables", exported_tables);
+}
+
+unique_ptr<LogicalOperator> LogicalExport::Deserialize(Deserializer &deserializer) {
+	auto copy_info = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(200, "copy_info");
+	auto exported_tables = deserializer.ReadPropertyWithDefault<unique_ptr<ParseInfo>>(201, "exported_tables");
+	auto result = duckdb::unique_ptr<LogicalExport>(new LogicalExport(deserializer.Get<ClientContext &>(), std::move(copy_info), std::move(exported_tables)));
+	return std::move(result);
+}
+
 void LogicalExpressionGet::Serialize(Serializer &serializer) const {
 	LogicalOperator::Serialize(serializer);
 	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);

package/src/duckdb/src/storage/serialization/serialize_nodes.cpp

@@ -32,6 +32,7 @@
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/common/types/interval.hpp"
+#include "duckdb/parser/parsed_data/exported_table_data.hpp"
 
 namespace duckdb {
 
@@ -343,6 +344,34 @@ CommonTableExpressionMap CommonTableExpressionMap::Deserialize(Deserializer &des
 	return result;
 }
 
+void ExportedTableData::Serialize(Serializer &serializer) const {
+	serializer.WritePropertyWithDefault<string>(1, "table_name", table_name);
+	serializer.WritePropertyWithDefault<string>(2, "schema_name", schema_name);
+	serializer.WritePropertyWithDefault<string>(3, "database_name", database_name);
+	serializer.WritePropertyWithDefault<string>(4, "file_path", file_path);
+	serializer.WritePropertyWithDefault<vector<string>>(5, "not_null_columns", not_null_columns);
+}
+
+ExportedTableData ExportedTableData::Deserialize(Deserializer &deserializer) {
+	ExportedTableData result;
+	deserializer.ReadPropertyWithDefault<string>(1, "table_name", result.table_name);
+	deserializer.ReadPropertyWithDefault<string>(2, "schema_name", result.schema_name);
+	deserializer.ReadPropertyWithDefault<string>(3, "database_name", result.database_name);
+	deserializer.ReadPropertyWithDefault<string>(4, "file_path", result.file_path);
+	deserializer.ReadPropertyWithDefault<vector<string>>(5, "not_null_columns", result.not_null_columns);
+	return result;
+}
+
+void ExportedTableInfo::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<ExportedTableData>(1, "table_data", table_data);
+}
+
+ExportedTableInfo ExportedTableInfo::Deserialize(Deserializer &deserializer) {
+	auto table_data = deserializer.ReadProperty<ExportedTableData>(1, "table_data");
+	ExportedTableInfo result(deserializer.Get<ClientContext &>(), table_data);
+	return result;
+}
+
 void HivePartitioningIndex::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<string>(100, "value", value);
 	serializer.WritePropertyWithDefault<idx_t>(101, "index", index);