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

package/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp

@@ -0,0 +1,295 @@
+#include "duckdb/common/bitpacking.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Unpacking
+//===--------------------------------------------------------------------===//
+
+static void UnpackSingle(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta, uint16_t shr) {
+	if (delta + shr < 32) {
+		*out = ((static_cast<hugeint_t>(in[0])) >> shr) % (hugeint_t(1) << delta);
+	}
+
+	else if (delta + shr >= 32 && delta + shr < 64) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		++in;
+
+		if (delta + shr > 32) {
+			const uint16_t NEXT_SHR = shr + delta - 32;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (32 - shr);
+		}
+	}
+
+	else if (delta + shr >= 64 && delta + shr < 96) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		in += 2;
+
+		if (delta + shr > 64) {
+			const uint16_t NEXT_SHR = delta + shr - 64;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (64 - shr);
+		}
+	}
+
+	else if (delta + shr >= 96 && delta + shr < 128) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
+		in += 3;
+
+		if (delta + shr > 96) {
+			const uint16_t NEXT_SHR = delta + shr - 96;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (96 - shr);
+		}
+	}
+
+	else if (delta + shr >= 128) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
+		*out |= static_cast<hugeint_t>(in[3]) << (96 - shr);
+		in += 4;
+
+		if (delta + shr > 128) {
+			const uint16_t NEXT_SHR = delta + shr - 128;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (128 - shr);
+		}
+	}
+}
+
+static void UnpackLast(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta) {
+	const uint8_t LAST_IDX = 31;
+	const uint16_t SHIFT = (delta * 31) % 32;
+	out[LAST_IDX] = in[0] >> SHIFT;
+	if (delta > 32) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[1]) << (32 - SHIFT);
+	}
+	if (delta > 64) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[2]) << (64 - SHIFT);
+	}
+	if (delta > 96) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[3]) << (96 - SHIFT);
+	}
+}
+
+// Unpacks for specific deltas
+static void UnpackDelta0(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		out[i] = 0;
+	}
+}
+
+static void UnpackDelta32(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t k = 0; k < 32; ++k) {
+		out[k] = static_cast<hugeint_t>(in[k]);
+	}
+}
+
+static void UnpackDelta64(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 2;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+	}
+}
+
+static void UnpackDelta96(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 3;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
+	}
+}
+
+static void UnpackDelta128(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 4;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 3]) << 96;
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Packing
+//===--------------------------------------------------------------------===//
+
+static void PackSingle(const hugeint_t in, uint32_t *__restrict &out, uint16_t delta, uint16_t shl, hugeint_t mask) {
+	if (delta + shl < 32) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>((in & mask) << shl);
+		}
+
+	} else if (delta + shl >= 32 && delta + shl < 64) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>((in & mask) << shl);
+		}
+		++out;
+
+		if (delta + shl > 32) {
+			*out = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		}
+	}
+
+	else if (delta + shl >= 64 && delta + shl < 96) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>(in << shl);
+		}
+
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out += 2;
+
+		if (delta + shl > 64) {
+			*out = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		}
+	}
+
+	else if (delta + shl >= 96 && delta + shl < 128) {
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>(in << shl);
+		}
+
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		out += 3;
+
+		if (delta + shl > 96) {
+			*out = static_cast<uint32_t>((in & mask) >> (96 - shl));
+		}
+	}
+
+	else if (delta + shl >= 128) {
+		// shl == 0 won't ever happen here considering a delta of 128 calls PackDelta128
+		out[0] |= static_cast<uint32_t>(in << shl);
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		out[3] = static_cast<uint32_t>((in & mask) >> (96 - shl));
+		out += 4;
+
+		if (delta + shl > 128) {
+			*out = static_cast<uint32_t>((in & mask) >> (128 - shl));
+		}
+	}
+}
+
+static void PackLast(const hugeint_t *__restrict in, uint32_t *__restrict out, uint16_t delta) {
+	const uint8_t LAST_IDX = 31;
+	const uint16_t SHIFT = (delta * 31) % 32;
+	out[0] |= static_cast<uint32_t>(in[LAST_IDX] << SHIFT);
+	if (delta > 32) {
+		out[1] = static_cast<uint32_t>(in[LAST_IDX] >> (32 - SHIFT));
+	}
+	if (delta > 64) {
+		out[2] = static_cast<uint32_t>(in[LAST_IDX] >> (64 - SHIFT));
+	}
+	if (delta > 96) {
+		out[3] = static_cast<uint32_t>(in[LAST_IDX] >> (96 - SHIFT));
+	}
+}
+
+// Packs for specific deltas
+static void PackDelta32(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		out[i] = static_cast<uint32_t>(in[i]);
+	}
+}
+
+static void PackDelta64(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 2 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+	}
+}
+
+static void PackDelta96(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 3 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
+	}
+}
+
+static void PackDelta128(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 4 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
+		out[OFFSET + 3] = static_cast<uint32_t>(in[i] >> 96);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// HugeIntPacker
+//===--------------------------------------------------------------------===//
+
+void HugeIntPacker::Pack(const hugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width) {
+	D_ASSERT(width <= 128);
+	switch (width) {
+	case 0:
+		break;
+	case 32:
+		PackDelta32(in, out);
+		break;
+	case 64:
+		PackDelta64(in, out);
+		break;
+	case 96:
+		PackDelta96(in, out);
+		break;
+	case 128:
+		PackDelta128(in, out);
+		break;
+	default:
+		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
+			PackSingle(in[oindex], out, width, (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE,
+			           (hugeint_t(1) << width) - 1);
+		}
+		PackLast(in, out, width);
+	}
+}
+
+void HugeIntPacker::Unpack(const uint32_t *__restrict in, hugeint_t *__restrict out, bitpacking_width_t width) {
+	D_ASSERT(width <= 128);
+	switch (width) {
+	case 0:
+		UnpackDelta0(in, out);
+		break;
+	case 32:
+		UnpackDelta32(in, out);
+		break;
+	case 64:
+		UnpackDelta64(in, out);
+		break;
+	case 96:
+		UnpackDelta96(in, out);
+		break;
+	case 128:
+		UnpackDelta128(in, out);
+		break;
+	default:
+		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
+			UnpackSingle(in, out + oindex, width,
+			             (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE);
+		}
+		UnpackLast(in, out, width);
+	}
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+// 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/constraints/list.hpp"
+
+namespace duckdb {
+
+void Constraint::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+}
+
+unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<ConstraintType>("type");
+	unique_ptr<Constraint> result;
+	switch (type) {
+	case ConstraintType::CHECK:
+		result = CheckConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::FOREIGN_KEY:
+		result = ForeignKeyConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::NOT_NULL:
+		result = NotNullConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::UNIQUE:
+		result = UniqueConstraint::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of Constraint!");
+	}
+	return result;
+}
+
+void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("expression", *expression);
+}
+
+unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
+	auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
+	return std::move(result);
+}
+
+void ForeignKeyConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("pk_columns", pk_columns);
+	serializer.WriteProperty("fk_columns", fk_columns);
+	serializer.WriteProperty("type", info.type);
+	serializer.WriteProperty("schema", info.schema);
+	serializer.WriteProperty("table", info.table);
+	serializer.WriteProperty("pk_keys", info.pk_keys);
+	serializer.WriteProperty("fk_keys", info.fk_keys);
+}
+
+unique_ptr<Constraint> ForeignKeyConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
+	deserializer.ReadProperty("pk_columns", result->pk_columns);
+	deserializer.ReadProperty("fk_columns", result->fk_columns);
+	deserializer.ReadProperty("type", result->info.type);
+	deserializer.ReadProperty("schema", result->info.schema);
+	deserializer.ReadProperty("table", result->info.table);
+	deserializer.ReadProperty("pk_keys", result->info.pk_keys);
+	deserializer.ReadProperty("fk_keys", result->info.fk_keys);
+	return std::move(result);
+}
+
+void NotNullConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("index", index);
+}
+
+unique_ptr<Constraint> NotNullConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto index = deserializer.ReadProperty<LogicalIndex>("index");
+	auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
+	return std::move(result);
+}
+
+void UniqueConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("is_primary_key", is_primary_key);
+	serializer.WriteProperty("index", index);
+	serializer.WriteProperty("columns", columns);
+}
+
+unique_ptr<Constraint> UniqueConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
+	deserializer.ReadProperty("is_primary_key", result->is_primary_key);
+	deserializer.ReadProperty("index", result->index);
+	deserializer.ReadProperty("columns", result->columns);
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+// 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/parsed_data/create_info.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+
+namespace duckdb {
+
+void CreateInfo::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("catalog", catalog);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("temporary", temporary);
+	serializer.WriteProperty("internal", internal);
+	serializer.WriteProperty("on_conflict", on_conflict);
+	serializer.WriteProperty("sql", sql);
+}
+
+unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<CatalogType>("type");
+	auto catalog = deserializer.ReadProperty<string>("catalog");
+	auto schema = deserializer.ReadProperty<string>("schema");
+	auto temporary = deserializer.ReadProperty<bool>("temporary");
+	auto internal = deserializer.ReadProperty<bool>("internal");
+	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>("on_conflict");
+	auto sql = deserializer.ReadProperty<string>("sql");
+	unique_ptr<CreateInfo> result;
+	switch (type) {
+	case CatalogType::INDEX_ENTRY:
+		result = CreateIndexInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::MACRO_ENTRY:
+		result = CreateMacroInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::SCHEMA_ENTRY:
+		result = CreateSchemaInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::SEQUENCE_ENTRY:
+		result = CreateSequenceInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TABLE_ENTRY:
+		result = CreateTableInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TABLE_MACRO_ENTRY:
+		result = CreateMacroInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TYPE_ENTRY:
+		result = CreateTypeInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::VIEW_ENTRY:
+		result = CreateViewInfo::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of CreateInfo!");
+	}
+	result->catalog = std::move(catalog);
+	result->schema = std::move(schema);
+	result->temporary = temporary;
+	result->internal = internal;
+	result->on_conflict = on_conflict;
+	result->sql = std::move(sql);
+	return result;
+}
+
+void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", index_name);
+	serializer.WriteProperty("index_type", index_type);
+	serializer.WriteProperty("constraint_type", constraint_type);
+	serializer.WriteProperty("parsed_expressions", parsed_expressions);
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("column_ids", column_ids);
+}
+
+unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
+	deserializer.ReadProperty("name", result->index_name);
+	deserializer.ReadProperty("index_type", result->index_type);
+	deserializer.ReadProperty("constraint_type", result->constraint_type);
+	deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);
+	deserializer.ReadProperty("names", result->names);
+	deserializer.ReadProperty("column_ids", result->column_ids);
+	return std::move(result);
+}
+
+void CreateMacroInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("function", *function);
+}
+
+unique_ptr<CreateInfo> CreateMacroInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("function", result->function);
+	return std::move(result);
+}
+
+void CreateSchemaInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+}
+
+unique_ptr<CreateInfo> CreateSchemaInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateSchemaInfo>(new CreateSchemaInfo());
+	return std::move(result);
+}
+
+void CreateSequenceInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("usage_count", usage_count);
+	serializer.WriteProperty("increment", increment);
+	serializer.WriteProperty("min_value", min_value);
+	serializer.WriteProperty("max_value", max_value);
+	serializer.WriteProperty("start_value", start_value);
+	serializer.WriteProperty("cycle", cycle);
+}
+
+unique_ptr<CreateInfo> CreateSequenceInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateSequenceInfo>(new CreateSequenceInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("usage_count", result->usage_count);
+	deserializer.ReadProperty("increment", result->increment);
+	deserializer.ReadProperty("min_value", result->min_value);
+	deserializer.ReadProperty("max_value", result->max_value);
+	deserializer.ReadProperty("start_value", result->start_value);
+	deserializer.ReadProperty("cycle", result->cycle);
+	return std::move(result);
+}
+
+void CreateTableInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("table", table);
+	serializer.WriteProperty("columns", columns);
+	serializer.WriteProperty("constraints", constraints);
+	serializer.WriteOptionalProperty("query", query);
+}
+
+unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateTableInfo>(new CreateTableInfo());
+	deserializer.ReadProperty("table", result->table);
+	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadProperty("constraints", result->constraints);
+	deserializer.ReadOptionalProperty("query", result->query);
+	return std::move(result);
+}
+
+void CreateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("type", type);
+}
+
+unique_ptr<CreateInfo> CreateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateTypeInfo>(new CreateTypeInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("type", result->type);
+	return std::move(result);
+}
+
+void CreateViewInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("view_name", view_name);
+	serializer.WriteProperty("aliases", aliases);
+	serializer.WriteProperty("types", types);
+	serializer.WriteOptionalProperty("query", query);
+}
+
+unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateViewInfo>(new CreateViewInfo());
+	deserializer.ReadProperty("view_name", result->view_name);
+	deserializer.ReadProperty("aliases", result->aliases);
+	deserializer.ReadProperty("types", result->types);
+	deserializer.ReadOptionalProperty("query", result->query);
+	return std::move(result);
+}
+
+} // namespace duckdb