duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp

@@ -10,9 +10,9 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
                                          string entry_name_p, string owner_schema_p, string owner_name_p,
-                                         bool if_exists)
+                                         OnEntryNotFound if_not_found)
     : AlterInfo(AlterType::CHANGE_OWNERSHIP, std::move(entry_catalog_p), std::move(entry_schema_p),
-                std::move(entry_name_p), if_exists),
+                std::move(entry_name_p), if_not_found),
       entry_catalog_type(entry_catalog_type), owner_schema(std::move(owner_schema_p)),
       owner_name(std::move(owner_name_p)) {
 }
@@ -22,8 +22,8 @@ CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 }
 
 unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, catalog, schema, name, owner_schema,
-	                                                        owner_name, if_exists);
+	return make_uniq_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, catalog, schema, name, owner_schema,
+	                                                      owner_name, if_not_found);
 }
 
 void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
@@ -35,7 +35,7 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_table_type(type) {
 }
 AlterTableInfo::~AlterTableInfo() {
@@ -50,7 +50,7 @@ void AlterTableInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 	SerializeAlterTable(writer);
 }
 
@@ -60,7 +60,7 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 	data.catalog = reader.ReadRequired<string>();
 	data.schema = reader.ReadRequired<string>();
 	data.name = reader.ReadRequired<string>();
-	data.if_exists = reader.ReadRequired<bool>();
+	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
 
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
@@ -98,7 +98,7 @@ RenameColumnInfo::~RenameColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
+	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
 }
 
 void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -109,7 +109,7 @@ void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto old_name = reader.ReadRequired<string>();
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameColumnInfo>(std::move(data), old_name, new_name);
+	return make_uniq<RenameColumnInfo>(std::move(data), old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
@@ -122,7 +122,7 @@ RenameTableInfo::~RenameTableInfo() {
 }
 
 unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
+	return make_uniq_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
 }
 
 void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -131,7 +131,7 @@ void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameTableInfo>(std::move(data), new_name);
+	return make_uniq<RenameTableInfo>(std::move(data), new_name);
 }
 
 //===--------------------------------------------------------------------===//
@@ -146,7 +146,7 @@ AddColumnInfo::~AddColumnInfo() {
 }
 
 unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
+	return make_uniq_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
 }
 
 void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -157,7 +157,7 @@ void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
 	auto if_column_not_exists = reader.ReadRequired<bool>();
-	return make_unique<AddColumnInfo>(std::move(data), std::move(new_column), if_column_not_exists);
+	return make_uniq<AddColumnInfo>(std::move(data), std::move(new_column), if_column_not_exists);
 }
 
 //===--------------------------------------------------------------------===//
@@ -171,8 +171,7 @@ RemoveColumnInfo::~RemoveColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists,
-	                                                     cascade);
+	return make_uniq_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists, cascade);
 }
 
 void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -185,7 +184,7 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEn
 	auto new_name = reader.ReadRequired<string>();
 	auto if_column_exists = reader.ReadRequired<bool>();
 	auto cascade = reader.ReadRequired<bool>();
-	return make_unique<RemoveColumnInfo>(std::move(data), std::move(new_name), if_column_exists, cascade);
+	return make_uniq<RemoveColumnInfo>(std::move(data), std::move(new_name), if_column_exists, cascade);
 }
 
 //===--------------------------------------------------------------------===//
@@ -200,8 +199,8 @@ ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
 }
 
 unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(GetAlterEntryData(), column_name, target_type,
-	                                                         expression->Copy());
+	return make_uniq_base<AlterInfo, ChangeColumnTypeInfo>(GetAlterEntryData(), column_name, target_type,
+	                                                       expression->Copy());
 }
 
 void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -214,8 +213,8 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, Alt
 	auto column_name = reader.ReadRequired<string>();
 	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<ChangeColumnTypeInfo>(std::move(data), std::move(column_name), std::move(target_type),
-	                                         std::move(expression));
+	return make_uniq<ChangeColumnTypeInfo>(std::move(data), std::move(column_name), std::move(target_type),
+	                                       std::move(expression));
 }
 
 //===--------------------------------------------------------------------===//
@@ -229,8 +228,8 @@ SetDefaultInfo::~SetDefaultInfo() {
 }
 
 unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetDefaultInfo>(GetAlterEntryData(), column_name,
-	                                                   expression ? expression->Copy() : nullptr);
+	return make_uniq_base<AlterInfo, SetDefaultInfo>(GetAlterEntryData(), column_name,
+	                                                 expression ? expression->Copy() : nullptr);
 }
 
 void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -241,7 +240,7 @@ void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
 unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
 	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<SetDefaultInfo>(std::move(data), std::move(column_name), std::move(new_default));
+	return make_uniq<SetDefaultInfo>(std::move(data), std::move(column_name), std::move(new_default));
 }
 
 //===--------------------------------------------------------------------===//
@@ -254,7 +253,7 @@ SetNotNullInfo::~SetNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
+	return make_uniq_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
 void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -263,7 +262,7 @@ void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<SetNotNullInfo>(std::move(data), std::move(column_name));
+	return make_uniq<SetNotNullInfo>(std::move(data), std::move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
@@ -276,7 +275,7 @@ DropNotNullInfo::~DropNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
+	return make_uniq_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
 void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -285,7 +284,7 @@ void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<DropNotNullInfo>(std::move(data), std::move(column_name));
+	return make_uniq<DropNotNullInfo>(std::move(data), std::move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
@@ -302,8 +301,8 @@ AlterForeignKeyInfo::~AlterForeignKeyInfo() {
 }
 
 unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
-	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(GetAlterEntryData(), fk_table, pk_columns, fk_columns,
-	                                                        pk_keys, fk_keys, type);
+	return make_uniq_base<AlterInfo, AlterForeignKeyInfo>(GetAlterEntryData(), fk_table, pk_columns, fk_columns,
+	                                                      pk_keys, fk_keys, type);
 }
 
 void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -322,8 +321,8 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 	auto pk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto fk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto type = reader.ReadRequired<AlterForeignKeyType>();
-	return make_unique<AlterForeignKeyInfo>(std::move(data), std::move(fk_table), std::move(pk_columns),
-	                                        std::move(fk_columns), std::move(pk_keys), std::move(fk_keys), type);
+	return make_uniq<AlterForeignKeyInfo>(std::move(data), std::move(fk_table), std::move(pk_columns),
+	                                      std::move(fk_columns), std::move(pk_keys), std::move(fk_keys), type);
 }
 
 //===--------------------------------------------------------------------===//
@@ -331,7 +330,7 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 //===--------------------------------------------------------------------===//
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_view_type(type) {
 }
 AlterViewInfo::~AlterViewInfo() {
@@ -346,7 +345,7 @@ void AlterViewInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField<bool>(if_exists);
+	writer.WriteField<OnEntryNotFound>(if_not_found);
 	SerializeAlterView(writer);
 }
 
@@ -356,7 +355,7 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 	data.catalog = reader.ReadRequired<string>();
 	data.schema = reader.ReadRequired<string>();
 	data.name = reader.ReadRequired<string>();
-	data.if_exists = reader.ReadRequired<bool>();
+	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:
@@ -376,7 +375,7 @@ RenameViewInfo::~RenameViewInfo() {
 }
 
 unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
+	return make_uniq_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
 }
 
 void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
@@ -385,6 +384,6 @@ void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameViewInfo>(std::move(data), new_name);
+	return make_uniq<RenameViewInfo>(std::move(data), new_name);
 }
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_aggregate_function_info.cpp

@@ -19,7 +19,7 @@ CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunctionSet se
 }
 
 unique_ptr<CreateInfo> CreateAggregateFunctionInfo::Copy() const {
-	auto result = make_unique<CreateAggregateFunctionInfo>(functions);
+	auto result = make_uniq<CreateAggregateFunctionInfo>(functions);
 	CopyProperties(*result);
 	return std::move(result);
 }

package/src/duckdb/src/parser/parsed_data/create_collation_info.cpp

@@ -15,7 +15,7 @@ void CreateCollationInfo::SerializeInternal(Serializer &) const {
 }
 
 unique_ptr<CreateInfo> CreateCollationInfo::Copy() const {
-	auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+	auto result = make_uniq<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
 	CopyProperties(*result);
 	return std::move(result);
 }

package/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp

@@ -13,7 +13,7 @@ void CreateCopyFunctionInfo::SerializeInternal(Serializer &) const {
 }
 
 unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
-	auto result = make_unique<CreateCopyFunctionInfo>(function);
+	auto result = make_uniq<CreateCopyFunctionInfo>(function);
 	CopyProperties(*result);
 	return std::move(result);
 }

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 
-	auto result = make_unique<CreateIndexInfo>();
+	auto result = make_uniq<CreateIndexInfo>();
 	CopyProperties(*result);
 
 	result->index_type = index_type;
@@ -45,7 +45,7 @@ void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
 
 unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer) {
 
-	auto result = make_unique<CreateIndexInfo>();
+	auto result = make_uniq<CreateIndexInfo>();
 	result->DeserializeBase(deserializer);
 
 	FieldReader reader(deserializer);

package/src/duckdb/src/parser/parsed_data/create_pragma_function_info.cpp

@@ -15,7 +15,7 @@ CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(string name, PragmaFunctionSe
 }
 
 unique_ptr<CreateInfo> CreatePragmaFunctionInfo::Copy() const {
-	auto result = make_unique<CreatePragmaFunctionInfo>(functions.name, functions);
+	auto result = make_uniq<CreatePragmaFunctionInfo>(functions.name, functions);
 	CopyProperties(*result);
 	return std::move(result);
 }

package/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp

@@ -21,14 +21,14 @@ CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
 unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
 	ScalarFunctionSet set(name);
 	set.functions = functions.functions;
-	auto result = make_unique<CreateScalarFunctionInfo>(std::move(set));
+	auto result = make_uniq<CreateScalarFunctionInfo>(std::move(set));
 	CopyProperties(*result);
 	return std::move(result);
 }
 
 unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {
-	return make_unique_base<AlterInfo, AddScalarFunctionOverloadInfo>(AlterEntryData(catalog, schema, name, true),
-	                                                                  functions);
+	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
+	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL), functions);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp

@@ -21,14 +21,14 @@ CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunctionSet set)
 unique_ptr<CreateInfo> CreateTableFunctionInfo::Copy() const {
 	TableFunctionSet set(name);
 	set.functions = functions.functions;
-	auto result = make_unique<CreateTableFunctionInfo>(std::move(set));
+	auto result = make_uniq<CreateTableFunctionInfo>(std::move(set));
 	CopyProperties(*result);
 	return std::move(result);
 }
 
 unique_ptr<AlterInfo> CreateTableFunctionInfo::GetAlterInfo() const {
-	return make_unique_base<AlterInfo, AddTableFunctionOverloadInfo>(AlterEntryData(catalog, schema, name, true),
-	                                                                 functions);
+	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(
+	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL), functions);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_info.cpp

@@ -12,8 +12,8 @@ CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_
     : CreateInfo(CatalogType::TABLE_ENTRY, std::move(schema_p), std::move(catalog_p)), table(std::move(name_p)) {
 }
 
-CreateTableInfo::CreateTableInfo(SchemaCatalogEntry *schema, string name_p)
-    : CreateTableInfo(schema->catalog->GetName(), schema->name, std::move(name_p)) {
+CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
+    : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
 void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
@@ -26,7 +26,7 @@ void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
 }
 
 unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_unique<CreateTableInfo>();
+	auto result = make_uniq<CreateTableInfo>();
 	result->DeserializeBase(deserializer);
 
 	FieldReader reader(deserializer);
@@ -40,7 +40,7 @@ unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deseriali
 }
 
 unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
-	auto result = make_unique<CreateTableInfo>(catalog, schema, table);
+	auto result = make_uniq<CreateTableInfo>(catalog, schema, table);
 	CopyProperties(*result);
 	result->columns = columns.Copy();
 	for (auto &constraint : constraints) {

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -15,12 +15,12 @@ CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_na
       view_name(std::move(view_name_p)) {
 }
 
-CreateViewInfo::CreateViewInfo(SchemaCatalogEntry *schema, string view_name)
-    : CreateViewInfo(schema->catalog->GetName(), schema->name, std::move(view_name)) {
+CreateViewInfo::CreateViewInfo(SchemaCatalogEntry &schema, string view_name)
+    : CreateViewInfo(schema.catalog.GetName(), schema.name, std::move(view_name)) {
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
-	auto result = make_unique<CreateViewInfo>(catalog, schema, view_name);
+	auto result = make_uniq<CreateViewInfo>(catalog, schema, view_name);
 	CopyProperties(*result);
 	result->aliases = aliases;
 	result->types = types;
@@ -29,7 +29,7 @@ unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
 }
 
 unique_ptr<CreateViewInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_unique<CreateViewInfo>();
+	auto result = make_uniq<CreateViewInfo>();
 	result->DeserializeBase(deserializer);
 
 	FieldReader reader(deserializer);
@@ -85,7 +85,7 @@ unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context
 		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single CREATE VIEW statement",
 		    sql);
 	}
-	auto &create_statement = (CreateStatement &)*parser.statements[0];
+	auto &create_statement = parser.statements[0]->Cast<CreateStatement>();
 	if (create_statement.info->type != CatalogType::VIEW_ENTRY) {
 		throw BinderException(
 		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement", sql);

package/src/duckdb/src/parser/parsed_data/sample_options.cpp

@@ -1,19 +1,13 @@
 #include "duckdb/parser/parsed_data/sample_options.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 string SampleMethodToString(SampleMethod method) {
-	switch (method) {
-	case SampleMethod::SYSTEM_SAMPLE:
-		return "System";
-	case SampleMethod::BERNOULLI_SAMPLE:
-		return "Bernoulli";
-	case SampleMethod::RESERVOIR_SAMPLE:
-		return "Reservoir";
-	default:
-		return "Unknown";
-	}
+	return EnumUtil::ToString(method);
 }
 
 void SampleOptions::Serialize(Serializer &serializer) {
@@ -25,8 +19,26 @@ void SampleOptions::Serialize(Serializer &serializer) {
 	writer.Finalize();
 }
 
+void SampleOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("sample_size", sample_size);
+	serializer.WriteProperty("is_percentage", is_percentage);
+	serializer.WriteProperty("method", method);
+	serializer.WriteProperty("seed", seed);
+}
+
+unique_ptr<SampleOptions> SampleOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_uniq<SampleOptions>();
+
+	deserializer.ReadProperty("sample_size", result->sample_size);
+	deserializer.ReadProperty("is_percentage", result->is_percentage);
+	deserializer.ReadProperty("method", result->method);
+	deserializer.ReadProperty("seed", result->seed);
+
+	return result;
+}
+
 unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
-	auto result = make_unique<SampleOptions>();
+	auto result = make_uniq<SampleOptions>();
 
 	FieldReader reader(source);
 	result->sample_size = reader.ReadRequiredSerializable<Value, Value>();
@@ -39,7 +51,7 @@ unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
 }
 
 unique_ptr<SampleOptions> SampleOptions::Copy() {
-	auto result = make_unique<SampleOptions>();
+	auto result = make_uniq<SampleOptions>();
 	result->sample_size = sample_size;
 	result->is_percentage = is_percentage;
 	result->method = method;

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -107,6 +109,76 @@ void ParsedExpression::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void ParsedExpression::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("class", GetExpressionClass());
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("alias", alias);
+}
+
+unique_ptr<ParsedExpression> ParsedExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression_class = deserializer.ReadProperty<ExpressionClass>("class");
+	auto type = deserializer.ReadProperty<ExpressionType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	unique_ptr<ParsedExpression> result;
+	switch (expression_class) {
+	case ExpressionClass::BETWEEN:
+		result = BetweenExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CASE:
+		result = CaseExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CAST:
+		result = CastExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COLLATE:
+		result = CollateExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COLUMN_REF:
+		result = ColumnRefExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::COMPARISON:
+		result = ComparisonExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CONJUNCTION:
+		result = ConjunctionExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::CONSTANT:
+		result = ConstantExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::DEFAULT:
+		result = make_uniq<DefaultExpression>();
+		break;
+	case ExpressionClass::FUNCTION:
+		result = FunctionExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::LAMBDA:
+		result = LambdaExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::OPERATOR:
+		result = OperatorExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::PARAMETER:
+		result = ParameterExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::POSITIONAL_REFERENCE:
+		result = PositionalReferenceExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::STAR:
+		result = StarExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::SUBQUERY:
+		result = SubqueryExpression::FormatDeserialize(type, deserializer);
+		break;
+	case ExpressionClass::WINDOW:
+		result = WindowExpression::FormatDeserialize(type, deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for expression deserialization!");
+	}
+	result->alias = alias;
+	return result;
+}
+
 unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto expression_class = reader.ReadRequired<ExpressionClass>();