duckdb 0.6.2-dev781.0 → 0.6.2-dev889.0

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

@@ -8,9 +8,11 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // ChangeOwnershipInfo
 //===--------------------------------------------------------------------===//
-ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema_p, string entry_name_p,
-                                         string owner_schema_p, string owner_name_p, bool if_exists)
-    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_schema_p), move(entry_name_p), if_exists),
+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)
+    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_catalog_p), move(entry_schema_p), move(entry_name_p),
+                if_exists),
       entry_catalog_type(entry_catalog_type), owner_schema(move(owner_schema_p)), owner_name(move(owner_name_p)) {
 }
 
@@ -19,8 +21,8 @@ CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 }
 
 unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, schema, name, owner_schema, owner_name,
-	                                                        if_exists);
+	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, catalog, schema, name, owner_schema,
+	                                                        owner_name, if_exists);
 }
 
 void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
@@ -30,8 +32,9 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
-AlterTableInfo::AlterTableInfo(AlterTableType type, string schema_p, string table_p, bool if_exists)
-    : AlterInfo(AlterType::ALTER_TABLE, move(move(schema_p)), move(table_p), if_exists), alter_table_type(type) {
+AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
+    : AlterInfo(AlterType::ALTER_TABLE, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+      alter_table_type(type) {
 }
 AlterTableInfo::~AlterTableInfo() {
 }
@@ -42,6 +45,7 @@ CatalogType AlterTableInfo::GetCatalogType() const {
 
 void AlterTableInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteField<AlterTableType>(alter_table_type);
+	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
 	writer.WriteField(if_exists);
@@ -50,30 +54,32 @@ void AlterTableInfo::Serialize(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 	auto type = reader.ReadRequired<AlterTableType>();
-	auto schema = reader.ReadRequired<string>();
-	auto table = reader.ReadRequired<string>();
-	auto if_exists = reader.ReadRequired<bool>();
+	AlterEntryData data;
+	data.catalog = reader.ReadRequired<string>();
+	data.schema = reader.ReadRequired<string>();
+	data.name = reader.ReadRequired<string>();
+	data.if_exists = reader.ReadRequired<bool>();
 
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
 	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(reader, schema, table, if_exists);
+		return RenameColumnInfo::Deserialize(reader, move(data));
 	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(reader, schema, table, if_exists);
+		return RenameTableInfo::Deserialize(reader, move(data));
 	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(reader, schema, table, if_exists);
+		return AddColumnInfo::Deserialize(reader, move(data));
 	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(reader, schema, table, if_exists);
+		return RemoveColumnInfo::Deserialize(reader, move(data));
 	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(reader, schema, table, if_exists);
+		return ChangeColumnTypeInfo::Deserialize(reader, move(data));
 	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(reader, schema, table, if_exists);
+		return SetDefaultInfo::Deserialize(reader, move(data));
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		return AlterForeignKeyInfo::Deserialize(reader, schema, table, if_exists);
+		return AlterForeignKeyInfo::Deserialize(reader, move(data));
 	case AlterTableType::SET_NOT_NULL:
-		return SetNotNullInfo::Deserialize(reader, schema, table, if_exists);
+		return SetNotNullInfo::Deserialize(reader, move(data));
 	case AlterTableType::DROP_NOT_NULL:
-		return DropNotNullInfo::Deserialize(reader, schema, table, if_exists);
+		return DropNotNullInfo::Deserialize(reader, move(data));
 	default:
 		throw SerializationException("Unknown alter table type for deserialization!");
 	}
@@ -82,16 +88,15 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
-RenameColumnInfo::RenameColumnInfo(string schema_p, string table_p, bool if_exists_p, string old_name_p,
-                                   string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema_p), move(table_p), if_exists_p),
-      old_name(move(old_name_p)), new_name(move(new_name_p)) {
+RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(data)), old_name(move(old_name_p)),
+      new_name(move(new_name_p)) {
 }
 RenameColumnInfo::~RenameColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameColumnInfo>(schema, name, if_exists, old_name, new_name);
+	return make_unique_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
 }
 
 void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -99,49 +104,47 @@ void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(new_name);
 }
 
-unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+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>(move(schema), move(table), if_exists, old_name, new_name);
+	return make_unique<RenameColumnInfo>(move(data), old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
-RenameTableInfo::RenameTableInfo(string schema_p, string table_p, bool if_exists, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(schema_p), move(table_p), if_exists),
-      new_table_name(move(new_name_p)) {
+RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(data)), new_table_name(move(new_name_p)) {
 }
 RenameTableInfo::~RenameTableInfo() {
 }
 
 unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameTableInfo>(schema, name, if_exists, new_table_name);
+	return make_unique_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
 }
 
 void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(new_table_name);
 }
 
-unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameTableInfo>(move(schema), move(table), if_exists, new_name);
+	return make_unique<RenameTableInfo>(move(data), new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
-AddColumnInfo::AddColumnInfo(string schema_p, string table_p, bool if_exists_p, ColumnDefinition new_column,
-                             bool if_column_not_exists)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(schema_p), move(table_p), if_exists_p),
-      new_column(move(new_column)), if_column_not_exists(if_column_not_exists) {
+AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(data)), new_column(move(new_column)),
+      if_column_not_exists(if_column_not_exists) {
 }
 
 AddColumnInfo::~AddColumnInfo() {
 }
 
 unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddColumnInfo>(schema, name, if_exists, new_column.Copy(), if_column_not_exists);
+	return make_unique_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
 }
 
 void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
@@ -149,25 +152,24 @@ void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteField<bool>(if_column_not_exists);
 }
 
-unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+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>(move(schema), move(table), if_exists, move(new_column), if_column_not_exists);
+	return make_unique<AddColumnInfo>(move(data), move(new_column), if_column_not_exists);
 }
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
-RemoveColumnInfo::RemoveColumnInfo(string schema, string table, bool if_exists, string removed_column,
-                                   bool if_column_exists, bool cascade)
-    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(schema), move(table), if_exists),
-      removed_column(move(removed_column)), if_column_exists(if_column_exists), cascade(cascade) {
+RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
+    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(data)), removed_column(move(removed_column)),
+      if_column_exists(if_column_exists), cascade(cascade) {
 }
 RemoveColumnInfo::~RemoveColumnInfo() {
 }
 
 unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RemoveColumnInfo>(schema, name, if_exists, removed_column, if_column_exists,
+	return make_unique_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists,
 	                                                     cascade);
 }
 
@@ -177,26 +179,26 @@ void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteField<bool>(cascade);
 }
 
-unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
 	auto if_column_exists = reader.ReadRequired<bool>();
 	auto cascade = reader.ReadRequired<bool>();
-	return make_unique<RemoveColumnInfo>(move(schema), move(table), if_exists, new_name, if_column_exists, cascade);
+	return make_unique<RemoveColumnInfo>(move(data), move(new_name), if_column_exists, cascade);
 }
 
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
-ChangeColumnTypeInfo::ChangeColumnTypeInfo(string schema_p, string table_p, bool if_exists_p, string column_name,
-                                           LogicalType target_type, unique_ptr<ParsedExpression> expression)
-    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(schema_p), move(table_p), if_exists_p),
-      column_name(move(column_name)), target_type(move(target_type)), expression(move(expression)) {
+ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
+                                           unique_ptr<ParsedExpression> expression)
+    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(data)), column_name(move(column_name)),
+      target_type(move(target_type)), expression(move(expression)) {
 }
 ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
 }
 
 unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(schema, name, if_exists, column_name, target_type,
+	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(GetAlterEntryData(), column_name, target_type,
 	                                                         expression->Copy());
 }
 
@@ -206,28 +208,25 @@ void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, string schema, string table,
-                                                        bool if_exists) {
+unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
 	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<ChangeColumnTypeInfo>(move(schema), move(table), if_exists, move(column_name), move(target_type),
-	                                         move(expression));
+	return make_unique<ChangeColumnTypeInfo>(move(data), move(column_name), move(target_type), move(expression));
 }
 
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
-SetDefaultInfo::SetDefaultInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p,
-                               unique_ptr<ParsedExpression> new_default)
-    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(schema_p), move(table_p), if_exists_p),
-      column_name(move(column_name_p)), expression(move(new_default)) {
+SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
+    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(data)), column_name(move(column_name_p)),
+      expression(move(new_default)) {
 }
 SetDefaultInfo::~SetDefaultInfo() {
 }
 
 unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetDefaultInfo>(schema, name, if_exists, column_name,
+	return make_unique_base<AlterInfo, SetDefaultInfo>(GetAlterEntryData(), column_name,
 	                                                   expression ? expression->Copy() : nullptr);
 }
 
@@ -236,74 +235,71 @@ void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+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>(move(schema), move(table), if_exists, move(column_name), move(new_default));
+	return make_unique<SetDefaultInfo>(move(data), move(column_name), move(new_default));
 }
 
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
-SetNotNullInfo::SetNotNullInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p)
-    : AlterTableInfo(AlterTableType::SET_NOT_NULL, move(schema_p), move(table_p), if_exists_p),
-      column_name(move(column_name_p)) {
+SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
+    : AlterTableInfo(AlterTableType::SET_NOT_NULL, move(data)), column_name(move(column_name_p)) {
 }
 SetNotNullInfo::~SetNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetNotNullInfo>(schema, name, if_exists, column_name);
+	return make_unique_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
 void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(column_name);
 }
 
-unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<SetNotNullInfo>(move(schema), move(table), if_exists, move(column_name));
+	return make_unique<SetNotNullInfo>(move(data), move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
-DropNotNullInfo::DropNotNullInfo(string schema_p, string table_p, bool if_exists_p, string column_name_p)
-    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, move(schema_p), move(table_p), if_exists_p),
-      column_name(move(column_name_p)) {
+DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
+    : AlterTableInfo(AlterTableType::DROP_NOT_NULL, move(data)), column_name(move(column_name_p)) {
 }
 DropNotNullInfo::~DropNotNullInfo() {
 }
 
 unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
-	return make_unique_base<AlterInfo, DropNotNullInfo>(schema, name, if_exists, column_name);
+	return make_unique_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
 void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteString(column_name);
 }
 
-unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, string schema, string table, bool if_exists) {
+unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto column_name = reader.ReadRequired<string>();
-	return make_unique<DropNotNullInfo>(move(schema), move(table), if_exists, move(column_name));
+	return make_unique<DropNotNullInfo>(move(data), move(column_name));
 }
 
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
-AlterForeignKeyInfo::AlterForeignKeyInfo(string schema_p, string table_p, bool if_exists_p, string fk_table,
-                                         vector<string> pk_columns, vector<string> fk_columns,
-                                         vector<PhysicalIndex> pk_keys, vector<PhysicalIndex> fk_keys,
-                                         AlterForeignKeyType type_p)
-    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, move(schema_p), move(table_p), if_exists_p),
-      fk_table(move(fk_table)), pk_columns(move(pk_columns)), fk_columns(move(fk_columns)), pk_keys(move(pk_keys)),
-      fk_keys(move(fk_keys)), type(type_p) {
+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)
+    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, move(data)), fk_table(move(fk_table)),
+      pk_columns(move(pk_columns)), fk_columns(move(fk_columns)), pk_keys(move(pk_keys)), fk_keys(move(fk_keys)),
+      type(type_p) {
 }
 AlterForeignKeyInfo::~AlterForeignKeyInfo() {
 }
 
 unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
-	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(schema, name, if_exists, fk_table, pk_columns, fk_columns,
+	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(GetAlterEntryData(), fk_table, pk_columns, fk_columns,
 	                                                        pk_keys, fk_keys, type);
 }
 
@@ -316,23 +312,23 @@ void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
 	writer.WriteField<AlterForeignKeyType>(type);
 }
 
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, string schema, string table,
-                                                       bool if_exists) {
+unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto fk_table = reader.ReadRequired<string>();
 	auto pk_columns = reader.ReadRequiredList<string>();
 	auto fk_columns = reader.ReadRequiredList<string>();
 	auto pk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto fk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
 	auto type = reader.ReadRequired<AlterForeignKeyType>();
-	return make_unique<AlterForeignKeyInfo>(move(schema), move(table), if_exists, move(fk_table), move(pk_columns),
-	                                        move(fk_columns), move(pk_keys), move(fk_keys), type);
+	return make_unique<AlterForeignKeyInfo>(move(data), move(fk_table), move(pk_columns), move(fk_columns),
+	                                        move(pk_keys), move(fk_keys), type);
 }
 
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
-AlterViewInfo::AlterViewInfo(AlterViewType type, string schema_p, string view_p, bool if_exists_p)
-    : AlterInfo(AlterType::ALTER_VIEW, move(schema_p), move(view_p), if_exists_p), alter_view_type(type) {
+AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
+    : AlterInfo(AlterType::ALTER_VIEW, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+      alter_view_type(type) {
 }
 AlterViewInfo::~AlterViewInfo() {
 }
@@ -343,6 +339,7 @@ CatalogType AlterViewInfo::GetCatalogType() const {
 
 void AlterViewInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteField<AlterViewType>(alter_view_type);
+	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
 	writer.WriteField<bool>(if_exists);
@@ -351,13 +348,15 @@ void AlterViewInfo::Serialize(FieldWriter &writer) const {
 
 unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 	auto type = reader.ReadRequired<AlterViewType>();
-	auto schema = reader.ReadRequired<string>();
-	auto view = reader.ReadRequired<string>();
-	auto if_exists = reader.ReadRequired<bool>();
+	AlterEntryData data;
+	data.catalog = reader.ReadRequired<string>();
+	data.schema = reader.ReadRequired<string>();
+	data.name = reader.ReadRequired<string>();
+	data.if_exists = reader.ReadRequired<bool>();
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(reader, schema, view, if_exists);
+		return RenameViewInfo::Deserialize(reader, move(data));
 	default:
 		throw SerializationException("Unknown alter view type for deserialization!");
 	}
@@ -366,23 +365,22 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
-RenameViewInfo::RenameViewInfo(string schema_p, string view_p, bool if_exists_p, string new_name_p)
-    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(schema_p), move(view_p), if_exists_p),
-      new_view_name(move(new_name_p)) {
+RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
+    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(data)), new_view_name(move(new_name_p)) {
 }
 RenameViewInfo::~RenameViewInfo() {
 }
 
 unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameViewInfo>(schema, name, if_exists, new_view_name);
+	return make_unique_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
 }
 
 void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
 	writer.WriteString(new_view_name);
 }
 
-unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, string schema, string view, bool if_exists) {
+unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
 	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameViewInfo>(move(schema), move(view), if_exists, new_name);
+	return make_unique<RenameViewInfo>(move(data), new_name);
 }
 } // namespace duckdb

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

@@ -0,0 +1,27 @@
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
+
+namespace duckdb {
+
+CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunction function)
+    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
+	name = function.name;
+	functions.AddFunction(move(function));
+	internal = true;
+}
+
+CreateAggregateFunctionInfo::CreateAggregateFunctionInfo(AggregateFunctionSet set)
+    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+	name = functions.name;
+	for (auto &func : functions.functions) {
+		func.name = functions.name;
+	}
+	internal = true;
+}
+
+unique_ptr<CreateInfo> CreateAggregateFunctionInfo::Copy() const {
+	auto result = make_unique<CreateAggregateFunctionInfo>(functions);
+	CopyProperties(*result);
+	return move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,23 @@
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
+
+namespace duckdb {
+
+CreateCollationInfo::CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p,
+                                         bool not_required_for_equality_p)
+    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
+      not_required_for_equality(not_required_for_equality_p) {
+	this->name = move(name_p);
+	internal = true;
+}
+
+void CreateCollationInfo::SerializeInternal(Serializer &) const {
+	throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
+}
+
+unique_ptr<CreateInfo> CreateCollationInfo::Copy() const {
+	auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+	CopyProperties(*result);
+	return move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,21 @@
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+
+namespace duckdb {
+
+CreateCopyFunctionInfo::CreateCopyFunctionInfo(CopyFunction function_p)
+    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(move(function_p)) {
+	this->name = function.name;
+	internal = true;
+}
+
+void CreateCopyFunctionInfo::SerializeInternal(Serializer &) const {
+	throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
+}
+
+unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
+	auto result = make_unique<CreateCopyFunctionInfo>(function);
+	CopyProperties(*result);
+	return move(result);
+}
+
+} // namespace duckdb

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

@@ -8,6 +8,7 @@
 
 namespace duckdb {
 void CreateInfo::DeserializeBase(Deserializer &deserializer) {
+	this->catalog = deserializer.Read<string>();
 	this->schema = deserializer.Read<string>();
 	this->on_conflict = deserializer.Read<OnCreateConflict>();
 	this->temporary = deserializer.Read<bool>();
@@ -17,6 +18,7 @@ void CreateInfo::DeserializeBase(Deserializer &deserializer) {
 
 void CreateInfo::Serialize(Serializer &serializer) const {
 	serializer.Write(type);
+	serializer.WriteString(catalog);
 	serializer.WriteString(schema);
 	serializer.Write(on_conflict);
 	serializer.Write(temporary);
@@ -47,6 +49,7 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &source, PlanDeseria
 
 void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.type = type;
+	other.catalog = catalog;
 	other.schema = schema;
 	other.on_conflict = on_conflict;
 	other.temporary = temporary;

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

@@ -0,0 +1,23 @@
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+
+namespace duckdb {
+
+CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(PragmaFunction function)
+    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(function.name) {
+	name = function.name;
+	functions.AddFunction(move(function));
+	internal = true;
+}
+CreatePragmaFunctionInfo::CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_p)
+    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(move(functions_p)) {
+	this->name = move(name);
+	internal = true;
+}
+
+unique_ptr<CreateInfo> CreatePragmaFunctionInfo::Copy() const {
+	auto result = make_unique<CreatePragmaFunctionInfo>(functions.name, functions);
+	CopyProperties(*result);
+	return move(result);
+}
+
+} // namespace duckdb

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

@@ -7,6 +7,7 @@ CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunction function)
     : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(function.name) {
 	name = function.name;
 	functions.AddFunction(move(function));
+	internal = true;
 }
 CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
     : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(move(set)) {
@@ -14,6 +15,7 @@ CreateScalarFunctionInfo::CreateScalarFunctionInfo(ScalarFunctionSet set)
 	for (auto &func : functions.functions) {
 		func.name = functions.name;
 	}
+	internal = true;
 }
 
 unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
@@ -25,7 +27,7 @@ unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
 }
 
 unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {
-	return make_unique_base<AlterInfo, AddFunctionOverloadInfo>(schema, name, true, functions);
+	return make_unique_base<AlterInfo, AddFunctionOverloadInfo>(AlterEntryData(catalog, schema, name, true), functions);
 }
 
 } // namespace duckdb

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

@@ -0,0 +1,28 @@
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+
+namespace duckdb {
+
+CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunction function)
+    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(function.name) {
+	name = function.name;
+	functions.AddFunction(move(function));
+	internal = true;
+}
+CreateTableFunctionInfo::CreateTableFunctionInfo(TableFunctionSet set)
+    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(move(set)) {
+	name = functions.name;
+	for (auto &func : functions.functions) {
+		func.name = functions.name;
+	}
+	internal = true;
+}
+
+unique_ptr<CreateInfo> CreateTableFunctionInfo::Copy() const {
+	TableFunctionSet set(name);
+	set.functions = functions.functions;
+	auto result = make_unique<CreateTableFunctionInfo>(move(set));
+	CopyProperties(*result);
+	return move(result);
+}
+
+} // namespace duckdb