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

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

@@ -21,8 +21,8 @@ enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
 // Change Ownership
 //===--------------------------------------------------------------------===//
 struct ChangeOwnershipInfo : public AlterInfo {
-	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema, string entry_name, string owner_schema,
-	                    string owner_name, bool if_exists);
+	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
+	                    string owner_schema, string owner_name, bool if_exists);
 
 	// Catalog type refers to the entry type, since this struct is usually built from an
 	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement
@@ -55,7 +55,7 @@ enum class AlterTableType : uint8_t {
 };
 
 struct AlterTableInfo : public AlterInfo {
-	AlterTableInfo(AlterTableType type, string schema, string table, bool if_exists);
+	AlterTableInfo(AlterTableType type, AlterEntryData data);
 	~AlterTableInfo() override;
 
 	AlterTableType alter_table_type;
@@ -71,7 +71,7 @@ public:
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
 struct RenameColumnInfo : public AlterTableInfo {
-	RenameColumnInfo(string schema, string table, bool if_exists, string old_name_p, string new_name_p);
+	RenameColumnInfo(AlterEntryData data, string old_name_p, string new_name_p);
 	~RenameColumnInfo() override;
 
 	//! Column old name
@@ -82,14 +82,14 @@ struct RenameColumnInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
 struct RenameTableInfo : public AlterTableInfo {
-	RenameTableInfo(string schema, string table, bool if_exists, string new_name);
+	RenameTableInfo(AlterEntryData data, string new_name);
 	~RenameTableInfo() override;
 
 	//! Relation new name
@@ -98,14 +98,14 @@ struct RenameTableInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
 struct AddColumnInfo : public AlterTableInfo {
-	AddColumnInfo(string schema, string table, bool if_exists, ColumnDefinition new_column, bool if_column_not_exists);
+	AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists);
 	~AddColumnInfo() override;
 
 	//! New column
@@ -116,15 +116,14 @@ struct AddColumnInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
 struct RemoveColumnInfo : public AlterTableInfo {
-	RemoveColumnInfo(string schema, string table, bool if_exists, string removed_column, bool if_column_exists,
-	                 bool cascade);
+	RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade);
 	~RemoveColumnInfo() override;
 
 	//! The column to remove
@@ -137,14 +136,14 @@ struct RemoveColumnInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
 struct ChangeColumnTypeInfo : public AlterTableInfo {
-	ChangeColumnTypeInfo(string schema, string table, bool if_exists, string column_name, LogicalType target_type,
+	ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
 	                     unique_ptr<ParsedExpression> expression);
 	~ChangeColumnTypeInfo() override;
 
@@ -158,15 +157,14 @@ struct ChangeColumnTypeInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
 struct SetDefaultInfo : public AlterTableInfo {
-	SetDefaultInfo(string schema, string table, bool if_exists, string column_name,
-	               unique_ptr<ParsedExpression> new_default);
+	SetDefaultInfo(AlterEntryData data, string column_name, unique_ptr<ParsedExpression> new_default);
 	~SetDefaultInfo() override;
 
 	//! The column name to alter
@@ -177,16 +175,15 @@ struct SetDefaultInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
 struct AlterForeignKeyInfo : public AlterTableInfo {
-	AlterForeignKeyInfo(string schema, string table, bool if_exists, string fk_table, vector<string> pk_columns,
-	                    vector<string> fk_columns, vector<PhysicalIndex> pk_keys, vector<PhysicalIndex> fk_keys,
-	                    AlterForeignKeyType type);
+	AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns, vector<string> fk_columns,
+	                    vector<PhysicalIndex> pk_keys, vector<PhysicalIndex> fk_keys, AlterForeignKeyType type);
 	~AlterForeignKeyInfo() override;
 
 	string fk_table;
@@ -199,7 +196,39 @@ struct AlterForeignKeyInfo : public AlterTableInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+};
+
+//===--------------------------------------------------------------------===//
+// SetNotNullInfo
+//===--------------------------------------------------------------------===//
+struct SetNotNullInfo : public AlterTableInfo {
+	SetNotNullInfo(AlterEntryData data, string column_name);
+	~SetNotNullInfo() override;
+
+	//! The column name to alter
+	string column_name;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
+};
+
+//===--------------------------------------------------------------------===//
+// DropNotNullInfo
+//===--------------------------------------------------------------------===//
+struct DropNotNullInfo : public AlterTableInfo {
+	DropNotNullInfo(AlterEntryData data, string column_name);
+	~DropNotNullInfo() override;
+
+	//! The column name to alter
+	string column_name;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+	void SerializeAlterTable(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 //===--------------------------------------------------------------------===//
@@ -208,7 +237,7 @@ public:
 enum class AlterViewType : uint8_t { INVALID = 0, RENAME_VIEW = 1 };
 
 struct AlterViewInfo : public AlterInfo {
-	AlterViewInfo(AlterViewType type, string schema, string view, bool if_exists);
+	AlterViewInfo(AlterViewType type, AlterEntryData data);
 	~AlterViewInfo() override;
 
 	AlterViewType alter_view_type;
@@ -224,7 +253,7 @@ public:
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
 struct RenameViewInfo : public AlterViewInfo {
-	RenameViewInfo(string schema, string view, bool if_exists, string new_name);
+	RenameViewInfo(AlterEntryData data, string new_name);
 	~RenameViewInfo() override;
 
 	//! Relation new name
@@ -233,39 +262,7 @@ struct RenameViewInfo : public AlterViewInfo {
 public:
 	unique_ptr<AlterInfo> Copy() const override;
 	void SerializeAlterView(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string view, bool if_exists);
-};
-
-//===--------------------------------------------------------------------===//
-// SetNotNullInfo
-//===--------------------------------------------------------------------===//
-struct SetNotNullInfo : public AlterTableInfo {
-	SetNotNullInfo(string schema, string table, bool if_exists, string column_name);
-	~SetNotNullInfo() override;
-
-	//! The column name to alter
-	string column_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
-};
-
-//===--------------------------------------------------------------------===//
-// DropNotNullInfo
-//===--------------------------------------------------------------------===//
-struct DropNotNullInfo : public AlterTableInfo {
-	DropNotNullInfo(string schema, string table, bool if_exists, string column_name);
-	~DropNotNullInfo() override;
-
-	//! The column name to alter
-	string column_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table, bool if_exists);
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, AlterEntryData data);
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/attach_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+
+struct AttachInfo : public ParseInfo {
+	AttachInfo() {
+	}
+
+	//! The alias of the attached database
+	string name;
+	//! The path to the attached database
+	string path;
+	//! Set of (key, value) options
+	unordered_map<string, Value> options;
+
+public:
+	unique_ptr<AttachInfo> Copy() const {
+		auto result = make_unique<AttachInfo>();
+		result->name = name;
+		result->path = path;
+		result->options = options;
+		return result;
+	}
+};
+
+} // namespace duckdb

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

@@ -16,9 +16,11 @@
 namespace duckdb {
 
 struct CopyInfo : public ParseInfo {
-	CopyInfo() : schema(DEFAULT_SCHEMA) {
+	CopyInfo() : catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA) {
 	}
 
+	//! The catalog name to copy to/from
+	string catalog;
 	//! The schema name to copy to/from
 	string schema;
 	//! The table name to copy to/from
@@ -37,6 +39,7 @@ struct CopyInfo : public ParseInfo {
 public:
 	unique_ptr<CopyInfo> Copy() const {
 		auto result = make_unique<CopyInfo>();
+		result->catalog = catalog;
 		result->schema = schema;
 		result->table = table;
 		result->select_list = select_list;

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

@@ -14,28 +14,13 @@
 namespace duckdb {
 
 struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
-
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
-		name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
+	explicit CreateAggregateFunctionInfo(AggregateFunction function);
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set);
 
 	AggregateFunctionSet functions;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
 };
 
 } // namespace duckdb

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

@@ -14,11 +14,8 @@
 namespace duckdb {
 
 struct CreateCollationInfo : public CreateInfo {
-	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);
-	}
+	DUCKDB_API CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p,
+	                               bool not_required_for_equality_p);
 
 	//! The name of the collation
 	string name;
@@ -32,16 +29,10 @@ struct CreateCollationInfo : public CreateInfo {
 	bool not_required_for_equality;
 
 protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-	}
+	void SerializeInternal(Serializer &) const override;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
-		CopyProperties(*result);
-		return move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
 };
 
 } // namespace duckdb

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

@@ -14,10 +14,7 @@
 namespace duckdb {
 
 struct CreateCopyFunctionInfo : public CreateInfo {
-	explicit CreateCopyFunctionInfo(CopyFunction function)
-	    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(function) {
-		this->name = function.name;
-	}
+	DUCKDB_API explicit CreateCopyFunctionInfo(CopyFunction function);
 
 	//! Function name
 	string name;
@@ -25,16 +22,10 @@ struct CreateCopyFunctionInfo : public CreateInfo {
 	CopyFunction function;
 
 protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-	}
+	void SerializeInternal(Serializer &) const override;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCopyFunctionInfo>(function);
-		CopyProperties(*result);
-		return move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
 };
 
 } // namespace duckdb

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

@@ -44,7 +44,7 @@ protected:
 	void SerializeInternal(Serializer &serializer) const override;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override;
+	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
 
 	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
 };

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

@@ -28,15 +28,17 @@ enum class OnCreateConflict : uint8_t {
 };
 
 struct CreateInfo : public ParseInfo {
-	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA)
-	    : type(type), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT), temporary(false),
-	      internal(false) {
+	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA, string catalog_p = INVALID_CATALOG)
+	    : type(type), catalog(move(catalog_p)), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT),
+	      temporary(false), internal(false) {
 	}
 	~CreateInfo() override {
 	}
 
 	//! The to-be-created catalog type
 	CatalogType type;
+	//! The catalog name of the entry
+	string catalog;
 	//! The schema name of the entry
 	string schema;
 	//! What to do on create conflict

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

@@ -15,24 +15,13 @@
 namespace duckdb {
 
 struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
-	explicit CreatePragmaFunctionInfo(PragmaFunction function)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
-	CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(functions_) {
-		this->name = name;
-	}
+	DUCKDB_API explicit CreatePragmaFunctionInfo(PragmaFunction function);
+	DUCKDB_API CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_);
 
 	PragmaFunctionSet functions;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreatePragmaFunctionInfo>(functions.name, functions);
-		CopyProperties(*result);
-		return move(result);
-	}
+	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
 };
 
 } // namespace duckdb

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

@@ -14,30 +14,14 @@
 namespace duckdb {
 
 struct CreateTableFunctionInfo : public CreateFunctionInfo {
-	explicit CreateTableFunctionInfo(TableFunction function)
-	    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
-	explicit CreateTableFunctionInfo(TableFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(move(set)) {
-		name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
+	DUCKDB_API explicit CreateTableFunctionInfo(TableFunction function);
+	DUCKDB_API explicit CreateTableFunctionInfo(TableFunctionSet set);
 
 	//! The table functions
 	TableFunctionSet functions;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		TableFunctionSet set(name);
-		set.functions = functions.functions;
-		auto result = make_unique<CreateTableFunctionInfo>(move(set));
-		CopyProperties(*result);
-		return move(result);
-	}
+	DUCKDB_API unique_ptr<CreateInfo> Copy() const;
 };
 
 } // namespace duckdb

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

@@ -17,10 +17,12 @@
 #include "duckdb/parser/column_list.hpp"
 
 namespace duckdb {
+class SchemaCatalogEntry;
 
 struct CreateTableInfo : public CreateInfo {
 	DUCKDB_API CreateTableInfo();
-	DUCKDB_API CreateTableInfo(string schema, string name);
+	DUCKDB_API CreateTableInfo(string catalog, string schema, string name);
+	DUCKDB_API CreateTableInfo(SchemaCatalogEntry *schema, string name);
 
 	//! Table name to insert to
 	string table;

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

@@ -12,13 +12,12 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 
 namespace duckdb {
+class SchemaCatalogEntry;
 
 struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
-	}
-	CreateViewInfo(string schema, string view_name)
-	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
-	}
+	CreateViewInfo();
+	CreateViewInfo(SchemaCatalogEntry *schema, string view_name);
+	CreateViewInfo(string catalog_p, string schema_p, string view_name);
 
 	//! Table name to insert to
 	string view_name;
@@ -30,38 +29,12 @@ struct CreateViewInfo : public CreateInfo {
 	unique_ptr<SelectStatement> query;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateViewInfo>(schema, view_name);
-		CopyProperties(*result);
-		result->aliases = aliases;
-		result->types = types;
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-		return move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
 
-	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &deserializer) {
-		auto result = make_unique<CreateViewInfo>();
-		result->DeserializeBase(deserializer);
-
-		FieldReader reader(deserializer);
-		result->view_name = reader.ReadRequired<string>();
-		result->aliases = reader.ReadRequiredList<string>();
-		result->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		result->query = reader.ReadOptional<SelectStatement>(nullptr);
-		reader.Finalize();
-
-		return result;
-	}
+	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &deserializer);
 
 protected:
-	void SerializeInternal(Serializer &serializer) const override {
-		FieldWriter writer(serializer);
-		writer.WriteString(view_name);
-		writer.WriteList<string>(aliases);
-		writer.WriteRegularSerializableList(types);
-		writer.WriteOptional(query);
-		writer.Finalize();
-	}
+	void SerializeInternal(Serializer &serializer) const override;
 };
 
 } // namespace duckdb

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

@@ -14,11 +14,13 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
-	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
 	}
 
 	//! The catalog type to drop
 	CatalogType type;
+	//! Catalog name to drop from, if any
+	string catalog;
 	//! Schema name to drop from, if any
 	string schema;
 	//! Element name to drop
@@ -28,15 +30,19 @@ struct DropInfo : public ParseInfo {
 	//! Cascade drop (drop all dependents instead of throwing an error if there
 	//! are any)
 	bool cascade = false;
+	//! Allow dropping of internal system entries
+	bool allow_drop_internal = false;
 
 public:
 	unique_ptr<DropInfo> Copy() const {
 		auto result = make_unique<DropInfo>();
 		result->type = type;
+		result->catalog = catalog;
 		result->schema = schema;
 		result->name = name;
 		result->if_exists = if_exists;
 		result->cascade = cascade;
+		result->allow_drop_internal = allow_drop_internal;
 		return result;
 	}
 };

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

@@ -21,6 +21,9 @@ struct ExportedTableData {
 	//! Name of the schema
 	string schema_name;
 
+	//! Name of the database
+	string database_name;
+
 	//! Path to be exported
 	string file_path;
 };

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

@@ -62,8 +62,8 @@ struct ParserExtensionPlanResult {
 	TableFunction function;
 	//! Parameters to the function
 	vector<Value> parameters;
-	//! Whether or not the statement is read_only (i.e. can be executed in a read_only database)
-	bool read_only = false;
+	//! The set of databases that will be modified by this statement (empty for a read-only statement)
+	unordered_set<string> modified_databases;
 	//! Whether or not the statement requires a valid transaction to be executed
 	bool requires_valid_transaction = true;
 	//! What type of result set the statement returns

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

@@ -16,12 +16,14 @@
 namespace duckdb {
 
 struct QualifiedName {
+	string catalog;
 	string schema;
 	string name;
 
 	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
 	//! the schema will be set to INVALID_SCHEMA
 	static QualifiedName Parse(const string &input) {
+		string catalog;
 		string schema;
 		string name;
 		idx_t idx = 0;
@@ -57,15 +59,21 @@ struct QualifiedName {
 		throw ParserException("Unterminated quote in qualified name!");
 	end:
 		if (entries.empty()) {
+			catalog = INVALID_CATALOG;
 			schema = INVALID_SCHEMA;
 			name = entry;
 		} else if (entries.size() == 1) {
+			catalog = INVALID_CATALOG;
 			schema = entries[0];
 			name = entry;
+		} else if (entries.size() == 2) {
+			catalog = entries[0];
+			schema = entries[1];
+			name = entry;
 		} else {
-			throw ParserException("Expected schema.entry or entry: too many entries found");
+			throw ParserException("Expected catalog.entry, schema.entry or entry: too many entries found");
 		}
-		return QualifiedName {schema, name};
+		return QualifiedName {catalog, schema, name};
 	}
 };