duckdb 0.8.2-dev3458.0 → 0.8.2-dev3949.0

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

@@ -44,47 +44,63 @@ string SanitizeExportIdentifier(const string &str) {
 	return result;
 }
 
-bool IsExistMainKeyTable(string &table_name, vector<reference<TableCatalogEntry>> &unordered) {
-	for (idx_t i = 0; i < unordered.size(); i++) {
-		if (unordered[i].get().name == table_name) {
+bool ReferencedTableIsOrdered(string &referenced_table, catalog_entry_vector_t &ordered) {
+	for (auto &entry : ordered) {
+		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
+		if (StringUtil::CIEquals(table_entry.name, referenced_table)) {
+			// The referenced table is already ordered
 			return true;
 		}
 	}
 	return false;
 }
 
-void ScanForeignKeyTable(vector<reference<TableCatalogEntry>> &ordered, vector<reference<TableCatalogEntry>> &unordered,
-                         bool move_only_pk_table) {
-	for (auto i = unordered.begin(); i != unordered.end();) {
-		auto table_entry = *i;
+void ScanForeignKeyTable(catalog_entry_vector_t &ordered, catalog_entry_vector_t &unordered,
+                         bool move_primary_keys_only) {
+	catalog_entry_vector_t remaining;
+
+	for (auto &entry : unordered) {
+		auto &table_entry = entry.get().Cast<TableCatalogEntry>();
 		bool move_to_ordered = true;
-		auto &constraints = table_entry.get().GetConstraints();
-		for (idx_t j = 0; j < constraints.size(); j++) {
-			auto &cond = constraints[j];
-			if (cond->type == ConstraintType::FOREIGN_KEY) {
-				auto &fk = cond->Cast<ForeignKeyConstraint>();
-				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
-				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
-				     IsExistMainKeyTable(fk.info.table, unordered))) {
-					move_to_ordered = false;
-					break;
-				}
+		auto &constraints = table_entry.GetConstraints();
+
+		for (auto &cond : constraints) {
+			if (cond->type != ConstraintType::FOREIGN_KEY) {
+				continue;
+			}
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
+			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
+				continue;
+			}
+
+			if (move_primary_keys_only) {
+				// This table references a table, don't move it yet
+				move_to_ordered = false;
+				break;
+			} else if (!ReferencedTableIsOrdered(fk.info.table, ordered)) {
+				// The table that it references isn't ordered yet
+				move_to_ordered = false;
+				break;
 			}
 		}
+
 		if (move_to_ordered) {
 			ordered.push_back(table_entry);
-			i = unordered.erase(i);
 		} else {
-			i++;
+			remaining.push_back(table_entry);
 		}
 	}
+	unordered = remaining;
 }
 
-void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables) {
-	vector<reference<TableCatalogEntry>> ordered;
-	vector<reference<TableCatalogEntry>> unordered = tables;
+void ReorderTableEntries(catalog_entry_vector_t &tables) {
+	catalog_entry_vector_t ordered;
+	catalog_entry_vector_t unordered = tables;
+	// First only move the tables that don't have any dependencies
 	ScanForeignKeyTable(ordered, unordered, true);
 	while (!unordered.empty()) {
+		// Now we will start moving tables that have foreign key constraints
+		// if the tables they reference are already moved
 		ScanForeignKeyTable(ordered, unordered, false);
 	}
 	tables = ordered;
@@ -130,7 +146,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	// gather a list of all the tables
 	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
-	vector<reference<TableCatalogEntry>> tables;
+	catalog_entry_vector_t tables;
 	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
 		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
@@ -151,7 +167,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	unordered_set<string> table_name_index;
 	for (auto &t : tables) {
-		auto &table = t.get();
+		auto &table = t.get().Cast<TableCatalogEntry>();
 		auto info = make_uniq<CopyInfo>();
 		// we copy the options supplied to the EXPORT
 		info->format = stmt.info->format;

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

@@ -110,8 +110,8 @@ void BoundAggregateExpression::FormatSerialize(FormatSerializer &serializer) con
 	serializer.WriteProperty(201, "children", children);
 	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
 	serializer.WriteProperty(203, "aggregate_type", aggr_type);
-	serializer.WriteOptionalProperty(204, "filter", filter);
-	serializer.WriteOptionalProperty(205, "order_bys", order_bys);
+	serializer.WritePropertyWithDefault(204, "filter", filter, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(205, "order_bys", order_bys, unique_ptr<BoundOrderModifier>());
 }
 
 unique_ptr<Expression> BoundAggregateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -120,10 +120,10 @@ unique_ptr<Expression> BoundAggregateExpression::FormatDeserialize(FormatDeseria
 	auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
 	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
 	auto aggregate_type = deserializer.ReadProperty<AggregateType>(203, "aggregate_type");
-	auto filter = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(204, "filter");
+	auto filter = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(204, "filter", unique_ptr<Expression>());
 	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),
 	                                                  std::move(entry.second), aggregate_type);
-	deserializer.ReadOptionalProperty(205, "order_bys", result->order_bys);
+	deserializer.ReadPropertyWithDefault(205, "order_bys", result->order_bys, unique_ptr<BoundOrderModifier>());
 	return std::move(result);
 }
 

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

@@ -172,14 +172,14 @@ void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const
 	}
 	serializer.WriteProperty(202, "partitions", partitions);
 	serializer.WriteProperty(203, "orders", orders);
-	serializer.WriteOptionalProperty(204, "filters", filter_expr);
+	serializer.WritePropertyWithDefault(204, "filters", filter_expr, unique_ptr<Expression>());
 	serializer.WriteProperty(205, "ignore_nulls", ignore_nulls);
 	serializer.WriteProperty(206, "start", start);
 	serializer.WriteProperty(207, "end", end);
-	serializer.WriteOptionalProperty(208, "start_expr", start_expr);
-	serializer.WriteOptionalProperty(209, "end_expr", end_expr);
-	serializer.WriteOptionalProperty(210, "offset_expr", offset_expr);
-	serializer.WriteOptionalProperty(211, "default_expr", default_expr);
+	serializer.WritePropertyWithDefault(208, "start_expr", start_expr, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(209, "end_expr", end_expr, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(210, "offset_expr", offset_expr, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(211, "default_expr", default_expr, unique_ptr<Expression>());
 }
 
 unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -198,14 +198,14 @@ unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializ
 	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
 	deserializer.ReadProperty(202, "partitions", result->partitions);
 	deserializer.ReadProperty(203, "orders", result->orders);
-	deserializer.ReadOptionalProperty(204, "filters", result->filter_expr);
+	deserializer.ReadPropertyWithDefault(204, "filters", result->filter_expr, unique_ptr<Expression>());
 	deserializer.ReadProperty(205, "ignore_nulls", result->ignore_nulls);
 	deserializer.ReadProperty(206, "start", result->start);
 	deserializer.ReadProperty(207, "end", result->end);
-	deserializer.ReadOptionalProperty(208, "start_expr", result->start_expr);
-	deserializer.ReadOptionalProperty(209, "end_expr", result->end_expr);
-	deserializer.ReadOptionalProperty(210, "offset_expr", result->offset_expr);
-	deserializer.ReadOptionalProperty(211, "default_expr", result->default_expr);
+	deserializer.ReadPropertyWithDefault(208, "start_expr", result->start_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithDefault(209, "end_expr", result->end_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithDefault(210, "offset_expr", result->offset_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithDefault(211, "default_expr", result->default_expr, unique_ptr<Expression>());
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -146,7 +146,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 
 		// format (de)serialization of expressions
 		try {
-			auto blob = BinarySerializer::Serialize(*expressions[expr_idx]);
+			auto blob = BinarySerializer::Serialize(*expressions[expr_idx], true);
 			bound_parameter_map_t parameters;
 			auto result = BinaryDeserializer::Deserialize<Expression>(context, parameters, blob.data(), blob.size());
 			result->Hash();

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

@@ -169,7 +169,7 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 
 	// format (de)serialization of this operator
 	try {
-		auto blob = BinarySerializer::Serialize(*op);
+		auto blob = BinarySerializer::Serialize(*op, true);
 		bound_parameter_map_t parameters;
 		auto result = BinaryDeserializer::Deserialize<LogicalOperator>(context, parameters, blob.data(), blob.size());
 	} catch (SerializationException &ex) {

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

@@ -34,7 +34,7 @@
 
 namespace duckdb {
 
-void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables);
+void ReorderTableEntries(catalog_entry_vector_t &tables);
 
 SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager)
     : CheckpointWriter(db), partial_block_manager(block_manager, CheckpointType::FULL_CHECKPOINT) {
@@ -157,7 +157,7 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 	// write the schema data
 	schema.Serialize(GetMetadataWriter());
 	// then, we fetch the tables/views/sequences information
-	vector<reference<TableCatalogEntry>> tables;
+	catalog_entry_vector_t tables;
 	vector<reference<ViewCatalogEntry>> views;
 	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
 		if (entry.internal) {
@@ -235,7 +235,8 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 	// reorder tables because of foreign key constraint
 	ReorderTableEntries(tables);
 	// Write the tables
-	for (auto &table : tables) {
+	for (auto &entry : tables) {
+		auto &table = entry.get().Cast<TableCatalogEntry>();
 		WriteTable(table);
 	}
 	// Write the views

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

@@ -37,7 +37,7 @@ unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deseria
 
 void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
 	Constraint::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "expression", *expression);
+	serializer.WriteProperty(200, "expression", expression);
 }
 
 unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {

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

@@ -102,7 +102,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &de
 void CreateMacroInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "name", name);
-	serializer.WriteProperty(201, "function", *function);
+	serializer.WriteProperty(201, "function", function);
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -149,7 +149,7 @@ void CreateTableInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(200, "table", table);
 	serializer.WriteProperty(201, "columns", columns);
 	serializer.WriteProperty(202, "constraints", constraints);
-	serializer.WriteOptionalProperty(203, "query", query);
+	serializer.WritePropertyWithDefault(203, "query", query, unique_ptr<SelectStatement>());
 }
 
 unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -157,7 +157,7 @@ unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &de
 	deserializer.ReadProperty(200, "table", result->table);
 	deserializer.ReadProperty(201, "columns", result->columns);
 	deserializer.ReadProperty(202, "constraints", result->constraints);
-	deserializer.ReadOptionalProperty(203, "query", result->query);
+	deserializer.ReadPropertyWithDefault(203, "query", result->query, unique_ptr<SelectStatement>());
 	return std::move(result);
 }
 
@@ -179,7 +179,7 @@ void CreateViewInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(200, "view_name", view_name);
 	serializer.WriteProperty(201, "aliases", aliases);
 	serializer.WriteProperty(202, "types", types);
-	serializer.WriteOptionalProperty(203, "query", query);
+	serializer.WritePropertyWithDefault(203, "query", query, unique_ptr<SelectStatement>());
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -187,7 +187,7 @@ unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &des
 	deserializer.ReadProperty(200, "view_name", result->view_name);
 	deserializer.ReadProperty(201, "aliases", result->aliases);
 	deserializer.ReadProperty(202, "types", result->types);
-	deserializer.ReadOptionalProperty(203, "query", result->query);
+	deserializer.ReadPropertyWithDefault(203, "query", result->query, unique_ptr<SelectStatement>());
 	return std::move(result);
 }
 

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

@@ -83,9 +83,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 
 void BoundBetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "input", *input);
-	serializer.WriteProperty(201, "lower", *lower);
-	serializer.WriteProperty(202, "upper", *upper);
+	serializer.WriteProperty(200, "input", input);
+	serializer.WriteProperty(201, "lower", lower);
+	serializer.WriteProperty(202, "upper", upper);
 	serializer.WriteProperty(203, "lower_inclusive", lower_inclusive);
 	serializer.WriteProperty(204, "upper_inclusive", upper_inclusive);
 }
@@ -104,7 +104,7 @@ void BoundCaseExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "case_checks", case_checks);
-	serializer.WriteProperty(202, "else_expr", *else_expr);
+	serializer.WriteProperty(202, "else_expr", else_expr);
 }
 
 unique_ptr<Expression> BoundCaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -117,7 +117,7 @@ unique_ptr<Expression> BoundCaseExpression::FormatDeserialize(FormatDeserializer
 
 void BoundCastExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "child", *child);
+	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "return_type", return_type);
 	serializer.WriteProperty(202, "try_cast", try_cast);
 }
@@ -147,8 +147,8 @@ unique_ptr<Expression> BoundColumnRefExpression::FormatDeserialize(FormatDeseria
 
 void BoundComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "left", *left);
-	serializer.WriteProperty(201, "right", *right);
+	serializer.WriteProperty(200, "left", left);
+	serializer.WriteProperty(201, "right", right);
 }
 
 unique_ptr<Expression> BoundComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -194,7 +194,7 @@ unique_ptr<Expression> BoundDefaultExpression::FormatDeserialize(FormatDeseriali
 void BoundLambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
-	serializer.WriteProperty(201, "lambda_expr", *lambda_expr);
+	serializer.WriteProperty(201, "lambda_expr", lambda_expr);
 	serializer.WriteProperty(202, "captures", captures);
 	serializer.WriteProperty(203, "parameter_count", parameter_count);
 }
@@ -243,7 +243,7 @@ void BoundParameterExpression::FormatSerialize(FormatSerializer &serializer) con
 	Expression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "identifier", identifier);
 	serializer.WriteProperty(201, "return_type", return_type);
-	serializer.WriteProperty(202, "parameter_data", *parameter_data);
+	serializer.WriteProperty(202, "parameter_data", parameter_data);
 }
 
 unique_ptr<Expression> BoundParameterExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -270,7 +270,7 @@ unique_ptr<Expression> BoundReferenceExpression::FormatDeserialize(FormatDeseria
 void BoundUnnestExpression::FormatSerialize(FormatSerializer &serializer) const {
 	Expression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
-	serializer.WriteProperty(201, "child", *child);
+	serializer.WriteProperty(201, "child", child);
 }
 
 unique_ptr<Expression> BoundUnnestExpression::FormatDeserialize(FormatDeserializer &deserializer) {

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

@@ -218,7 +218,7 @@ void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(201, "mark_index", mark_index);
 	serializer.WriteProperty(202, "left_projection_map", left_projection_map);
 	serializer.WriteProperty(203, "right_projection_map", right_projection_map);
-	serializer.WriteProperty(204, "condition", *condition);
+	serializer.WriteProperty(204, "condition", condition);
 }
 
 unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -254,7 +254,7 @@ void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "chunk_types", chunk_types);
-	serializer.WriteProperty(202, "collection", *collection);
+	serializer.WriteProperty(202, "collection", collection);
 }
 
 unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -290,7 +290,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeser
 
 void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "info", *info);
+	serializer.WriteProperty(200, "info", info);
 }
 
 unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -301,7 +301,7 @@ unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer
 
 void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "info", *info);
+	serializer.WriteProperty(200, "info", info);
 	serializer.WriteProperty(201, "unbound_expressions", unbound_expressions);
 }
 
@@ -316,7 +316,7 @@ void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "catalog", schema.ParentCatalog().GetName());
 	serializer.WriteProperty(201, "schema", schema.name);
-	serializer.WriteProperty(202, "info", *info->base);
+	serializer.WriteProperty(202, "info", info->base);
 }
 
 unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -374,14 +374,14 @@ void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "distinct_type", distinct_type);
 	serializer.WriteProperty(201, "distinct_targets", distinct_targets);
-	serializer.WriteOptionalProperty(202, "order_by", order_by);
+	serializer.WritePropertyWithDefault(202, "order_by", order_by, unique_ptr<BoundOrderModifier>());
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
 	auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "distinct_targets");
 	auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
-	deserializer.ReadOptionalProperty(202, "order_by", result->order_by);
+	deserializer.ReadPropertyWithDefault(202, "order_by", result->order_by, unique_ptr<BoundOrderModifier>());
 	return std::move(result);
 }
 
@@ -468,8 +468,8 @@ void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(209, "action_type", action_type);
 	serializer.WriteProperty(210, "expected_set_types", expected_set_types);
 	serializer.WriteProperty(211, "on_conflict_filter", on_conflict_filter);
-	serializer.WriteOptionalProperty(212, "on_conflict_condition", on_conflict_condition);
-	serializer.WriteOptionalProperty(213, "do_update_condition", do_update_condition);
+	serializer.WritePropertyWithDefault(212, "on_conflict_condition", on_conflict_condition, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(213, "do_update_condition", do_update_condition, unique_ptr<Expression>());
 	serializer.WriteProperty(214, "set_columns", set_columns);
 	serializer.WriteProperty(215, "set_types", set_types);
 	serializer.WriteProperty(216, "excluded_table_index", excluded_table_index);
@@ -491,8 +491,8 @@ unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer
 	deserializer.ReadProperty(209, "action_type", result->action_type);
 	deserializer.ReadProperty(210, "expected_set_types", result->expected_set_types);
 	deserializer.ReadProperty(211, "on_conflict_filter", result->on_conflict_filter);
-	deserializer.ReadOptionalProperty(212, "on_conflict_condition", result->on_conflict_condition);
-	deserializer.ReadOptionalProperty(213, "do_update_condition", result->do_update_condition);
+	deserializer.ReadPropertyWithDefault(212, "on_conflict_condition", result->on_conflict_condition, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithDefault(213, "do_update_condition", result->do_update_condition, unique_ptr<Expression>());
 	deserializer.ReadProperty(214, "set_columns", result->set_columns);
 	deserializer.ReadProperty(215, "set_types", result->set_types);
 	deserializer.ReadProperty(216, "excluded_table_index", result->excluded_table_index);
@@ -505,15 +505,15 @@ void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "limit_val", limit_val);
 	serializer.WriteProperty(201, "offset_val", offset_val);
-	serializer.WriteOptionalProperty(202, "limit", limit);
-	serializer.WriteOptionalProperty(203, "offset", offset);
+	serializer.WritePropertyWithDefault(202, "limit", limit, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(203, "offset", offset, unique_ptr<Expression>());
 }
 
 unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto limit_val = deserializer.ReadProperty<int64_t>(200, "limit_val");
 	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
-	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
-	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
+	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit", unique_ptr<Expression>());
+	auto offset = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(203, "offset", unique_ptr<Expression>());
 	auto result = duckdb::unique_ptr<LogicalLimit>(new LogicalLimit(limit_val, offset_val, std::move(limit), std::move(offset)));
 	return std::move(result);
 }
@@ -522,15 +522,15 @@ void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "limit_percent", limit_percent);
 	serializer.WriteProperty(201, "offset_val", offset_val);
-	serializer.WriteOptionalProperty(202, "limit", limit);
-	serializer.WriteOptionalProperty(203, "offset", offset);
+	serializer.WritePropertyWithDefault(202, "limit", limit, unique_ptr<Expression>());
+	serializer.WritePropertyWithDefault(203, "offset", offset, unique_ptr<Expression>());
 }
 
 unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
 	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
-	auto limit = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(202, "limit");
-	auto offset = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(203, "offset");
+	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit", unique_ptr<Expression>());
+	auto offset = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(203, "offset", unique_ptr<Expression>());
 	auto result = duckdb::unique_ptr<LogicalLimitPercent>(new LogicalLimitPercent(limit_percent, offset_val, std::move(limit), std::move(offset)));
 	return std::move(result);
 }
@@ -682,7 +682,7 @@ unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &d
 
 void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "info", *info);
+	serializer.WriteProperty(200, "info", info);
 }
 
 unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {

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

@@ -39,7 +39,7 @@ unique_ptr<MacroFunction> MacroFunction::FormatDeserialize(FormatDeserializer &d
 
 void ScalarMacroFunction::FormatSerialize(FormatSerializer &serializer) const {
 	MacroFunction::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "expression", *expression);
+	serializer.WriteProperty(200, "expression", expression);
 }
 
 unique_ptr<MacroFunction> ScalarMacroFunction::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -50,7 +50,7 @@ unique_ptr<MacroFunction> ScalarMacroFunction::FormatDeserialize(FormatDeseriali
 
 void TableMacroFunction::FormatSerialize(FormatSerializer &serializer) const {
 	MacroFunction::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "query_node", *query_node);
+	serializer.WriteProperty(200, "query_node", query_node);
 }
 
 unique_ptr<MacroFunction> TableMacroFunction::FormatDeserialize(FormatDeserializer &deserializer) {