duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

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

@@ -151,7 +151,7 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
                                         idx_t append_count, bool append_to_table) {
 	auto &table = table_ref.get();
 	if (append_to_table) {
-		table.InitializeAppend(transaction, append_state, append_count);
+		table.InitializeAppend(transaction, append_state);
 	}
 	ErrorData error;
 	if (append_to_table) {
@@ -202,6 +202,9 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 		});
 		error.Throw();
 	}
+	if (append_to_table) {
+		table.FinalizeAppend(transaction, append_state);
+	}
 }
 
 OptimisticDataWriter &LocalTableStorage::CreateOptimisticWriter() {
@@ -352,7 +355,7 @@ bool LocalStorage::NextParallelScan(ClientContext &context, DataTable &table, Pa
 
 void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable &table) {
 	state.storage = &table_manager.GetOrCreateStorage(table);
-	state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state, 0);
+	state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state);
 }
 
 void LocalStorage::Append(LocalAppendState &state, DataChunk &chunk) {

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

@@ -85,7 +85,7 @@ block_id_t MetadataManager::AllocateNewBlock() {
 	auto handle = buffer_manager.Allocate(MemoryTag::METADATA, Storage::BLOCK_SIZE, false, &new_block.block);
 	new_block.block_id = new_block_id;
 	for (idx_t i = 0; i < METADATA_BLOCK_COUNT; i++) {
-		new_block.free_blocks.push_back(METADATA_BLOCK_COUNT - i - 1);
+		new_block.free_blocks.push_back(NumericCast<uint8_t>(METADATA_BLOCK_COUNT - i - 1));
 	}
 	// zero-initialize the handle
 	memset(handle.Ptr(), 0, Storage::BLOCK_SIZE);
@@ -135,7 +135,7 @@ MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) {
 	} // LCOV_EXCL_STOP
 	MetadataPointer result;
 	result.block_index = block_id;
-	result.index = index;
+	result.index = UnsafeNumericCast<uint8_t>(index);
 	return result;
 }
 
@@ -165,7 +165,7 @@ MetaBlockPointer MetadataManager::FromBlockPointer(BlockPointer block_pointer) {
 	D_ASSERT(offset < MetadataManager::METADATA_BLOCK_SIZE);
 	MetaBlockPointer result;
 	result.block_pointer = idx_t(block_pointer.block_id) | index << 56ULL;
-	result.offset = offset;
+	result.offset = UnsafeNumericCast<uint32_t>(offset);
 	return result;
 }
 
@@ -247,7 +247,7 @@ void MetadataBlock::FreeBlocksFromInteger(idx_t free_list) {
 		auto index = i - 1;
 		idx_t mask = idx_t(1) << index;
 		if (free_list & mask) {
-			free_blocks.push_back(index);
+			free_blocks.push_back(UnsafeNumericCast<uint8_t>(index));
 		}
 	}
 }

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

@@ -47,7 +47,7 @@ void MetadataReader::ReadData(data_ptr_t buffer, idx_t read_size) {
 }
 
 MetaBlockPointer MetadataReader::GetMetaBlockPointer() {
-	return manager.GetDiskPointer(block.pointer, offset);
+	return manager.GetDiskPointer(block.pointer, UnsafeNumericCast<uint32_t>(offset));
 }
 
 void MetadataReader::ReadNextBlock() {

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

@@ -27,7 +27,7 @@ MetaBlockPointer MetadataWriter::GetMetaBlockPointer() {
 		NextBlock();
 		D_ASSERT(capacity > 0);
 	}
-	return manager.GetDiskPointer(block.pointer, offset);
+	return manager.GetDiskPointer(block.pointer, UnsafeNumericCast<uint32_t>(offset));
 }
 
 MetadataHandle MetadataWriter::NextHandle() {

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

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/metadata/metadata_manager.cpp>
+#include </Users/carlo/duckdb/src/storage/metadata/metadata_reader.cpp>
+#include </Users/carlo/duckdb/src/storage/metadata/metadata_writer.cpp>

package/src/duckdb/src/storage/partial_block_manager.cpp

@@ -139,7 +139,7 @@ void PartialBlockManager::Merge(PartialBlockManager &other) {
 		if (!e.second) {
 			throw InternalException("Empty partially filled block found");
 		}
-		auto used_space = Storage::BLOCK_SIZE - e.first;
+		auto used_space = NumericCast<uint32_t>(Storage::BLOCK_SIZE - e.first);
 		if (HasBlockAllocation(used_space)) {
 			// we can merge this block into an existing block - merge them
 			// merge blocks

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

@@ -188,6 +188,7 @@ void CreateViewInfo::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<vector<LogicalType>>(202, "types", types);
 	serializer.WritePropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", query);
 	serializer.WritePropertyWithDefault<vector<string>>(204, "names", names);
+	serializer.WritePropertyWithDefault<vector<Value>>(205, "column_comments", column_comments, vector<Value>());
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
@@ -197,6 +198,7 @@ unique_ptr<CreateInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(202, "types", result->types);
 	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", result->query);
 	deserializer.ReadPropertyWithDefault<vector<string>>(204, "names", result->names);
+	deserializer.ReadPropertyWithDefault<vector<Value>>(205, "column_comments", result->column_comments, vector<Value>());
 	return std::move(result);
 }
 

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

@@ -13,12 +13,14 @@ void Expression::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty<ExpressionClass>(100, "expression_class", expression_class);
 	serializer.WriteProperty<ExpressionType>(101, "type", type);
 	serializer.WritePropertyWithDefault<string>(102, "alias", alias);
+	serializer.WritePropertyWithDefault<optional_idx>(103, "query_location", query_location, optional_idx());
 }
 
 unique_ptr<Expression> Expression::Deserialize(Deserializer &deserializer) {
 	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "expression_class");
 	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
 	auto alias = deserializer.ReadPropertyWithDefault<string>(102, "alias");
+	auto query_location = deserializer.ReadPropertyWithDefault<optional_idx>(103, "query_location", optional_idx());
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<Expression> result;
 	switch (expression_class) {
@@ -78,6 +80,7 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &deserializer) {
 	}
 	deserializer.Unset<ExpressionType>();
 	result->alias = std::move(alias);
+	result->query_location = query_location;
 	return result;
 }
 

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

@@ -124,9 +124,6 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_LIMIT:
 		result = LogicalLimit::Deserialize(deserializer);
 		break;
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		result = LogicalLimitPercent::Deserialize(deserializer);
-		break;
 	case LogicalOperatorType::LOGICAL_LOAD:
 		result = LogicalSimple::Deserialize(deserializer);
 		break;
@@ -506,35 +503,14 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(Deserializer &deserialize
 
 void LogicalLimit::Serialize(Serializer &serializer) const {
 	LogicalOperator::Serialize(serializer);
-	serializer.WritePropertyWithDefault<int64_t>(200, "limit_val", limit_val);
-	serializer.WritePropertyWithDefault<int64_t>(201, "offset_val", offset_val);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(202, "limit", limit);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(203, "offset", offset);
+	serializer.WriteProperty<BoundLimitNode>(200, "limit_val", limit_val);
+	serializer.WriteProperty<BoundLimitNode>(201, "offset_val", offset_val);
 }
 
 unique_ptr<LogicalOperator> LogicalLimit::Deserialize(Deserializer &deserializer) {
-	auto limit_val = deserializer.ReadPropertyWithDefault<int64_t>(200, "limit_val");
-	auto offset_val = deserializer.ReadPropertyWithDefault<int64_t>(201, "offset_val");
-	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit");
-	auto offset = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(203, "offset");
-	auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
-	return std::move(result);
-}
-
-void LogicalLimitPercent::Serialize(Serializer &serializer) const {
-	LogicalOperator::Serialize(serializer);
-	serializer.WriteProperty<double>(200, "limit_percent", limit_percent);
-	serializer.WritePropertyWithDefault<int64_t>(201, "offset_val", offset_val);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(202, "limit", limit);
-	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(203, "offset", offset);
-}
-
-unique_ptr<LogicalOperator> LogicalLimitPercent::Deserialize(Deserializer &deserializer) {
-	auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
-	auto offset_val = deserializer.ReadPropertyWithDefault<int64_t>(201, "offset_val");
-	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit");
-	auto offset = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(203, "offset");
-	auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
+	auto limit_val = deserializer.ReadProperty<BoundLimitNode>(200, "limit_val");
+	auto offset_val = deserializer.ReadProperty<BoundLimitNode>(201, "offset_val");
+	auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(std::move(limit_val), std::move(offset_val)));
 	return std::move(result);
 }
 

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

@@ -25,8 +25,8 @@
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_option.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/common/types/interval.hpp"
@@ -45,6 +45,22 @@ BoundCaseCheck BoundCaseCheck::Deserialize(Deserializer &deserializer) {
 	return result;
 }
 
+void BoundLimitNode::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<LimitNodeType>(100, "type", type);
+	serializer.WritePropertyWithDefault<idx_t>(101, "constant_integer", constant_integer);
+	serializer.WriteProperty<double>(102, "constant_percentage", constant_percentage);
+	serializer.WritePropertyWithDefault<unique_ptr<Expression>>(103, "expression", expression);
+}
+
+BoundLimitNode BoundLimitNode::Deserialize(Deserializer &deserializer) {
+	auto type = deserializer.ReadProperty<LimitNodeType>(100, "type");
+	auto constant_integer = deserializer.ReadPropertyWithDefault<idx_t>(101, "constant_integer");
+	auto constant_percentage = deserializer.ReadProperty<double>(102, "constant_percentage");
+	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(103, "expression");
+	BoundLimitNode result(type, constant_integer, constant_percentage, std::move(expression));
+	return result;
+}
+
 void BoundOrderByNode::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty<OrderType>(100, "type", type);
 	serializer.WriteProperty<OrderByNullType>(101, "null_order", null_order);
@@ -133,6 +149,7 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty<map<LogicalTypeId, CSVOption<StrpTimeFormat>>>(128, "dialect_options.date_format", dialect_options.date_format);
 	serializer.WritePropertyWithDefault<string>(129, "sniffer_user_mismatch_error", sniffer_user_mismatch_error);
 	serializer.WritePropertyWithDefault<bool>(130, "parallel", parallel);
+	serializer.WritePropertyWithDefault<vector<bool>>(131, "was_type_manually_set", was_type_manually_set);
 }
 
 CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
@@ -168,6 +185,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadProperty<map<LogicalTypeId, CSVOption<StrpTimeFormat>>>(128, "dialect_options.date_format", result.dialect_options.date_format);
 	deserializer.ReadPropertyWithDefault<string>(129, "sniffer_user_mismatch_error", result.sniffer_user_mismatch_error);
 	deserializer.ReadPropertyWithDefault<bool>(130, "parallel", result.parallel);
+	deserializer.ReadPropertyWithDefault<vector<bool>>(131, "was_type_manually_set", result.was_type_manually_set);
 	return result;
 }
 
@@ -363,14 +381,14 @@ PivotColumn PivotColumn::Deserialize(Deserializer &deserializer) {
 
 void PivotColumnEntry::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<vector<Value>>(100, "values", values);
-	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", star_expr);
+	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", expr);
 	serializer.WritePropertyWithDefault<string>(102, "alias", alias);
 }
 
 PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &deserializer) {
 	PivotColumnEntry result;
 	deserializer.ReadPropertyWithDefault<vector<Value>>(100, "values", result.values);
-	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", result.star_expr);
+	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(101, "star_expr", result.expr);
 	deserializer.ReadPropertyWithDefault<string>(102, "alias", result.alias);
 	return result;
 }

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

@@ -8,6 +8,7 @@
 #include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
 #include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
 #include "duckdb/parser/parsed_data/detach_info.hpp"
@@ -16,7 +17,6 @@
 #include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
 #include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/parser/parsed_data/comment_on_info.hpp"
 
 namespace duckdb {
 
@@ -34,9 +34,6 @@ unique_ptr<ParseInfo> ParseInfo::Deserialize(Deserializer &deserializer) {
 	case ParseInfoType::ATTACH_INFO:
 		result = AttachInfo::Deserialize(deserializer);
 		break;
-	case ParseInfoType::COMMENT_ON_INFO:
-		result = CommentOnInfo::Deserialize(deserializer);
-		break;
 	case ParseInfoType::COPY_INFO:
 		result = CopyInfo::Deserialize(deserializer);
 		break;
@@ -89,6 +86,9 @@ unique_ptr<ParseInfo> AlterInfo::Deserialize(Deserializer &deserializer) {
 	case AlterType::ALTER_VIEW:
 		result = AlterViewInfo::Deserialize(deserializer);
 		break;
+	case AlterType::SET_COLUMN_COMMENT:
+		result = SetColumnCommentInfo::Deserialize(deserializer);
+		break;
 	case AlterType::SET_COMMENT:
 		result = SetCommentInfo::Deserialize(deserializer);
 		break;
@@ -133,9 +133,6 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(Deserializer &deserializer) {
 	case AlterTableType::RENAME_TABLE:
 		result = RenameTableInfo::Deserialize(deserializer);
 		break;
-	case AlterTableType::SET_COLUMN_COMMENT:
-		result = SetColumnCommentInfo::Deserialize(deserializer);
-		break;
 	case AlterTableType::SET_DEFAULT:
 		result = SetDefaultInfo::Deserialize(deserializer);
 		break;
@@ -232,25 +229,6 @@ unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &deser
 	return std::move(result);
 }
 
-void CommentOnInfo::Serialize(Serializer &serializer) const {
-	ParseInfo::Serialize(serializer);
-	serializer.WriteProperty<CatalogType>(200, "type", type);
-	serializer.WritePropertyWithDefault<string>(201, "catalog", catalog);
-	serializer.WritePropertyWithDefault<string>(202, "schema", schema);
-	serializer.WritePropertyWithDefault<string>(203, "name", name);
-	serializer.WriteProperty<Value>(204, "comment", comment);
-}
-
-unique_ptr<ParseInfo> CommentOnInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CommentOnInfo>(new CommentOnInfo());
-	deserializer.ReadProperty<CatalogType>(200, "type", result->type);
-	deserializer.ReadPropertyWithDefault<string>(201, "catalog", result->catalog);
-	deserializer.ReadPropertyWithDefault<string>(202, "schema", result->schema);
-	deserializer.ReadPropertyWithDefault<string>(203, "name", result->name);
-	deserializer.ReadProperty<Value>(204, "comment", result->comment);
-	return std::move(result);
-}
-
 void CopyInfo::Serialize(Serializer &serializer) const {
 	ParseInfo::Serialize(serializer);
 	serializer.WritePropertyWithDefault<string>(200, "catalog", catalog);
@@ -406,15 +384,17 @@ unique_ptr<AlterViewInfo> RenameViewInfo::Deserialize(Deserializer &deserializer
 }
 
 void SetColumnCommentInfo::Serialize(Serializer &serializer) const {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WritePropertyWithDefault<string>(400, "column_name", column_name);
-	serializer.WriteProperty<Value>(401, "comment", comment);
+	AlterInfo::Serialize(serializer);
+	serializer.WriteProperty<CatalogType>(300, "catalog_entry_type", catalog_entry_type);
+	serializer.WriteProperty<Value>(301, "comment_value", comment_value);
+	serializer.WritePropertyWithDefault<string>(302, "column_name", column_name);
 }
 
-unique_ptr<AlterTableInfo> SetColumnCommentInfo::Deserialize(Deserializer &deserializer) {
+unique_ptr<AlterInfo> SetColumnCommentInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SetColumnCommentInfo>(new SetColumnCommentInfo());
-	deserializer.ReadPropertyWithDefault<string>(400, "column_name", result->column_name);
-	deserializer.ReadProperty<Value>(401, "comment", result->comment);
+	deserializer.ReadProperty<CatalogType>(300, "catalog_entry_type", result->catalog_entry_type);
+	deserializer.ReadProperty<Value>(301, "comment_value", result->comment_value);
+	deserializer.ReadPropertyWithDefault<string>(302, "column_name", result->column_name);
 	return std::move(result);
 }
 

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

@@ -0,0 +1,16 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_constraint.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_create_info.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_expression.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_logical_operator.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_macro_function.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_nodes.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_parsed_expression.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_parse_info.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_query_node.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_result_modifier.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_statement.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_table_filter.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_tableref.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_types.cpp>
+#include </Users/carlo/duckdb/src/storage/serialization/serialize_storage.cpp>