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

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

@@ -25,15 +25,16 @@
 #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/persistent/csv_reader_options.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/function/table/read_csv.hpp"
+#include "duckdb/common/types/interval.hpp"
 
 namespace duckdb {
 
 void BoundCaseCheck::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty(100, "when_expr", *when_expr);
-	serializer.WriteProperty(101, "then_expr", *then_expr);
+	serializer.WriteProperty(100, "when_expr", when_expr);
+	serializer.WriteProperty(101, "then_expr", then_expr);
 }
 
 BoundCaseCheck BoundCaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -46,7 +47,7 @@ BoundCaseCheck BoundCaseCheck::FormatDeserialize(FormatDeserializer &deserialize
 void BoundOrderByNode::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "null_order", null_order);
-	serializer.WriteProperty(102, "expression", *expression);
+	serializer.WriteProperty(102, "expression", expression);
 }
 
 BoundOrderByNode BoundOrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -85,89 +86,89 @@ BoundPivotInfo BoundPivotInfo::FormatDeserialize(FormatDeserializer &deserialize
 	return result;
 }
 
-void BufferedCSVReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
+void CSVReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "has_delimiter", has_delimiter);
-	serializer.WriteProperty(101, "delimiter", delimiter);
-	serializer.WriteProperty(102, "has_quote", has_quote);
-	serializer.WriteProperty(103, "quote", quote);
-	serializer.WriteProperty(104, "has_escape", has_escape);
-	serializer.WriteProperty(105, "escape", escape);
-	serializer.WriteProperty(106, "has_header", has_header);
-	serializer.WriteProperty(107, "header", header);
-	serializer.WriteProperty(108, "ignore_errors", ignore_errors);
-	serializer.WriteProperty(109, "num_cols", num_cols);
-	serializer.WriteProperty(110, "buffer_sample_size", buffer_sample_size);
-	serializer.WriteProperty(111, "null_str", null_str);
-	serializer.WriteProperty(112, "compression", compression);
-	serializer.WriteProperty(113, "new_line", new_line);
-	serializer.WriteProperty(114, "allow_quoted_nulls", allow_quoted_nulls);
-	serializer.WriteProperty(115, "skip_rows", skip_rows);
-	serializer.WriteProperty(116, "skip_rows_set", skip_rows_set);
-	serializer.WriteProperty(117, "maximum_line_size", maximum_line_size);
-	serializer.WriteProperty(118, "normalize_names", normalize_names);
-	serializer.WriteProperty(119, "force_not_null", force_not_null);
-	serializer.WriteProperty(120, "all_varchar", all_varchar);
-	serializer.WriteProperty(121, "sample_chunk_size", sample_chunk_size);
-	serializer.WriteProperty(122, "sample_chunks", sample_chunks);
-	serializer.WriteProperty(123, "auto_detect", auto_detect);
-	serializer.WriteProperty(124, "file_path", file_path);
-	serializer.WriteProperty(125, "decimal_separator", decimal_separator);
-	serializer.WriteProperty(126, "null_padding", null_padding);
-	serializer.WriteProperty(127, "buffer_size", buffer_size);
-	serializer.WriteProperty(128, "file_options", file_options);
-	serializer.WriteProperty(129, "force_quote", force_quote);
-	serializer.WriteProperty(130, "date_format", date_format);
-	serializer.WriteProperty(131, "has_format", has_format);
-	serializer.WriteProperty(132, "rejects_table_name", rejects_table_name);
-	serializer.WriteProperty(133, "rejects_limit", rejects_limit);
-	serializer.WriteProperty(134, "rejects_recovery_columns", rejects_recovery_columns);
-	serializer.WriteProperty(135, "rejects_recovery_column_ids", rejects_recovery_column_ids);
-}
-
-BufferedCSVReaderOptions BufferedCSVReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
-	BufferedCSVReaderOptions result;
+	serializer.WriteProperty(101, "has_quote", has_quote);
+	serializer.WriteProperty(102, "has_escape", has_escape);
+	serializer.WriteProperty(103, "has_header", has_header);
+	serializer.WriteProperty(104, "ignore_errors", ignore_errors);
+	serializer.WriteProperty(105, "buffer_sample_size", buffer_sample_size);
+	serializer.WriteProperty(106, "null_str", null_str);
+	serializer.WriteProperty(107, "compression", compression);
+	serializer.WriteProperty(108, "allow_quoted_nulls", allow_quoted_nulls);
+	serializer.WriteProperty(109, "skip_rows_set", skip_rows_set);
+	serializer.WriteProperty(110, "maximum_line_size", maximum_line_size);
+	serializer.WriteProperty(111, "normalize_names", normalize_names);
+	serializer.WriteProperty(112, "force_not_null", force_not_null);
+	serializer.WriteProperty(113, "all_varchar", all_varchar);
+	serializer.WriteProperty(114, "sample_chunk_size", sample_chunk_size);
+	serializer.WriteProperty(115, "sample_chunks", sample_chunks);
+	serializer.WriteProperty(116, "auto_detect", auto_detect);
+	serializer.WriteProperty(117, "file_path", file_path);
+	serializer.WriteProperty(118, "decimal_separator", decimal_separator);
+	serializer.WriteProperty(119, "null_padding", null_padding);
+	serializer.WriteProperty(120, "buffer_size", buffer_size);
+	serializer.WriteProperty(121, "file_options", file_options);
+	serializer.WriteProperty(122, "force_quote", force_quote);
+	serializer.WriteProperty(123, "rejects_table_name", rejects_table_name);
+	serializer.WriteProperty(124, "rejects_limit", rejects_limit);
+	serializer.WriteProperty(125, "rejects_recovery_columns", rejects_recovery_columns);
+	serializer.WriteProperty(126, "rejects_recovery_column_ids", rejects_recovery_column_ids);
+	serializer.WriteProperty(127, "dialect_options.state_machine_options.delimiter", dialect_options.state_machine_options.delimiter);
+	serializer.WriteProperty(128, "dialect_options.state_machine_options.quote", dialect_options.state_machine_options.quote);
+	serializer.WriteProperty(129, "dialect_options.state_machine_options.escape", dialect_options.state_machine_options.escape);
+	serializer.WriteProperty(130, "dialect_options.header", dialect_options.header);
+	serializer.WriteProperty(131, "dialect_options.num_cols", dialect_options.num_cols);
+	serializer.WriteProperty(132, "dialect_options.new_line", dialect_options.new_line);
+	serializer.WriteProperty(133, "dialect_options.skip_rows", dialect_options.skip_rows);
+	serializer.WriteProperty(134, "dialect_options.date_format", dialect_options.date_format);
+	serializer.WriteProperty(135, "dialect_options.has_format", dialect_options.has_format);
+}
+
+CSVReaderOptions CSVReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	CSVReaderOptions result;
 	deserializer.ReadProperty(100, "has_delimiter", result.has_delimiter);
-	deserializer.ReadProperty(101, "delimiter", result.delimiter);
-	deserializer.ReadProperty(102, "has_quote", result.has_quote);
-	deserializer.ReadProperty(103, "quote", result.quote);
-	deserializer.ReadProperty(104, "has_escape", result.has_escape);
-	deserializer.ReadProperty(105, "escape", result.escape);
-	deserializer.ReadProperty(106, "has_header", result.has_header);
-	deserializer.ReadProperty(107, "header", result.header);
-	deserializer.ReadProperty(108, "ignore_errors", result.ignore_errors);
-	deserializer.ReadProperty(109, "num_cols", result.num_cols);
-	deserializer.ReadProperty(110, "buffer_sample_size", result.buffer_sample_size);
-	deserializer.ReadProperty(111, "null_str", result.null_str);
-	deserializer.ReadProperty(112, "compression", result.compression);
-	deserializer.ReadProperty(113, "new_line", result.new_line);
-	deserializer.ReadProperty(114, "allow_quoted_nulls", result.allow_quoted_nulls);
-	deserializer.ReadProperty(115, "skip_rows", result.skip_rows);
-	deserializer.ReadProperty(116, "skip_rows_set", result.skip_rows_set);
-	deserializer.ReadProperty(117, "maximum_line_size", result.maximum_line_size);
-	deserializer.ReadProperty(118, "normalize_names", result.normalize_names);
-	deserializer.ReadProperty(119, "force_not_null", result.force_not_null);
-	deserializer.ReadProperty(120, "all_varchar", result.all_varchar);
-	deserializer.ReadProperty(121, "sample_chunk_size", result.sample_chunk_size);
-	deserializer.ReadProperty(122, "sample_chunks", result.sample_chunks);
-	deserializer.ReadProperty(123, "auto_detect", result.auto_detect);
-	deserializer.ReadProperty(124, "file_path", result.file_path);
-	deserializer.ReadProperty(125, "decimal_separator", result.decimal_separator);
-	deserializer.ReadProperty(126, "null_padding", result.null_padding);
-	deserializer.ReadProperty(127, "buffer_size", result.buffer_size);
-	deserializer.ReadProperty(128, "file_options", result.file_options);
-	deserializer.ReadProperty(129, "force_quote", result.force_quote);
-	deserializer.ReadProperty(130, "date_format", result.date_format);
-	deserializer.ReadProperty(131, "has_format", result.has_format);
-	deserializer.ReadProperty(132, "rejects_table_name", result.rejects_table_name);
-	deserializer.ReadProperty(133, "rejects_limit", result.rejects_limit);
-	deserializer.ReadProperty(134, "rejects_recovery_columns", result.rejects_recovery_columns);
-	deserializer.ReadProperty(135, "rejects_recovery_column_ids", result.rejects_recovery_column_ids);
+	deserializer.ReadProperty(101, "has_quote", result.has_quote);
+	deserializer.ReadProperty(102, "has_escape", result.has_escape);
+	deserializer.ReadProperty(103, "has_header", result.has_header);
+	deserializer.ReadProperty(104, "ignore_errors", result.ignore_errors);
+	deserializer.ReadProperty(105, "buffer_sample_size", result.buffer_sample_size);
+	deserializer.ReadProperty(106, "null_str", result.null_str);
+	deserializer.ReadProperty(107, "compression", result.compression);
+	deserializer.ReadProperty(108, "allow_quoted_nulls", result.allow_quoted_nulls);
+	deserializer.ReadProperty(109, "skip_rows_set", result.skip_rows_set);
+	deserializer.ReadProperty(110, "maximum_line_size", result.maximum_line_size);
+	deserializer.ReadProperty(111, "normalize_names", result.normalize_names);
+	deserializer.ReadProperty(112, "force_not_null", result.force_not_null);
+	deserializer.ReadProperty(113, "all_varchar", result.all_varchar);
+	deserializer.ReadProperty(114, "sample_chunk_size", result.sample_chunk_size);
+	deserializer.ReadProperty(115, "sample_chunks", result.sample_chunks);
+	deserializer.ReadProperty(116, "auto_detect", result.auto_detect);
+	deserializer.ReadProperty(117, "file_path", result.file_path);
+	deserializer.ReadProperty(118, "decimal_separator", result.decimal_separator);
+	deserializer.ReadProperty(119, "null_padding", result.null_padding);
+	deserializer.ReadProperty(120, "buffer_size", result.buffer_size);
+	deserializer.ReadProperty(121, "file_options", result.file_options);
+	deserializer.ReadProperty(122, "force_quote", result.force_quote);
+	deserializer.ReadProperty(123, "rejects_table_name", result.rejects_table_name);
+	deserializer.ReadProperty(124, "rejects_limit", result.rejects_limit);
+	deserializer.ReadProperty(125, "rejects_recovery_columns", result.rejects_recovery_columns);
+	deserializer.ReadProperty(126, "rejects_recovery_column_ids", result.rejects_recovery_column_ids);
+	deserializer.ReadProperty(127, "dialect_options.state_machine_options.delimiter", result.dialect_options.state_machine_options.delimiter);
+	deserializer.ReadProperty(128, "dialect_options.state_machine_options.quote", result.dialect_options.state_machine_options.quote);
+	deserializer.ReadProperty(129, "dialect_options.state_machine_options.escape", result.dialect_options.state_machine_options.escape);
+	deserializer.ReadProperty(130, "dialect_options.header", result.dialect_options.header);
+	deserializer.ReadProperty(131, "dialect_options.num_cols", result.dialect_options.num_cols);
+	deserializer.ReadProperty(132, "dialect_options.new_line", result.dialect_options.new_line);
+	deserializer.ReadProperty(133, "dialect_options.skip_rows", result.dialect_options.skip_rows);
+	deserializer.ReadProperty(134, "dialect_options.date_format", result.dialect_options.date_format);
+	deserializer.ReadProperty(135, "dialect_options.has_format", result.dialect_options.has_format);
 	return result;
 }
 
 void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty(100, "when_expr", *when_expr);
-	serializer.WriteProperty(101, "then_expr", *then_expr);
+	serializer.WriteProperty(100, "when_expr", when_expr);
+	serializer.WriteProperty(101, "then_expr", then_expr);
 }
 
 CaseCheck CaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -192,7 +193,7 @@ ColumnBinding ColumnBinding::FormatDeserialize(FormatDeserializer &deserializer)
 void ColumnDefinition::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "name", name);
 	serializer.WriteProperty(101, "type", type);
-	serializer.WriteOptionalProperty(102, "expression", expression);
+	serializer.WritePropertyWithDefault(102, "expression", expression, unique_ptr<ParsedExpression>());
 	serializer.WriteProperty(103, "category", category);
 	serializer.WriteProperty(104, "compression_type", compression_type);
 }
@@ -200,7 +201,7 @@ void ColumnDefinition::FormatSerialize(FormatSerializer &serializer) const {
 ColumnDefinition ColumnDefinition::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto name = deserializer.ReadProperty<string>(100, "name");
 	auto type = deserializer.ReadProperty<LogicalType>(101, "type");
-	auto expression = deserializer.ReadOptionalProperty<unique_ptr<ParsedExpression>>(102, "expression");
+	auto expression = deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(102, "expression", unique_ptr<ParsedExpression>());
 	auto category = deserializer.ReadProperty<TableColumnType>(103, "category");
 	ColumnDefinition result(std::move(name), std::move(type), std::move(expression), category);
 	deserializer.ReadProperty(104, "compression_type", result.compression_type);
@@ -231,7 +232,7 @@ ColumnList ColumnList::FormatDeserialize(FormatDeserializer &deserializer) {
 
 void CommonTableExpressionInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "aliases", aliases);
-	serializer.WriteProperty(101, "query", *query);
+	serializer.WriteProperty(101, "query", query);
 	serializer.WriteProperty(102, "materialized", materialized);
 }
 
@@ -266,8 +267,8 @@ HivePartitioningIndex HivePartitioningIndex::FormatDeserialize(FormatDeserialize
 }
 
 void JoinCondition::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty(100, "left", *left);
-	serializer.WriteProperty(101, "right", *right);
+	serializer.WriteProperty(100, "left", left);
+	serializer.WriteProperty(101, "right", right);
 	serializer.WriteProperty(102, "comparison", comparison);
 }
 
@@ -281,12 +282,12 @@ JoinCondition JoinCondition::FormatDeserialize(FormatDeserializer &deserializer)
 
 void LogicalType::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "id", id_);
-	serializer.WriteOptionalProperty(101, "type_info", type_info_);
+	serializer.WritePropertyWithDefault(101, "type_info", type_info_, shared_ptr<ExtraTypeInfo>());
 }
 
 LogicalType LogicalType::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto id = deserializer.ReadProperty<LogicalTypeId>(100, "id");
-	auto type_info = deserializer.ReadOptionalProperty<shared_ptr<ExtraTypeInfo>>(101, "type_info");
+	auto type_info = deserializer.ReadPropertyWithDefault<shared_ptr<ExtraTypeInfo>>(101, "type_info", shared_ptr<ExtraTypeInfo>());
 	LogicalType result(id, std::move(type_info));
 	return result;
 }
@@ -326,7 +327,7 @@ MultiFileReaderOptions MultiFileReaderOptions::FormatDeserialize(FormatDeseriali
 void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "null_order", null_order);
-	serializer.WriteProperty(102, "expression", *expression);
+	serializer.WriteProperty(102, "expression", expression);
 }
 
 OrderByNode OrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -353,6 +354,20 @@ PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &deserializer) {
 	return result;
 }
 
+void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty(100, "values", values);
+	serializer.WritePropertyWithDefault(101, "star_expr", star_expr, unique_ptr<ParsedExpression>());
+	serializer.WriteProperty(102, "alias", alias);
+}
+
+PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &deserializer) {
+	PivotColumnEntry result;
+	deserializer.ReadProperty(100, "values", result.values);
+	deserializer.ReadPropertyWithDefault(101, "star_expr", result.star_expr, unique_ptr<ParsedExpression>());
+	deserializer.ReadProperty(102, "alias", result.alias);
+	return result;
+}
+
 void ReadCSVData::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "files", files);
 	serializer.WriteProperty(101, "csv_types", csv_types);
@@ -429,4 +444,18 @@ VacuumOptions VacuumOptions::FormatDeserialize(FormatDeserializer &deserializer)
 	return result;
 }
 
+void interval_t::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty(1, "months", months);
+	serializer.WriteProperty(2, "days", days);
+	serializer.WriteProperty(3, "micros", micros);
+}
+
+interval_t interval_t::FormatDeserialize(FormatDeserializer &deserializer) {
+	interval_t result;
+	deserializer.ReadProperty(1, "months", result.months);
+	deserializer.ReadProperty(2, "days", result.days);
+	deserializer.ReadProperty(3, "micros", result.micros);
+	return result;
+}
+
 } // namespace duckdb

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

@@ -209,7 +209,7 @@ void ChangeColumnTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	AlterTableInfo::FormatSerialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
 	serializer.WriteProperty(401, "target_type", target_type);
-	serializer.WriteProperty(402, "expression", *expression);
+	serializer.WriteProperty(402, "expression", expression);
 }
 
 unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -375,13 +375,13 @@ unique_ptr<AlterViewInfo> RenameViewInfo::FormatDeserialize(FormatDeserializer &
 void SetDefaultInfo::FormatSerialize(FormatSerializer &serializer) const {
 	AlterTableInfo::FormatSerialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
-	serializer.WriteOptionalProperty(401, "expression", expression);
+	serializer.WritePropertyWithDefault(401, "expression", expression, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<AlterTableInfo> SetDefaultInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SetDefaultInfo>(new SetDefaultInfo());
 	deserializer.ReadProperty(400, "column_name", result->column_name);
-	deserializer.ReadOptionalProperty(401, "expression", result->expression);
+	deserializer.ReadPropertyWithDefault(401, "expression", result->expression, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 

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

@@ -83,9 +83,9 @@ unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeseriali
 
 void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::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);
 }
 
 unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -99,7 +99,7 @@ unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(FormatDeserial
 void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "case_checks", case_checks);
-	serializer.WriteProperty(201, "else_expr", *else_expr);
+	serializer.WriteProperty(201, "else_expr", else_expr);
 }
 
 unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -111,7 +111,7 @@ unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(FormatDeserialize
 
 void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "child", *child);
+	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "cast_type", cast_type);
 	serializer.WriteProperty(202, "try_cast", try_cast);
 }
@@ -126,7 +126,7 @@ unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(FormatDeserialize
 
 void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "child", *child);
+	serializer.WriteProperty(200, "child", child);
 	serializer.WriteProperty(201, "collation", collation);
 }
 
@@ -150,8 +150,8 @@ unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(FormatDeseri
 
 void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "left", *left);
-	serializer.WriteProperty(201, "right", *right);
+	serializer.WriteProperty(200, "left", left);
+	serializer.WriteProperty(201, "right", right);
 }
 
 unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -197,8 +197,8 @@ void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(200, "function_name", function_name);
 	serializer.WriteProperty(201, "schema", schema);
 	serializer.WriteProperty(202, "children", children);
-	serializer.WriteOptionalProperty(203, "filter", filter);
-	serializer.WriteProperty(204, "order_bys", (ResultModifier &)*order_bys);
+	serializer.WritePropertyWithDefault(203, "filter", filter, unique_ptr<ParsedExpression>());
+	serializer.WriteProperty(204, "order_bys", (ResultModifier *)order_bys.get());
 	serializer.WriteProperty(205, "distinct", distinct);
 	serializer.WriteProperty(206, "is_operator", is_operator);
 	serializer.WriteProperty(207, "export_state", export_state);
@@ -210,7 +210,7 @@ unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeseria
 	deserializer.ReadProperty(200, "function_name", result->function_name);
 	deserializer.ReadProperty(201, "schema", result->schema);
 	deserializer.ReadProperty(202, "children", result->children);
-	deserializer.ReadOptionalProperty(203, "filter", result->filter);
+	deserializer.ReadPropertyWithDefault(203, "filter", result->filter, unique_ptr<ParsedExpression>());
 	auto order_bys = deserializer.ReadProperty<unique_ptr<ResultModifier>>(204, "order_bys");
 	result->order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(std::move(order_bys));
 	deserializer.ReadProperty(205, "distinct", result->distinct);
@@ -222,8 +222,8 @@ unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(FormatDeseria
 
 void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty(200, "lhs", *lhs);
-	serializer.WriteProperty(201, "expr", *expr);
+	serializer.WriteProperty(200, "lhs", lhs);
+	serializer.WriteProperty(201, "expr", expr);
 }
 
 unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -272,7 +272,7 @@ void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(201, "exclude_list", exclude_list);
 	serializer.WriteProperty(202, "replace_list", replace_list);
 	serializer.WriteProperty(203, "columns", columns);
-	serializer.WriteOptionalProperty(204, "expr", expr);
+	serializer.WritePropertyWithDefault(204, "expr", expr, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -281,7 +281,7 @@ unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(FormatDeserialize
 	deserializer.ReadProperty(201, "exclude_list", result->exclude_list);
 	deserializer.ReadProperty(202, "replace_list", result->replace_list);
 	deserializer.ReadProperty(203, "columns", result->columns);
-	deserializer.ReadOptionalProperty(204, "expr", result->expr);
+	deserializer.ReadPropertyWithDefault(204, "expr", result->expr, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
@@ -289,7 +289,7 @@ void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
 	ParsedExpression::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "subquery_type", subquery_type);
 	serializer.WriteProperty(201, "subquery", subquery);
-	serializer.WriteOptionalProperty(202, "child", child);
+	serializer.WritePropertyWithDefault(202, "child", child, unique_ptr<ParsedExpression>());
 	serializer.WriteProperty(203, "comparison_type", comparison_type);
 }
 
@@ -297,7 +297,7 @@ unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(FormatDeseria
 	auto result = duckdb::unique_ptr<SubqueryExpression>(new SubqueryExpression());
 	deserializer.ReadProperty(200, "subquery_type", result->subquery_type);
 	deserializer.ReadProperty(201, "subquery", result->subquery);
-	deserializer.ReadOptionalProperty(202, "child", result->child);
+	deserializer.ReadPropertyWithDefault(202, "child", result->child, unique_ptr<ParsedExpression>());
 	deserializer.ReadProperty(203, "comparison_type", result->comparison_type);
 	return std::move(result);
 }
@@ -312,12 +312,12 @@ void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(205, "orders", orders);
 	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<ParsedExpression>());
+	serializer.WritePropertyWithDefault(209, "end_expr", end_expr, unique_ptr<ParsedExpression>());
+	serializer.WritePropertyWithDefault(210, "offset_expr", offset_expr, unique_ptr<ParsedExpression>());
+	serializer.WritePropertyWithDefault(211, "default_expr", default_expr, unique_ptr<ParsedExpression>());
 	serializer.WriteProperty(212, "ignore_nulls", ignore_nulls);
-	serializer.WriteOptionalProperty(213, "filter_expr", filter_expr);
+	serializer.WritePropertyWithDefault(213, "filter_expr", filter_expr, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -330,12 +330,12 @@ unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(FormatDeseriali
 	deserializer.ReadProperty(205, "orders", result->orders);
 	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<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(209, "end_expr", result->end_expr, unique_ptr<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(210, "offset_expr", result->offset_expr, unique_ptr<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(211, "default_expr", result->default_expr, unique_ptr<ParsedExpression>());
 	deserializer.ReadProperty(212, "ignore_nulls", result->ignore_nulls);
-	deserializer.ReadOptionalProperty(213, "filter_expr", result->filter_expr);
+	deserializer.ReadPropertyWithDefault(213, "filter_expr", result->filter_expr, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 

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

@@ -44,8 +44,8 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 void CTENode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "cte_name", ctename);
-	serializer.WriteProperty(201, "query", *query);
-	serializer.WriteProperty(202, "child", *child);
+	serializer.WriteProperty(201, "query", query);
+	serializer.WriteProperty(202, "child", child);
 	serializer.WriteProperty(203, "aliases", aliases);
 }
 
@@ -62,8 +62,8 @@ void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "cte_name", ctename);
 	serializer.WriteProperty(201, "union_all", union_all);
-	serializer.WriteProperty(202, "left", *left);
-	serializer.WriteProperty(203, "right", *right);
+	serializer.WriteProperty(202, "left", left);
+	serializer.WriteProperty(203, "right", right);
 	serializer.WriteProperty(204, "aliases", aliases);
 }
 
@@ -80,35 +80,35 @@ unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &de
 void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "select_list", select_list);
-	serializer.WriteOptionalProperty(201, "from_table", from_table);
-	serializer.WriteOptionalProperty(202, "where_clause", where_clause);
+	serializer.WritePropertyWithDefault(201, "from_table", from_table, unique_ptr<TableRef>());
+	serializer.WritePropertyWithDefault(202, "where_clause", where_clause, unique_ptr<ParsedExpression>());
 	serializer.WriteProperty(203, "group_expressions", groups.group_expressions);
 	serializer.WriteProperty(204, "group_sets", groups.grouping_sets);
 	serializer.WriteProperty(205, "aggregate_handling", aggregate_handling);
-	serializer.WriteOptionalProperty(206, "having", having);
-	serializer.WriteOptionalProperty(207, "sample", sample);
-	serializer.WriteOptionalProperty(208, "qualify", qualify);
+	serializer.WritePropertyWithDefault(206, "having", having, unique_ptr<ParsedExpression>());
+	serializer.WritePropertyWithDefault(207, "sample", sample, unique_ptr<SampleOptions>());
+	serializer.WritePropertyWithDefault(208, "qualify", qualify, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SelectNode>(new SelectNode());
 	deserializer.ReadProperty(200, "select_list", result->select_list);
-	deserializer.ReadOptionalProperty(201, "from_table", result->from_table);
-	deserializer.ReadOptionalProperty(202, "where_clause", result->where_clause);
+	deserializer.ReadPropertyWithDefault(201, "from_table", result->from_table, unique_ptr<TableRef>());
+	deserializer.ReadPropertyWithDefault(202, "where_clause", result->where_clause, unique_ptr<ParsedExpression>());
 	deserializer.ReadProperty(203, "group_expressions", result->groups.group_expressions);
 	deserializer.ReadProperty(204, "group_sets", result->groups.grouping_sets);
 	deserializer.ReadProperty(205, "aggregate_handling", result->aggregate_handling);
-	deserializer.ReadOptionalProperty(206, "having", result->having);
-	deserializer.ReadOptionalProperty(207, "sample", result->sample);
-	deserializer.ReadOptionalProperty(208, "qualify", result->qualify);
+	deserializer.ReadPropertyWithDefault(206, "having", result->having, unique_ptr<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(207, "sample", result->sample, unique_ptr<SampleOptions>());
+	deserializer.ReadPropertyWithDefault(208, "qualify", result->qualify, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
 void SetOperationNode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "setop_type", setop_type);
-	serializer.WriteProperty(201, "left", *left);
-	serializer.WriteProperty(202, "right", *right);
+	serializer.WriteProperty(201, "left", left);
+	serializer.WriteProperty(202, "right", right);
 }
 
 unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &deserializer) {

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

@@ -59,27 +59,27 @@ unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserialize
 
 void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty(200, "limit", limit);
-	serializer.WriteOptionalProperty(201, "offset", offset);
+	serializer.WritePropertyWithDefault(200, "limit", limit, unique_ptr<ParsedExpression>());
+	serializer.WritePropertyWithDefault(201, "offset", offset, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
-	deserializer.ReadOptionalProperty(200, "limit", result->limit);
-	deserializer.ReadOptionalProperty(201, "offset", result->offset);
+	deserializer.ReadPropertyWithDefault(200, "limit", result->limit, unique_ptr<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(201, "offset", result->offset, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
 void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty(200, "limit", limit);
-	serializer.WriteOptionalProperty(201, "offset", offset);
+	serializer.WritePropertyWithDefault(200, "limit", limit, unique_ptr<ParsedExpression>());
+	serializer.WritePropertyWithDefault(201, "offset", offset, unique_ptr<ParsedExpression>());
 }
 
 unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LimitPercentModifier>(new LimitPercentModifier());
-	deserializer.ReadOptionalProperty(200, "limit", result->limit);
-	deserializer.ReadOptionalProperty(201, "offset", result->offset);
+	deserializer.ReadPropertyWithDefault(200, "limit", result->limit, unique_ptr<ParsedExpression>());
+	deserializer.ReadPropertyWithDefault(201, "offset", result->offset, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 

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

@@ -10,7 +10,7 @@
 namespace duckdb {
 
 void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty(100, "node", *node);
+	serializer.WriteProperty(100, "node", node);
 }
 
 unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {