duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -29,6 +29,30 @@ using duckdb_parquet::format::PageType;
 using ParquetRowGroup = duckdb_parquet::format::RowGroup;
 using duckdb_parquet::format::Type;
 
+ChildFieldIDs::ChildFieldIDs() {
+	ids = make_uniq<case_insensitive_map_t<FieldID>>();
+}
+
+ChildFieldIDs ChildFieldIDs::Copy() const {
+	ChildFieldIDs result;
+	for (const auto &id : *ids) {
+		result.ids->emplace(id.first, id.second.Copy());
+	}
+	return result;
+}
+
+FieldID::FieldID() : set(false) {
+}
+
+FieldID::FieldID(int32_t field_id_p) : set(true), field_id(field_id_p) {
+}
+
+FieldID FieldID::Copy() const {
+	auto result = set ? FieldID(field_id) : FieldID();
+	result.child_field_ids = child_field_ids.Copy();
+	return result;
+}
+
 class MyTransport : public TTransport {
 public:
 	explicit MyTransport(Serializer &serializer) : serializer(serializer) {
@@ -52,27 +76,32 @@ private:
 	Serializer &serializer;
 };
 
-Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type) {
+bool ParquetWriter::DuckDBTypeToParquetTypeInternal(const LogicalType &duckdb_type, Type::type &parquet_type) {
 	switch (duckdb_type.id()) {
 	case LogicalTypeId::BOOLEAN:
-		return Type::BOOLEAN;
+		parquet_type = Type::BOOLEAN;
+		break;
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::DATE:
-		return Type::INT32;
+		parquet_type = Type::INT32;
+		break;
 	case LogicalTypeId::BIGINT:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::FLOAT:
-		return Type::FLOAT;
+		parquet_type = Type::FLOAT;
+		break;
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::HUGEINT:
-		return Type::DOUBLE;
+		parquet_type = Type::DOUBLE;
+		break;
 	case LogicalTypeId::ENUM:
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BIT:
-		return Type::BYTE_ARRAY;
+		parquet_type = Type::BYTE_ARRAY;
+		break;
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::TIMESTAMP:
@@ -80,31 +109,80 @@ Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_SEC:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
 	case LogicalTypeId::UINTEGER:
-		return Type::INT32;
+		parquet_type = Type::INT32;
+		break;
 	case LogicalTypeId::UBIGINT:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::UUID:
-		return Type::FIXED_LEN_BYTE_ARRAY;
+		parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
+		break;
 	case LogicalTypeId::DECIMAL:
 		switch (duckdb_type.InternalType()) {
 		case PhysicalType::INT16:
 		case PhysicalType::INT32:
-			return Type::INT32;
+			parquet_type = Type::INT32;
+			break;
 		case PhysicalType::INT64:
-			return Type::INT64;
+			parquet_type = Type::INT64;
+			break;
 		case PhysicalType::INT128:
-			return Type::FIXED_LEN_BYTE_ARRAY;
+			parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
+			break;
 		default:
 			throw InternalException("Unsupported internal decimal type");
 		}
+		break;
 	default:
+		// Anything that is not supported returns false
+		return false;
+	}
+	return true;
+}
+
+Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type) {
+	Type::type result;
+	if (!DuckDBTypeToParquetTypeInternal(duckdb_type, result)) {
 		throw NotImplementedException("Unimplemented type for Parquet \"%s\"", duckdb_type.ToString());
 	}
+	return result;
+}
+
+bool ParquetWriter::TypeIsSupported(const LogicalType &type) {
+	Type::type unused;
+	auto id = type.id();
+	if (id == LogicalTypeId::LIST) {
+		auto &child_type = ListType::GetChildType(type);
+		return TypeIsSupported(child_type);
+	}
+	if (id == LogicalTypeId::STRUCT) {
+		auto &children = StructType::GetChildTypes(type);
+		for (auto &child : children) {
+			auto &child_type = child.second;
+			if (!TypeIsSupported(child_type)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	if (id == LogicalTypeId::MAP) {
+		auto &key_type = MapType::KeyType(type);
+		auto &value_type = MapType::ValueType(type);
+		if (!TypeIsSupported(key_type)) {
+			return false;
+		}
+		if (!TypeIsSupported(value_type)) {
+			return false;
+		}
+		return true;
+	}
+	return DuckDBTypeToParquetTypeInternal(type, unused);
 }
 
 void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,
@@ -226,8 +304,9 @@ void VerifyUniqueNames(const vector<string> &names) {
 }
 
 ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, vector<LogicalType> types_p, vector<string> names_p,
-                             CompressionCodec::type codec)
-    : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec) {
+                             CompressionCodec::type codec, ChildFieldIDs field_ids_p)
+    : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec),
+      field_ids(std::move(field_ids_p)) {
 	// initialize the file writer
 	writer = make_uniq<BufferedFileWriter>(fs, file_name.c_str(),
 	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
@@ -257,37 +336,73 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, vector<LogicalT
 	vector<string> schema_path;
 	for (idx_t i = 0; i < sql_types.size(); i++) {
 		column_writers.push_back(ColumnWriter::CreateWriterRecursive(file_meta_data.schema, *this, sql_types[i],
-		                                                             unique_names[i], schema_path));
+		                                                             unique_names[i], schema_path, &field_ids));
 	}
 }
 
 void ParquetWriter::PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGroup &result) {
+	// We write 8 columns at a time so that iterating over ColumnDataCollection is more efficient
+	static constexpr idx_t COLUMNS_PER_PASS = 8;
+
+	// We want these to be in-memory/hybrid so we don't have to copy over strings to the dictionary
+	D_ASSERT(buffer.GetAllocatorType() == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR ||
+	         buffer.GetAllocatorType() == ColumnDataAllocatorType::HYBRID);
+
 	// set up a new row group for this chunk collection
 	auto &row_group = result.row_group;
 	row_group.num_rows = buffer.Count();
+	row_group.total_byte_size = buffer.SizeInBytes();
 	row_group.__isset.file_offset = true;
 
 	auto &states = result.states;
 	// iterate over each of the columns of the chunk collection and write them
 	D_ASSERT(buffer.ColumnCount() == column_writers.size());
-	for (idx_t col_idx = 0; col_idx < buffer.ColumnCount(); col_idx++) {
-		const auto &col_writer = column_writers[col_idx];
-		auto write_state = col_writer->InitializeWriteState(row_group, buffer.GetAllocator());
-		if (col_writer->HasAnalyze()) {
-			for (auto &chunk : buffer.Chunks()) {
-				col_writer->Analyze(*write_state, nullptr, chunk.data[col_idx], chunk.size());
+	for (idx_t col_idx = 0; col_idx < buffer.ColumnCount(); col_idx += COLUMNS_PER_PASS) {
+		const auto next = MinValue<idx_t>(buffer.ColumnCount() - col_idx, COLUMNS_PER_PASS);
+		vector<column_t> column_ids;
+		vector<reference<ColumnWriter>> col_writers;
+		vector<unique_ptr<ColumnWriterState>> write_states;
+		for (idx_t i = 0; i < next; i++) {
+			column_ids.emplace_back(col_idx + i);
+			col_writers.emplace_back(*column_writers[column_ids.back()]);
+			write_states.emplace_back(col_writers.back().get().InitializeWriteState(row_group));
+		}
+
+		for (auto &chunk : buffer.Chunks({column_ids})) {
+			for (idx_t i = 0; i < next; i++) {
+				if (col_writers[i].get().HasAnalyze()) {
+					col_writers[i].get().Analyze(*write_states[i], nullptr, chunk.data[i], chunk.size());
+				}
 			}
-			col_writer->FinalizeAnalyze(*write_state);
 		}
-		for (auto &chunk : buffer.Chunks()) {
-			col_writer->Prepare(*write_state, nullptr, chunk.data[col_idx], chunk.size());
+
+		for (idx_t i = 0; i < next; i++) {
+			if (col_writers[i].get().HasAnalyze()) {
+				col_writers[i].get().FinalizeAnalyze(*write_states[i]);
+			}
 		}
-		col_writer->BeginWrite(*write_state);
-		for (auto &chunk : buffer.Chunks()) {
-			col_writer->Write(*write_state, chunk.data[col_idx], chunk.size());
+
+		for (auto &chunk : buffer.Chunks({column_ids})) {
+			for (idx_t i = 0; i < next; i++) {
+				col_writers[i].get().Prepare(*write_states[i], nullptr, chunk.data[i], chunk.size());
+			}
+		}
+
+		for (idx_t i = 0; i < next; i++) {
+			col_writers[i].get().BeginWrite(*write_states[i]);
+		}
+
+		for (auto &chunk : buffer.Chunks({column_ids})) {
+			for (idx_t i = 0; i < next; i++) {
+				col_writers[i].get().Write(*write_states[i], chunk.data[i], chunk.size());
+			}
+		}
+
+		for (auto &write_state : write_states) {
+			states.push_back(std::move(write_state));
 		}
-		states.push_back(std::move(write_state));
 	}
+	result.heaps = buffer.GetHeapReferences();
 }
 
 void ParquetWriter::FlushRowGroup(PreparedRowGroup &prepared) {
@@ -307,6 +422,8 @@ void ParquetWriter::FlushRowGroup(PreparedRowGroup &prepared) {
 	// append the row group to the file meta data
 	file_meta_data.row_groups.push_back(row_group);
 	file_meta_data.num_rows += row_group.num_rows;
+
+	prepared.heaps.clear();
 }
 
 void ParquetWriter::Flush(ColumnDataCollection &buffer) {
@@ -316,6 +433,7 @@ void ParquetWriter::Flush(ColumnDataCollection &buffer) {
 
 	PreparedRowGroup prepared_row_group;
 	PrepareRowGroup(buffer, prepared_row_group);
+	buffer.Reset();
 
 	FlushRowGroup(prepared_row_group);
 }

package/src/duckdb/extension/parquet/serialize_parquet.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "parquet_reader.hpp"
+
+namespace duckdb {
+
+void ParquetOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty(100, "binary_as_string", binary_as_string);
+	serializer.WriteProperty(101, "file_row_number", file_row_number);
+	serializer.WriteProperty(102, "file_options", file_options);
+}
+
+ParquetOptions ParquetOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	ParquetOptions result;
+	deserializer.ReadProperty(100, "binary_as_string", result.binary_as_string);
+	deserializer.ReadProperty(101, "file_row_number", result.file_row_number);
+	deserializer.ReadProperty(102, "file_options", result.file_options);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/zstd_file_system.cpp

@@ -155,7 +155,7 @@ void ZstdStreamWrapper::Close() {
 
 class ZStdFile : public CompressedFile {
 public:
-	ZStdFile(duckdb::unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
+	ZStdFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
 	    : CompressedFile(zstd_fs, std::move(child_handle_p), path) {
 		Initialize(write);
 	}
@@ -163,7 +163,7 @@ public:
 	ZStdFileSystem zstd_fs;
 };
 
-unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(duckdb::unique_ptr<FileHandle> handle, bool write) {
+unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
 	auto path = handle->path;
 	return make_uniq<ZStdFile>(std::move(handle), path, write);
 }

package/src/duckdb/src/catalog/catalog.cpp

@@ -278,7 +278,7 @@ optional_ptr<CatalogEntry> Catalog::CreateIndex(CatalogTransaction transaction,
 
 optional_ptr<CatalogEntry> Catalog::CreateIndex(ClientContext &context, CreateIndexInfo &info) {
 	auto &schema = GetSchema(context, info.schema);
-	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table->table_name);
+	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table);
 	return schema.CreateIndex(context, info, table);
 }
 
@@ -655,17 +655,13 @@ LogicalType Catalog::GetType(ClientContext &context, const string &schema, const
 	if (!type_entry) {
 		return LogicalType::INVALID;
 	}
-	auto result_type = type_entry->user_type;
-	EnumType::SetCatalog(result_type, type_entry.get());
-	return result_type;
+	return type_entry->user_type;
 }
 
 LogicalType Catalog::GetType(ClientContext &context, const string &catalog_name, const string &schema,
                              const string &name) {
 	auto &type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
-	auto result_type = type_entry.user_type;
-	EnumType::SetCatalog(result_type, &type_entry);
-	return result_type;
+	return type_entry.user_type;
 }
 
 vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context) {

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -23,7 +23,7 @@
 namespace duckdb {
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	// fetch types and create expressions for the index from the columns
 	vector<column_t> column_ids;
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -41,9 +41,9 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 	}
 	unique_ptr<ART> art;
 	// create an adaptive radix tree around the expressions
-	if (index_block) {
+	if (index_block.IsValid()) {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db, index_block->block_id, index_block->offset);
+		                     storage.db, nullptr, index_block);
 	} else {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
 		                     storage.db);
@@ -55,7 +55,7 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 }
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	vector<PhysicalIndex> new_keys;
 	new_keys.reserve(keys.size());
 	for (auto &logical_key : keys) {
@@ -92,7 +92,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 				if (info.indexes.empty()) {
 					AddDataTableIndex(*storage, columns, unique.keys, constraint_type);
 				} else {
-					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, &info.indexes[indexes_idx++]);
+					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, info.indexes[indexes_idx++]);
 				}
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
 				// foreign key constraint: create a foreign key index
@@ -103,7 +103,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
 					} else {
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-						                  &info.indexes[indexes_idx++]);
+						                  info.indexes[indexes_idx++]);
 					}
 				}
 			}
@@ -298,7 +298,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
 	auto new_storage =
-	    make_shared<DataTable>(context, *storage, info.new_column, bound_create_info->bound_defaults.back().get());
+	    make_shared<DataTable>(context, *storage, info.new_column, *bound_create_info->bound_defaults.back());
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
@@ -527,10 +527,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	if (info.target_type.id() == LogicalTypeId::USER) {
-		info.target_type =
-		    Catalog::GetType(context, catalog.GetName(), schema.name, UserType::GetTypeName(info.target_type));
-	}
+	Binder::BindLogicalType(context, info.target_type, &catalog, schema.name);
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;

package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp

@@ -19,47 +19,23 @@ string IndexCatalogEntry::ToSQL() const {
 	return sql;
 }
 
-void IndexCatalogEntry::Serialize(Serializer &serializer) const {
-	// here we serialize the index metadata in the following order:
-	// schema name, table name, index name, sql, index type, index constraint type, expression list, parsed expressions,
-	// column IDs
-
-	FieldWriter writer(serializer);
-	writer.WriteString(GetSchemaName());
-	writer.WriteString(GetTableName());
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteField(index->type);
-	writer.WriteField(index->constraint_type);
-	writer.WriteSerializableList(expressions);
-	writer.WriteSerializableList(parsed_expressions);
-	writer.WriteList<idx_t>(index->column_ids);
-	writer.Finalize();
-}
-
-unique_ptr<CreateIndexInfo> IndexCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	// here we deserialize the index metadata in the following order:
-	// schema name, table schema name, table name, index name, sql, index type, index constraint type, expression list,
-	// parsed expression list, column IDs
-
-	auto create_index_info = make_uniq<CreateIndexInfo>();
-
-	FieldReader reader(source);
-
-	create_index_info->schema = reader.ReadRequired<string>();
-	create_index_info->table = make_uniq<BaseTableRef>();
-	create_index_info->table->schema_name = create_index_info->schema;
-	create_index_info->table->table_name = reader.ReadRequired<string>();
-	create_index_info->index_name = reader.ReadRequired<string>();
-	create_index_info->sql = reader.ReadRequired<string>();
-	create_index_info->index_type = IndexType(reader.ReadRequired<uint8_t>());
-	create_index_info->constraint_type = IndexConstraintType(reader.ReadRequired<uint8_t>());
-	create_index_info->expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	create_index_info->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	create_index_info->column_ids = reader.ReadRequiredList<idx_t>();
-	reader.Finalize();
-	return create_index_info;
+unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateIndexInfo>();
+	result->schema = GetSchemaName();
+	result->table = GetTableName();
+	result->index_name = name;
+	result->sql = sql;
+	result->index_type = index->type;
+	result->constraint_type = index->constraint_type;
+	for (auto &expr : expressions) {
+		result->expressions.push_back(expr->Copy());
+	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
+	}
+	result->column_ids = index->column_ids;
+	result->temporary = temporary;
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp

@@ -22,21 +22,13 @@ TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEn
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::GetInfoForSerialization() const {
+unique_ptr<CreateInfo> MacroCatalogEntry::GetInfo() const {
 	auto info = make_uniq<CreateMacroInfo>(type);
 	info->catalog = catalog.GetName();
 	info->schema = schema.name;
 	info->name = name;
 	info->function = function->Copy();
-	return info;
-}
-void MacroCatalogEntry::Serialize(Serializer &serializer) const {
-	auto info = GetInfoForSerialization();
-	info->Serialize(serializer);
-}
-
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
-	return unique_ptr_cast<CreateInfo, CreateMacroInfo>(CreateInfo::Deserialize(main_source));
+	return std::move(info);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp

@@ -33,20 +33,10 @@ SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction trans
 	return result;
 }
 
-void SchemaCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSchemaInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSchemaInfo>();
+	result->schema = name;
+	return std::move(result);
 }
 
 string SchemaCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp

@@ -18,34 +18,17 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry
 	this->temporary = info.temporary;
 }
 
-void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteField<uint64_t>(usage_count);
-	writer.WriteField<int64_t>(increment);
-	writer.WriteField<int64_t>(min_value);
-	writer.WriteField<int64_t>(max_value);
-	writer.WriteField<int64_t>(counter);
-	writer.WriteField<bool>(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSequenceInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->usage_count = reader.ReadRequired<uint64_t>();
-	info->increment = reader.ReadRequired<int64_t>();
-	info->min_value = reader.ReadRequired<int64_t>();
-	info->max_value = reader.ReadRequired<int64_t>();
-	info->start_value = reader.ReadRequired<int64_t>();
-	info->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSequenceInfo>();
+	result->schema = schema.name;
+	result->name = name;
+	result->usage_count = usage_count;
+	result->increment = increment;
+	result->min_value = min_value;
+	result->max_value = max_value;
+	result->start_value = counter;
+	result->cycle = cycle;
+	return std::move(result);
 }
 
 string SequenceCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -56,42 +56,16 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
-CreateTableInfo TableCatalogEntry::GetTableInfoForSerialization() const {
-	CreateTableInfo result;
-	result.catalog = catalog.GetName();
-	result.schema = schema.name;
-	result.table = name;
-	result.columns = columns.Copy();
-	result.constraints.reserve(constraints.size());
+unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTableInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->table = name;
+	result->columns = columns.Copy();
+	result->constraints.reserve(constraints.size());
 	std::for_each(constraints.begin(), constraints.end(),
-	              [&result](const unique_ptr<Constraint> &c) { result.constraints.emplace_back(c->Copy()); });
-	return result;
-}
-
-void TableCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	const auto info = GetTableInfoForSerialization();
-	FieldWriter writer(serializer);
-	writer.WriteString(info.catalog);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	info.columns.Serialize(writer);
-	writer.WriteSerializableList(info.constraints);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateTableInfo>();
-
-	FieldReader reader(source);
-	info->catalog = reader.ReadRequired<string>();
-	info->schema = reader.ReadRequired<string>();
-	info->table = reader.ReadRequired<string>();
-	info->columns = ColumnList::Deserialize(reader);
-	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	reader.Finalize();
-
-	return info;
+	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
+	return std::move(result);
 }
 
 string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
@@ -162,11 +136,10 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			// single column unique: insert constraint here
 			ss << " UNIQUE";
 		}
-		if (column.DefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
-		}
 		if (column.Generated()) {
 			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
+		} else if (column.DefaultValue()) {
+			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
 		}
 	}
 	// print any extra constraints that still need to be printed
@@ -199,10 +172,6 @@ const ColumnList &TableCatalogEntry::GetColumns() const {
 	return columns;
 }
 
-ColumnList &TableCatalogEntry::GetColumnsMutable() {
-	return columns;
-}
-
 const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
 	return columns.GetColumn(idx);
 }