duckdb 0.8.2-dev1968.0 → 0.8.2-dev2044.0

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -28,7 +28,7 @@ protected:
 public:
 	// Serialize a value
 	template <class T>
-	typename std::enable_if<!std::is_enum<T>::value, void>::type WriteProperty(const char *tag, T &value) {
+	typename std::enable_if<!std::is_enum<T>::value, void>::type WriteProperty(const char *tag, const T &value) {
 		SetTag(tag);
 		WriteValue(value);
 	}
@@ -48,22 +48,8 @@ public:
 	}
 
 	// Optional pointer
-	template <class T>
-	void WriteOptionalProperty(const char *tag, T *ptr) {
-		SetTag(tag);
-		if (ptr == nullptr) {
-			OnOptionalBegin(false);
-			OnOptionalEnd(false);
-		} else {
-			OnOptionalBegin(true);
-			WriteValue(*ptr);
-			OnOptionalEnd(true);
-		}
-	}
-
-	// Optional unique_ptr
-	template <class T>
-	void WriteOptionalProperty(const char *tag, const unique_ptr<T> &ptr) {
+	template <class POINTER>
+	void WriteOptionalProperty(const char *tag, POINTER &&ptr) {
 		SetTag(tag);
 		if (ptr == nullptr) {
 			OnOptionalBegin(false);
@@ -122,10 +108,20 @@ protected:
 		OnListEnd(count);
 	}
 
+	template <class T>
+	void WriteValue(const unsafe_vector<T> &vec) {
+		auto count = vec.size();
+		OnListBegin(count);
+		for (auto &item : vec) {
+			WriteValue(item);
+		}
+		OnListEnd(count);
+	}
+
 	// UnorderedSet
 	// Serialized the same way as a list/vector
 	template <class T, class HASH, class CMP>
-	void WriteValue(const unordered_set<T, HASH, CMP> &set) {
+	void WriteValue(const duckdb::unordered_set<T, HASH, CMP> &set) {
 		auto count = set.size();
 		OnListBegin(count);
 		for (auto &item : set) {
@@ -137,7 +133,7 @@ protected:
 	// Set
 	// Serialized the same way as a list/vector
 	template <class T, class HASH, class CMP>
-	void WriteValue(const set<T, HASH, CMP> &set) {
+	void WriteValue(const duckdb::set<T, HASH, CMP> &set) {
 		auto count = set.size();
 		OnListBegin(count);
 		for (auto &item : set) {
@@ -148,7 +144,7 @@ protected:
 
 	// Map
 	template <class K, class V, class HASH, class CMP>
-	void WriteValue(const std::unordered_map<K, V, HASH, CMP> &map) {
+	void WriteValue(const duckdb::unordered_map<K, V, HASH, CMP> &map) {
 		auto count = map.size();
 		OnMapBegin(count);
 		for (auto &item : map) {
@@ -166,7 +162,7 @@ protected:
 
 	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
 	template <typename T>
-	typename std::enable_if<has_serialize<T>::value>::type WriteValue(T &value) {
+	typename std::enable_if<has_serialize<T>::value>::type WriteValue(const T &value) {
 		// Else, we defer to the .FormatSerialize method
 		OnObjectBegin();
 		value.FormatSerialize(*this);
@@ -243,6 +239,12 @@ protected:
 	virtual void WriteValue(const char *str) = 0;
 	virtual void WriteValue(interval_t value) = 0;
 	virtual void WriteDataPtr(const_data_ptr_t ptr, idx_t count) = 0;
+	void WriteValue(LogicalIndex value) {
+		WriteValue(value.index);
+	}
+	void WriteValue(PhysicalIndex value) {
+		WriteValue(value.index);
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -3,7 +3,8 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
-
+#include "duckdb/common/set.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 namespace duckdb {
 
 class FormatSerializer;   // Forward declare
@@ -51,11 +52,18 @@ struct is_vector<typename duckdb::vector<T>> : std::true_type {
 	typedef T ELEMENT_TYPE;
 };
 
+template <typename T>
+struct is_unsafe_vector : std::false_type {};
+template <typename T>
+struct is_unsafe_vector<typename duckdb::unsafe_vector<T>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+};
+
 // Check if T is a unordered map, and provide access to the inner type
 template <typename T>
 struct is_unordered_map : std::false_type {};
 template <typename... Args>
-struct is_unordered_map<typename std::unordered_map<Args...>> : std::true_type {
+struct is_unordered_map<typename duckdb::unordered_map<Args...>> : std::true_type {
 	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
 	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
 	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
@@ -90,7 +98,7 @@ struct is_pair<std::pair<T, U>> : std::true_type {
 template <typename T>
 struct is_unordered_set : std::false_type {};
 template <typename... Args>
-struct is_unordered_set<std::unordered_set<Args...>> : std::true_type {
+struct is_unordered_set<duckdb::unordered_set<Args...>> : std::true_type {
 	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
 	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
 	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
@@ -99,7 +107,7 @@ struct is_unordered_set<std::unordered_set<Args...>> : std::true_type {
 template <typename T>
 struct is_set : std::false_type {};
 template <typename... Args>
-struct is_set<std::set<Args...>> : std::true_type {
+struct is_set<duckdb::set<Args...>> : std::true_type {
 	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
 	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
 	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -154,6 +154,9 @@ public:
 	//! Get a vector of the segments in this ColumnDataCollection
 	const vector<unique_ptr<ColumnDataCollectionSegment>> &GetSegments() const;
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ColumnDataCollection> FormatDeserialize(FormatDeserializer &deserializer);
+
 private:
 	//! Creates a new segment within the ColumnDataCollection
 	void CreateSegment();

package/src/duckdb/src/include/duckdb/function/macro_function.hpp

@@ -48,6 +48,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	virtual void SerializeInternal(FieldWriter &writer) const = 0;
 

package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp

@@ -36,6 +36,9 @@ public:
 
 	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(FieldWriter &writer) const override;
 };

package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp

@@ -36,6 +36,9 @@ public:
 
 	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(FieldWriter &writer) const override;
 };

package/src/duckdb/src/include/duckdb/parser/column_definition.hpp

@@ -29,9 +29,6 @@ public:
 	DUCKDB_API ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> expression,
 	                            TableColumnType category);
 
-	//! The default value of the column (if any)
-	unique_ptr<ParsedExpression> default_value;
-
 public:
 	//! default_value
 	const unique_ptr<ParsedExpression> &DefaultValue() const;
@@ -70,6 +67,9 @@ public:
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static ColumnDefinition FormatDeserialize(FormatDeserializer &deserializer);
+
 	//===--------------------------------------------------------------------===//
 	// Generated Columns (VIRTUAL)
 	//===--------------------------------------------------------------------===//
@@ -97,8 +97,9 @@ private:
 	idx_t oid = DConstants::INVALID_INDEX;
 	//! The category of the column
 	TableColumnType category = TableColumnType::STANDARD;
-	//! Used by Generated Columns
-	unique_ptr<ParsedExpression> generated_expression;
+	//! The default value of the column (for non-generated columns)
+	//! The generated column expression (for generated columns)
+	unique_ptr<ParsedExpression> expression;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/column_list.hpp

@@ -20,6 +20,7 @@ public:
 
 public:
 	DUCKDB_API ColumnList(bool allow_duplicate_names = false);
+	DUCKDB_API explicit ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names = false);
 
 	DUCKDB_API void AddColumn(ColumnDefinition column);
 	void Finalize();
@@ -53,6 +54,9 @@ public:
 	void Serialize(FieldWriter &writer) const;
 	static ColumnList Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnList FormatDeserialize(FormatDeserializer &deserializer);
+
 	DUCKDB_API ColumnListIterator Logical() const;
 	DUCKDB_API ColumnListIterator Physical() const;
 

package/src/duckdb/src/include/duckdb/parser/constraint.hpp

@@ -16,6 +16,8 @@ namespace duckdb {
 
 class Serializer;
 class Deserializer;
+class FormatSerializer;
+class FormatDeserializer;
 class FieldWriter;
 class FieldReader;
 
@@ -68,6 +70,9 @@ public:
 	//! Deserializes a blob back into a Constraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
 
+	DUCKDB_API virtual void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp

@@ -32,6 +32,9 @@ public:
 
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp

@@ -35,6 +35,12 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a ParsedConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	ForeignKeyConstraint();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp

@@ -32,6 +32,9 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a NotNullConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp

@@ -38,6 +38,12 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a ParsedConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	UniqueConstraint();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -35,7 +35,7 @@ public:
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -42,7 +42,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/cast_expression.hpp

@@ -38,7 +38,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/collate_expression.hpp

@@ -35,7 +35,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
 	CollateExpression();

package/src/duckdb/src/include/duckdb/parser/expression/columnref_expression.hpp

@@ -49,7 +49,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
 	ColumnRefExpression();

package/src/duckdb/src/include/duckdb/parser/expression/comparison_expression.hpp

@@ -34,7 +34,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/conjunction_expression.hpp

@@ -38,7 +38,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/constant_expression.hpp

@@ -36,7 +36,7 @@ public:
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
 	ConstantExpression();

package/src/duckdb/src/include/duckdb/parser/expression/default_expression.hpp

@@ -31,6 +31,6 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -59,7 +59,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 	void Verify() const override;
 

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -41,7 +41,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
 	LambdaExpression();

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -36,7 +36,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>

package/src/duckdb/src/include/duckdb/parser/expression/parameter_expression.hpp

@@ -38,6 +38,6 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/positional_reference_expression.hpp

@@ -34,7 +34,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 private:
 	PositionalReferenceExpression();

package/src/duckdb/src/include/duckdb/parser/expression/star_expression.hpp

@@ -42,6 +42,6 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/subquery_expression.hpp

@@ -49,6 +49,6 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -77,7 +77,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 	static ExpressionType WindowToExpressionType(string &fun_name);
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp

@@ -40,8 +40,12 @@ struct AlterEntryData {
 };
 
 struct AlterInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::ALTER_INFO;
+
+public:
 	AlterInfo(AlterType type, string catalog, string schema, string name, OnEntryNotFound if_not_found);
-	virtual ~AlterInfo() override;
+	~AlterInfo() override;
 
 	AlterType type;
 	//! if exists
@@ -61,11 +65,18 @@ public:
 	void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 	virtual string GetColumnName() const {
 		return "";
 	};
 
 	AlterEntryData GetAlterEntryData() const;
+
+protected:
+	explicit AlterInfo(AlterType type);
 };
 
 } // namespace duckdb