duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

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

@@ -41,6 +41,42 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 	return result;
 }
 
+void CTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("query", *query);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("query", result->query);
+	deserializer.ReadProperty("child", result->child);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
+void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("union_all", union_all);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("union_all", result->union_all);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
 void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty("select_list", select_list);
@@ -83,40 +119,4 @@ unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
-	serializer.WriteProperty("cte_name", ctename);
-	serializer.WriteProperty("union_all", union_all);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-	serializer.WriteProperty("aliases", aliases);
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
-	deserializer.ReadProperty("cte_name", result->ctename);
-	deserializer.ReadProperty("union_all", result->union_all);
-	deserializer.ReadProperty("left", result->left);
-	deserializer.ReadProperty("right", result->right);
-	deserializer.ReadProperty("aliases", result->aliases);
-	return std::move(result);
-}
-
-void CTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
-	serializer.WriteProperty("cte_name", ctename);
-	serializer.WriteProperty("query", *query);
-	serializer.WriteProperty("child", *child);
-	serializer.WriteProperty("aliases", aliases);
-}
-
-unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
-	deserializer.ReadProperty("cte_name", result->ctename);
-	deserializer.ReadProperty("query", result->query);
-	deserializer.ReadProperty("child", result->child);
-	deserializer.ReadProperty("aliases", result->aliases);
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -6,6 +6,7 @@
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
 #include "duckdb/parser/result_modifier.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
@@ -35,17 +36,14 @@ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer
 	return result;
 }
 
-void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+void BoundOrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("orders", orders);
 }
 
-unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
-	deserializer.ReadOptionalProperty("limit", result->limit);
-	deserializer.ReadOptionalProperty("offset", result->offset);
-	return std::move(result);
+unique_ptr<BoundOrderModifier> BoundOrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
+	deserializer.ReadProperty("orders", result->orders);
+	return result;
 }
 
 void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
@@ -59,14 +57,16 @@ unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteProperty("orders", orders);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
 }
 
-unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
-	deserializer.ReadProperty("orders", result->orders);
+unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
+	deserializer.ReadOptionalProperty("limit", result->limit);
+	deserializer.ReadOptionalProperty("offset", result->offset);
 	return std::move(result);
 }
 
@@ -83,4 +83,15 @@ unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
+void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("orders", orders);
+}
+
+unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
+	deserializer.ReadProperty("orders", result->orders);
+	return std::move(result);
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+// 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 "duckdb/parser/statement/select_statement.hpp"
+
+namespace duckdb {
+
+void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("node", *node);
+}
+
+unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
+	deserializer.ReadProperty("node", result->node);
+	return result;
+}
+
+} // namespace duckdb

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

@@ -67,6 +67,30 @@ unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deseria
 	return std::move(result);
 }
 
+void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+}
+
+unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
+	return std::move(result);
+}
+
+void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("expected_names", expected_names);
+	serializer.WriteProperty("expected_types", expected_types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
+	deserializer.ReadProperty("expected_names", result->expected_names);
+	deserializer.ReadProperty("expected_types", result->expected_types);
+	deserializer.ReadProperty("values", result->values);
+	return std::move(result);
+}
+
 void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
 	serializer.WriteProperty("left", *left);
@@ -88,6 +112,29 @@ unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer
 	return std::move(result);
 }
 
+void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("source", *source);
+	serializer.WriteProperty("aggregates", aggregates);
+	serializer.WriteProperty("unpivot_names", unpivot_names);
+	serializer.WriteProperty("pivots", pivots);
+	serializer.WriteProperty("groups", groups);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty("include_nulls", include_nulls);
+}
+
+unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
+	deserializer.ReadProperty("source", result->source);
+	deserializer.ReadProperty("aggregates", result->aggregates);
+	deserializer.ReadProperty("unpivot_names", result->unpivot_names);
+	deserializer.ReadProperty("pivots", result->pivots);
+	deserializer.ReadProperty("groups", result->groups);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty("include_nulls", result->include_nulls);
+	return std::move(result);
+}
+
 void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
 	serializer.WriteProperty("subquery", *subquery);
@@ -116,51 +163,4 @@ unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &des
 	return std::move(result);
 }
 
-void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-}
-
-unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
-	return std::move(result);
-}
-
-void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("expected_names", expected_names);
-	serializer.WriteProperty("expected_types", expected_types);
-	serializer.WriteProperty("values", values);
-}
-
-unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
-	deserializer.ReadProperty("expected_names", result->expected_names);
-	deserializer.ReadProperty("expected_types", result->expected_types);
-	deserializer.ReadProperty("values", result->values);
-	return std::move(result);
-}
-
-void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("source", *source);
-	serializer.WriteProperty("aggregates", aggregates);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("pivots", pivots);
-	serializer.WriteProperty("groups", groups);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-	serializer.WriteProperty("include_nulls", include_nulls);
-}
-
-unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
-	deserializer.ReadProperty("source", result->source);
-	deserializer.ReadProperty("aggregates", result->aggregates);
-	deserializer.ReadProperty("unpivot_names", result->unpivot_names);
-	deserializer.ReadProperty("pivots", result->pivots);
-	deserializer.ReadProperty("groups", result->groups);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	deserializer.ReadProperty("include_nulls", result->include_nulls);
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -52,6 +52,21 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 	return result;
 }
 
+void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+	ExtraTypeInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", state_type.function_name);
+	serializer.WriteProperty("return_type", state_type.return_type);
+	serializer.WriteProperty("bound_argument_types", state_type.bound_argument_types);
+}
+
+shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
+	deserializer.ReadProperty("function_name", result->state_type.function_name);
+	deserializer.ReadProperty("return_type", result->state_type.return_type);
+	deserializer.ReadProperty("bound_argument_types", result->state_type.bound_argument_types);
+	return std::move(result);
+}
+
 void DecimalTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("width", width);
@@ -65,17 +80,6 @@ shared_ptr<ExtraTypeInfo> DecimalTypeInfo::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("collation", collation);
-}
-
-shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
-	deserializer.ReadProperty("collation", result->collation);
-	return std::move(result);
-}
-
 void ListTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("child_type", child_type);
@@ -87,29 +91,25 @@ shared_ptr<ExtraTypeInfo> ListTypeInfo::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("child_types", child_types);
+	serializer.WriteProperty("collation", collation);
 }
 
-shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
-	deserializer.ReadProperty("child_types", result->child_types);
+shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
+	deserializer.ReadProperty("collation", result->collation);
 	return std::move(result);
 }
 
-void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("function_name", state_type.function_name);
-	serializer.WriteProperty("return_type", state_type.return_type);
-	serializer.WriteProperty("bound_argument_types", state_type.bound_argument_types);
+	serializer.WriteProperty("child_types", child_types);
 }
 
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
-	deserializer.ReadProperty("function_name", result->state_type.function_name);
-	deserializer.ReadProperty("return_type", result->state_type.return_type);
-	deserializer.ReadProperty("bound_argument_types", result->state_type.bound_argument_types);
+shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
+	deserializer.ReadProperty("child_types", result->child_types);
 	return std::move(result);
 }
 

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

@@ -2,14 +2,15 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 52;
+const uint64_t VERSION_NUMBER = 53;
 
 struct StorageVersionInfo {
 	const char *version_name;
 	idx_t storage_version;
 };
 
-static StorageVersionInfo storage_version_info[] = {{"v0.7.0 or v0.7.1", 43},
+static StorageVersionInfo storage_version_info[] = {{"v0.8.0 or v0.8.1", 51},
+                                                    {"v0.7.0 or v0.7.1", 43},
                                                     {"v0.6.0 or v0.6.1", 39},
                                                     {"v0.5.0 or v0.5.1", 38},
                                                     {"v0.3.3, v0.3.4 or v0.4.0", 33},

package/src/duckdb/src/storage/wal_replay.cpp

@@ -195,7 +195,7 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
-	auto info = TableCatalogEntry::Deserialize(source, context);
+	auto info = TableCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
@@ -234,12 +234,12 @@ void ReplayState::ReplayAlter() {
 // Replay View
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateView() {
-	auto entry = ViewCatalogEntry::Deserialize(source, context);
+	auto entry = CatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateView(context, *entry);
+	catalog.CreateView(context, entry->Cast<CreateViewInfo>());
 }
 
 void ReplayState::ReplayDropView() {
@@ -309,7 +309,7 @@ void ReplayState::ReplayCreateSequence() {
 		return;
 	}
 
-	catalog.CreateSequence(context, *entry);
+	catalog.CreateSequence(context, entry->Cast<CreateSequenceInfo>());
 }
 
 void ReplayState::ReplayDropSequence() {
@@ -345,12 +345,12 @@ void ReplayState::ReplaySequenceValue() {
 // Replay Macro
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateMacro() {
-	auto entry = ScalarMacroCatalogEntry::Deserialize(source, context);
+	auto entry = ScalarMacroCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateFunction(context, *entry);
+	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
 }
 
 void ReplayState::ReplayDropMacro() {
@@ -369,12 +369,12 @@ void ReplayState::ReplayDropMacro() {
 // Replay Table Macro
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTableMacro() {
-	auto entry = TableMacroCatalogEntry::Deserialize(source, context);
+	auto entry = TableMacroCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateFunction(context, *entry);
+	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
 }
 
 void ReplayState::ReplayDropTableMacro() {
@@ -393,30 +393,31 @@ void ReplayState::ReplayDropTableMacro() {
 // Replay Index
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateIndex() {
-	auto info = IndexCatalogEntry::Deserialize(source, context);
+	auto info = IndexCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
+	auto &index_info = info->Cast<CreateIndexInfo>();
 
 	// get the physical table to which we'll add the index
-	auto &table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table->table_name);
+	auto &table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, index_info.table);
 	auto &data_table = table.GetStorage();
 
 	// bind the parsed expressions
-	if (info->expressions.empty()) {
-		for (auto &parsed_expr : info->parsed_expressions) {
-			info->expressions.push_back(parsed_expr->Copy());
+	if (index_info.expressions.empty()) {
+		for (auto &parsed_expr : index_info.parsed_expressions) {
+			index_info.expressions.push_back(parsed_expr->Copy());
 		}
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto expressions = binder->BindCreateIndexExpressions(table, *info);
+	auto expressions = binder->BindCreateIndexExpressions(table, index_info);
 
 	// create the empty index
 	unique_ptr<Index> index;
-	switch (info->index_type) {
+	switch (index_info.index_type) {
 	case IndexType::ART: {
-		index = make_uniq<ART>(info->column_ids, TableIOManager::Get(data_table), expressions, info->constraint_type,
-		                       data_table.db);
+		index = make_uniq<ART>(index_info.column_ids, TableIOManager::Get(data_table), expressions,
+		                       index_info.constraint_type, data_table.db);
 		break;
 	}
 	default:
@@ -424,10 +425,10 @@ void ReplayState::ReplayCreateIndex() {
 	}
 
 	// add the index to the catalog
-	auto &index_entry = catalog.CreateIndex(context, *info)->Cast<DuckIndexEntry>();
+	auto &index_entry = catalog.CreateIndex(context, index_info)->Cast<DuckIndexEntry>();
 	index_entry.index = index.get();
 	index_entry.info = data_table.info;
-	for (auto &parsed_expr : info->parsed_expressions) {
+	for (auto &parsed_expr : index_info.parsed_expressions) {
 		index_entry.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -348,17 +348,17 @@
 
 #include "extension/icu/third_party/icu/i18n/wintzimpl.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
-
-#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
 
+#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
+
 #include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
 

package/src/duckdb/ub_src_core_functions_scalar_string.cpp

@@ -38,6 +38,8 @@
 
 #include "src/core_functions/scalar/string/string_split.cpp"
 
+#include "src/core_functions/scalar/string/to_base.cpp"
+
 #include "src/core_functions/scalar/string/translate.cpp"
 
 #include "src/core_functions/scalar/string/trim.cpp"

package/src/duckdb/ub_src_parser.cpp

@@ -6,8 +6,6 @@
 
 #include "src/parser/constraint.cpp"
 
-#include "src/parser/common_table_expression_info.cpp"
-
 #include "src/parser/expression_util.cpp"
 
 #include "src/parser/keyword_helper.cpp"

package/src/duckdb/ub_src_storage_compression.cpp

@@ -14,6 +14,8 @@
 
 #include "src/storage/compression/bitpacking.cpp"
 
+#include "src/storage/compression/bitpacking_hugeint.cpp"
+
 #include "src/storage/compression/patas.cpp"
 
 #include "src/storage/compression/fsst.cpp"

package/src/duckdb/ub_src_storage_serialization.cpp

@@ -1,9 +1,25 @@
+#include "src/storage/serialization/serialize_constraint.cpp"
+
+#include "src/storage/serialization/serialize_create_info.cpp"
+
+#include "src/storage/serialization/serialize_expression.cpp"
+
+#include "src/storage/serialization/serialize_logical_operator.cpp"
+
+#include "src/storage/serialization/serialize_macro_function.cpp"
+
+#include "src/storage/serialization/serialize_nodes.cpp"
+
 #include "src/storage/serialization/serialize_parsed_expression.cpp"
 
+#include "src/storage/serialization/serialize_parse_info.cpp"
+
 #include "src/storage/serialization/serialize_query_node.cpp"
 
 #include "src/storage/serialization/serialize_result_modifier.cpp"
 
+#include "src/storage/serialization/serialize_statement.cpp"
+
 #include "src/storage/serialization/serialize_tableref.cpp"
 
 #include "src/storage/serialization/serialize_types.cpp"

package/src/duckdb/src/parser/common_table_expression_info.cpp

@@ -1,21 +0,0 @@
-#include "duckdb/parser/common_table_expression_info.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-
-namespace duckdb {
-
-void CommonTableExpressionInfo::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("aliases", aliases);
-	serializer.WriteProperty("query", query);
-	serializer.WriteProperty("materialized", materialized);
-}
-
-unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<CommonTableExpressionInfo>();
-	result->aliases = deserializer.ReadProperty<vector<string>>("aliases");
-	result->query = deserializer.ReadProperty<unique_ptr<SelectStatement>>("query");
-	result->materialized = deserializer.ReadProperty<CTEMaterialize>("materialized");
-	return result;
-}
-
-} // namespace duckdb