duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.0

package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp

@@ -21,51 +21,23 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ORDER_BY;
 
 public:
-	explicit LogicalOrder(vector<BoundOrderByNode> orders)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
-	}
+	explicit LogicalOrder(vector<BoundOrderByNode> orders);
 
 	vector<BoundOrderByNode> orders;
 	vector<idx_t> projections;
 
 public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		auto child_bindings = children[0]->GetColumnBindings();
-		if (projections.empty()) {
-			return child_bindings;
-		}
-
-		vector<ColumnBinding> result;
-		for (auto &col_idx : projections) {
-			result.push_back(child_bindings[col_idx]);
-		}
-		return result;
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
-	string ParamsToString() const override {
-		string result = "ORDERS:\n";
-		for (idx_t i = 0; i < orders.size(); i++) {
-			if (i > 0) {
-				result += "\n";
-			}
-			result += orders[i].expression->GetName();
-		}
-		return result;
-	}
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
+	string ParamsToString() const override;
 
 protected:
-	void ResolveTypes() override {
-		const auto child_types = children[0]->types;
-		if (projections.empty()) {
-			types = child_types;
-		} else {
-			for (auto &col_idx : projections) {
-				types.push_back(child_types[col_idx]);
-			}
-		}
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp

@@ -31,10 +31,16 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalPivot();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp

@@ -27,5 +27,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp

@@ -26,6 +26,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp

@@ -13,9 +13,7 @@
 namespace duckdb {
 
 class LogicalRecursiveCTE : public LogicalOperator {
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
-	      column_count(column_count) {
+	LogicalRecursiveCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
 	}
 
 public:
@@ -41,6 +39,10 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp

@@ -30,6 +30,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp

@@ -31,8 +31,14 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalSample();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp

@@ -31,6 +31,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp

@@ -40,6 +40,10 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp

@@ -30,6 +30,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override {
 		types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,

package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp

@@ -28,6 +28,9 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp

@@ -35,6 +35,10 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp

@@ -28,6 +28,8 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -33,11 +33,17 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 	string GetName() const override;
 
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void ResolveTypes() override;
+
+private:
+	LogicalUpdate(ClientContext &context, const string &catalog, const string &schema, const string &table);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp

@@ -29,6 +29,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -25,6 +25,9 @@ struct BoundPivotInfo {
 	vector<string> pivot_values;
 	//! The set of aggregate functions that is being executed
 	vector<unique_ptr<Expression>> aggregates;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BoundPivotInfo FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class BoundPivotRef : public BoundTableRef {

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -15,10 +15,12 @@ namespace duckdb {
 
 struct DelimCandidate {
 public:
-	explicit DelimCandidate(LogicalDelimJoin &delim_join) : delim_join(delim_join), delim_get_count(0) {
+	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalDelimJoin &delim_join)
+	    : op(op), delim_join(delim_join), delim_get_count(0) {
 	}
 
 public:
+	unique_ptr<LogicalOperator> &op;
 	LogicalDelimJoin &delim_join;
 	vector<reference<unique_ptr<LogicalOperator>>> joins;
 	idx_t delim_get_count;
@@ -61,7 +63,7 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 					}
 				}
 			}
-			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
+			candidate.op = LogicalComparisonJoin::FromDelimJoin(delim_join);
 		}
 	}
 
@@ -78,7 +80,7 @@ void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCa
 		return;
 	}
 
-	candidates.emplace_back(op->Cast<LogicalDelimJoin>());
+	candidates.emplace_back(op, op->Cast<LogicalDelimJoin>());
 	auto &candidate = candidates.back();
 
 	// DelimGets are in the RHS

package/src/duckdb/src/parser/column_definition.cpp

@@ -13,28 +13,14 @@ ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p)
 
 ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
                                    TableColumnType category)
-    : name(std::move(name_p)), type(std::move(type_p)), category(category) {
-	switch (category) {
-	case TableColumnType::STANDARD: {
-		default_value = std::move(expression);
-		break;
-	}
-	case TableColumnType::GENERATED: {
-		generated_expression = std::move(expression);
-		break;
-	}
-	default: {
-		throw InternalException("Type not implemented for TableColumnType");
-	}
-	}
+    : name(std::move(name_p)), type(std::move(type_p)), category(category), expression(std::move(expression)) {
 }
 
 ColumnDefinition ColumnDefinition::Copy() const {
 	ColumnDefinition copy(name, type);
 	copy.oid = oid;
 	copy.storage_oid = storage_oid;
-	copy.SetDefaultValue(default_value ? default_value->Copy() : nullptr);
-	copy.generated_expression = generated_expression ? generated_expression->Copy() : nullptr;
+	copy.expression = expression ? expression->Copy() : nullptr;
 	copy.compression_type = compression_type;
 	copy.category = category;
 	return copy;
@@ -44,11 +30,7 @@ void ColumnDefinition::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
 	writer.WriteSerializable(type);
-	if (Generated()) {
-		writer.WriteOptional(generated_expression);
-	} else {
-		writer.WriteOptional(default_value);
-	}
+	writer.WriteOptional(expression);
 	writer.WriteField<TableColumnType>(category);
 	writer.WriteField<duckdb::CompressionType>(compression_type);
 	writer.Finalize();
@@ -69,11 +51,17 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 }
 
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
-	return default_value;
+	if (Generated()) {
+		throw InternalException("Calling DefaultValue() on a generated column");
+	}
+	return expression;
 }
 
 void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	this->default_value = std::move(default_value);
+	if (Generated()) {
+		throw InternalException("Calling SetDefaultValue() on a generated column");
+	}
+	this->expression = std::move(default_value);
 }
 
 const LogicalType &ColumnDefinition::Type() const {
@@ -168,7 +156,7 @@ static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &d
 
 void ColumnDefinition::GetListOfDependencies(vector<string> &dependencies) const {
 	D_ASSERT(Generated());
-	InnerGetListOfDependencies(*generated_expression, dependencies);
+	InnerGetListOfDependencies(*expression, dependencies);
 }
 
 string ColumnDefinition::GetName() const {
@@ -179,28 +167,28 @@ LogicalType ColumnDefinition::GetType() const {
 	return type;
 }
 
-void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> expression) {
+void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> new_expr) {
 	category = TableColumnType::GENERATED;
 
-	if (expression->HasSubquery()) {
+	if (new_expr->HasSubquery()) {
 		throw ParserException("Expression of generated column \"%s\" contains a subquery, which isn't allowed", name);
 	}
 
-	VerifyColumnRefs(*expression);
+	VerifyColumnRefs(*new_expr);
 	if (type.id() == LogicalTypeId::ANY) {
-		generated_expression = std::move(expression);
+		expression = std::move(new_expr);
 		return;
 	}
 	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
 	// Except if the type is LogicalType::ANY (no type specified)
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(new_expr));
 }
 
 void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 	D_ASSERT(Generated());
 	// First time the type is set, add a cast around the expression
 	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(generated_expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
 	// Every generated expression should be wrapped in a cast on creation
 	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
 	// auto &cast_expr = generated_expression->Cast<CastExpression>();
@@ -210,12 +198,12 @@ void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 
 const ParsedExpression &ColumnDefinition::GeneratedExpression() const {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 ParsedExpression &ColumnDefinition::GeneratedExpressionMutable() {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/column_list.cpp

@@ -6,6 +6,14 @@ namespace duckdb {
 
 ColumnList::ColumnList(bool allow_duplicate_names) : allow_duplicate_names(allow_duplicate_names) {
 }
+
+ColumnList::ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names)
+    : allow_duplicate_names(allow_duplicate_names) {
+	for (auto &col : columns) {
+		AddColumn(std::move(col));
+	}
+}
+
 void ColumnList::AddColumn(ColumnDefinition column) {
 	auto oid = columns.size();
 	if (!column.Generated()) {

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -6,6 +6,9 @@
 
 namespace duckdb {
 
+ForeignKeyConstraint::ForeignKeyConstraint() : Constraint(ConstraintType::FOREIGN_KEY) {
+}
+
 ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
     : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)),
       info(std::move(info)) {

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -6,6 +6,9 @@
 
 namespace duckdb {
 
+UniqueConstraint::UniqueConstraint() : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX) {
+}
+
 UniqueConstraint::UniqueConstraint(LogicalIndex index, bool is_primary_key)
     : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
 }

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -8,18 +8,6 @@
 
 namespace duckdb {
 
-void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("when_expr", when_expr);
-	serializer.WriteProperty("then_expr", then_expr);
-}
-
-CaseCheck CaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
-	CaseCheck check;
-	deserializer.ReadProperty("when_expr", check.when_expr);
-	deserializer.ReadProperty("then_expr", check.then_expr);
-	return check;
-}
-
 CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
 }
 

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

@@ -8,8 +8,11 @@
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
-    : type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
-      name(std::move(name_p)), allow_internal(false) {
+    : ParseInfo(TYPE), type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)),
+      schema(std::move(schema_p)), name(std::move(name_p)), allow_internal(false) {
+}
+
+AlterInfo::AlterInfo(AlterType type) : ParseInfo(TYPE), type(type) {
 }
 
 AlterInfo::~AlterInfo() {

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

@@ -33,6 +33,9 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
+AlterTableInfo::AlterTableInfo(AlterTableType type) : AlterInfo(AlterType::ALTER_TABLE), alter_table_type(type) {
+}
+
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -94,6 +97,10 @@ RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, strin
     : AlterTableInfo(AlterTableType::RENAME_COLUMN, std::move(data)), old_name(std::move(old_name_p)),
       new_name(std::move(new_name_p)) {
 }
+
+RenameColumnInfo::RenameColumnInfo() : AlterTableInfo(AlterTableType::RENAME_COLUMN) {
+}
+
 RenameColumnInfo::~RenameColumnInfo() {
 }
 
@@ -115,9 +122,13 @@ unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, AlterEn
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
+RenameTableInfo::RenameTableInfo() : AlterTableInfo(AlterTableType::RENAME_TABLE) {
+}
+
 RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
     : AlterTableInfo(AlterTableType::RENAME_TABLE, std::move(data)), new_table_name(std::move(new_name_p)) {
 }
+
 RenameTableInfo::~RenameTableInfo() {
 }
 
@@ -137,6 +148,10 @@ unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEnt
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
+AddColumnInfo::AddColumnInfo(ColumnDefinition new_column_p)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN), new_column(std::move(new_column_p)) {
+}
+
 AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
     : AlterTableInfo(AlterTableType::ADD_COLUMN, std::move(data)), new_column(std::move(new_column)),
       if_column_not_exists(if_column_not_exists) {
@@ -163,6 +178,9 @@ unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, AlterEntry
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
+RemoveColumnInfo::RemoveColumnInfo() : AlterTableInfo(AlterTableType::REMOVE_COLUMN) {
+}
+
 RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
     : AlterTableInfo(AlterTableType::REMOVE_COLUMN, std::move(data)), removed_column(std::move(removed_column)),
       if_column_exists(if_column_exists), cascade(cascade) {
@@ -190,6 +208,9 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEn
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
+ChangeColumnTypeInfo::ChangeColumnTypeInfo() : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE) {
+}
+
 ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
                                            unique_ptr<ParsedExpression> expression)
     : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, std::move(data)), column_name(std::move(column_name)),
@@ -220,6 +241,9 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, Alt
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
+SetDefaultInfo::SetDefaultInfo() : AlterTableInfo(AlterTableType::SET_DEFAULT) {
+}
+
 SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
     : AlterTableInfo(AlterTableType::SET_DEFAULT, std::move(data)), column_name(std::move(column_name_p)),
       expression(std::move(new_default)) {
@@ -246,6 +270,9 @@ unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, AlterEntr
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
+SetNotNullInfo::SetNotNullInfo() : AlterTableInfo(AlterTableType::SET_NOT_NULL) {
+}
+
 SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::SET_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -268,6 +295,9 @@ unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntr
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
+DropNotNullInfo::DropNotNullInfo() : AlterTableInfo(AlterTableType::DROP_NOT_NULL) {
+}
+
 DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::DROP_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -290,6 +320,9 @@ unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEnt
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
+AlterForeignKeyInfo::AlterForeignKeyInfo() : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT) {
+}
+
 AlterForeignKeyInfo::AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns,
                                          vector<string> fk_columns, vector<PhysicalIndex> pk_keys,
                                          vector<PhysicalIndex> fk_keys, AlterForeignKeyType type_p)
@@ -328,6 +361,9 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
+AlterViewInfo::AlterViewInfo(AlterViewType type) : AlterInfo(AlterType::ALTER_VIEW) {
+}
+
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -368,6 +404,8 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
+RenameViewInfo::RenameViewInfo() : AlterViewInfo(AlterViewType::RENAME_VIEW) {
+}
 RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
     : AlterViewInfo(AlterViewType::RENAME_VIEW, std::move(data)), new_view_name(std::move(new_name_p)) {
 }

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

@@ -11,7 +11,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->index_type = index_type;
 	result->index_name = index_name;
 	result->constraint_type = constraint_type;
-	result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
+	result->table = table;
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
@@ -28,6 +28,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteField(index_type);
+	writer.WriteString(table);
 	writer.WriteString(index_name);
 	writer.WriteField(constraint_type);
 
@@ -45,6 +46,7 @@ unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deseriali
 
 	FieldReader reader(deserializer);
 	result->index_type = reader.ReadRequired<IndexType>();
+	result->table = reader.ReadRequired<string>();
 	result->index_name = reader.ReadRequired<string>();
 	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
 

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

@@ -27,6 +27,7 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
+	writer.WriteString(schema);
 	writer.WriteField(usage_count);
 	writer.WriteField(increment);
 	writer.WriteField(min_value);
@@ -42,6 +43,7 @@ unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &des
 
 	FieldReader reader(deserializer);
 	result->name = reader.ReadRequired<string>();
+	result->schema = reader.ReadRequired<string>();
 	result->usage_count = reader.ReadRequired<uint64_t>();
 	result->increment = reader.ReadRequired<int64_t>();
 	result->min_value = reader.ReadRequired<int64_t>();