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

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

@@ -1,12 +1,18 @@
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 
 CreateTableInfo::CreateTableInfo() : CreateInfo(CatalogType::TABLE_ENTRY, INVALID_SCHEMA) {
 }
 
-CreateTableInfo::CreateTableInfo(string schema_p, string name_p)
-    : CreateInfo(CatalogType::TABLE_ENTRY, move(schema_p)), table(move(name_p)) {
+CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_p)
+    : CreateInfo(CatalogType::TABLE_ENTRY, move(schema_p), move(catalog_p)), table(move(name_p)) {
+}
+
+CreateTableInfo::CreateTableInfo(SchemaCatalogEntry *schema, string name_p)
+    : CreateTableInfo(schema->catalog->GetName(), schema->name, move(name_p)) {
 }
 
 void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
@@ -33,7 +39,7 @@ unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deseriali
 }
 
 unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
-	auto result = make_unique<CreateTableInfo>(schema, table);
+	auto result = make_unique<CreateTableInfo>(catalog, schema, table);
 	CopyProperties(*result);
 	result->columns = columns.Copy();
 	for (auto &constraint : constraints) {

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

@@ -0,0 +1,49 @@
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateViewInfo::CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+}
+CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_name_p)
+    : CreateInfo(CatalogType::VIEW_ENTRY, move(schema_p), move(catalog_p)), view_name(move(view_name_p)) {
+}
+
+CreateViewInfo::CreateViewInfo(SchemaCatalogEntry *schema, string view_name)
+    : CreateViewInfo(schema->catalog->GetName(), schema->name, move(view_name)) {
+}
+
+unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
+	auto result = make_unique<CreateViewInfo>(catalog, 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<CreateViewInfo> 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;
+}
+
+void CreateViewInfo::SerializeInternal(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(view_name);
+	writer.WriteList<string>(aliases);
+	writer.WriteRegularSerializableList(types);
+	writer.WriteOptional(query);
+	writer.Finalize();
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/attach_statement.cpp

@@ -0,0 +1,15 @@
+#include "duckdb/parser/statement/attach_statement.hpp"
+
+namespace duckdb {
+
+AttachStatement::AttachStatement() : SQLStatement(StatementType::ATTACH_STATEMENT) {
+}
+
+AttachStatement::AttachStatement(const AttachStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
+unique_ptr<SQLStatement> AttachStatement::Copy() const {
+	return unique_ptr<AttachStatement>(new AttachStatement(*this));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -4,13 +4,14 @@
 
 namespace duckdb {
 
-InsertStatement::InsertStatement() : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA) {
+InsertStatement::InsertStatement()
+    : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA), catalog(INVALID_CATALOG) {
 }
 
 InsertStatement::InsertStatement(const InsertStatement &other)
     : SQLStatement(other),
       select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
-      columns(other.columns), table(other.table), schema(other.schema) {
+      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
 	cte_map = other.cte_map.Copy();
 }
 
@@ -18,6 +19,9 @@ string InsertStatement::ToString() const {
 	string result;
 	result = cte_map.ToString();
 	result += "INSERT INTO ";
+	if (!catalog.empty()) {
+		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
+	}
 	if (!schema.empty()) {
 		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
 	}

package/src/duckdb/src/parser/tableref/basetableref.cpp

@@ -6,8 +6,10 @@
 namespace duckdb {
 
 string BaseTableRef::ToString() const {
-	string schema = schema_name.empty() ? "" : KeywordHelper::WriteOptionallyQuoted(schema_name) + ".";
-	string result = schema + KeywordHelper::WriteOptionallyQuoted(table_name);
+	string result;
+	result += catalog_name.empty() ? "" : (KeywordHelper::WriteOptionallyQuoted(catalog_name) + ".");
+	result += schema_name.empty() ? "" : (KeywordHelper::WriteOptionallyQuoted(schema_name) + ".");
+	result += KeywordHelper::WriteOptionallyQuoted(table_name);
 	return BaseToString(result, column_name_alias);
 }
 
@@ -16,14 +18,15 @@ bool BaseTableRef::Equals(const TableRef *other_p) const {
 		return false;
 	}
 	auto other = (BaseTableRef *)other_p;
-	return other->schema_name == schema_name && other->table_name == table_name &&
-	       column_name_alias == other->column_name_alias;
+	return other->catalog_name == catalog_name && other->schema_name == schema_name &&
+	       other->table_name == table_name && column_name_alias == other->column_name_alias;
 }
 
 void BaseTableRef::Serialize(FieldWriter &writer) const {
 	writer.WriteString(schema_name);
 	writer.WriteString(table_name);
 	writer.WriteList<string>(column_name_alias);
+	writer.WriteString(catalog_name);
 }
 
 unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
@@ -32,6 +35,7 @@ unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
 	result->schema_name = reader.ReadRequired<string>();
 	result->table_name = reader.ReadRequired<string>();
 	result->column_name_alias = reader.ReadRequiredList<string>();
+	result->catalog_name = reader.ReadField<string>(INVALID_CATALOG);
 
 	return move(result);
 }
@@ -39,6 +43,7 @@ unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
 unique_ptr<TableRef> BaseTableRef::Copy() {
 	auto copy = make_unique<BaseTableRef>();
 
+	copy->catalog_name = catalog_name;
 	copy->schema_name = schema_name;
 	copy->table_name = table_name;
 	copy->column_name_alias = column_name_alias;

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -5,6 +5,18 @@
 
 namespace duckdb {
 
+static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, ForeignKeyInfo &fk_info) {
+	if (input->catalogname) {
+		throw ParserException("FOREIGN KEY constraints cannot be defined cross-database");
+	}
+	if (input->schemaname) {
+		fk_info.schema = input->schemaname;
+	} else {
+		fk_info.schema = "";
+	};
+	fk_info.table = input->relname;
+}
+
 unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
 	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
 	switch (constraint->contype) {
@@ -27,12 +39,7 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
 		ForeignKeyInfo fk_info;
 		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		if (constraint->pktable->schemaname) {
-			fk_info.schema = constraint->pktable->schemaname;
-		} else {
-			fk_info.schema = "";
-		}
-		fk_info.table = constraint->pktable->relname;
+		ParseSchemaTableNameFK(constraint->pktable, fk_info);
 		vector<string> pk_columns, fk_columns;
 		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
 			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
@@ -92,14 +99,9 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
 		ForeignKeyInfo fk_info;
 		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		if (constraint->pktable->schemaname) {
-			fk_info.schema = constraint->pktable->schemaname;
-		} else {
-			fk_info.schema = "";
-		}
-		fk_info.table = constraint->pktable->relname;
-		vector<string> pk_columns, fk_columns;
+		ParseSchemaTableNameFK(constraint->pktable, fk_info);
 
+		vector<string> pk_columns, fk_columns;
 		fk_columns.emplace_back(column.Name().c_str());
 		if (constraint->pk_attrs) {
 			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -96,15 +96,24 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_sp
 
 unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
 	auto name = root->funcname;
-	string schema, function_name;
-	if (name->length == 2) {
+	string catalog, schema, function_name;
+	if (name->length == 3) {
+		// catalog + schema + name
+		catalog = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
+		schema = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->data.ptr_value)->val.str;
+		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->next->data.ptr_value)->val.str;
+	} else if (name->length == 2) {
 		// schema + name
+		catalog = INVALID_CATALOG;
 		schema = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
 		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->data.ptr_value)->val.str;
-	} else {
+	} else if (name->length == 1) {
 		// unqualified name
+		catalog = INVALID_CATALOG;
 		schema = INVALID_SCHEMA;
 		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
+	} else {
+		throw InternalException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
 	}
 
 	auto lowercase_name = StringUtil::Lower(function_name);
@@ -134,7 +143,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("IGNORE NULLS is not supported for windowed aggregates");
 		}
 
-		auto expr = make_unique<WindowExpression>(win_fun_type, schema, lowercase_name);
+		auto expr = make_unique<WindowExpression>(win_fun_type, move(catalog), move(schema), lowercase_name);
 		expr->ignore_nulls = root->agg_ignore_nulls;
 
 		if (root->agg_filter) {
@@ -282,8 +291,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		return move(coalesce_op);
 	}
 
-	auto function = make_unique<FunctionExpression>(schema, lowercase_name.c_str(), move(children), move(filter_expr),
-	                                                move(order_bys), root->agg_distinct, false, root->export_state);
+	auto function = make_unique<FunctionExpression>(move(catalog), move(schema), lowercase_name.c_str(), move(children),
+	                                                move(filter_expr), move(order_bys), root->agg_distinct, false,
+	                                                root->export_state);
 	function->query_location = root->location;
 
 	return move(function);
@@ -330,7 +340,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpg
 	D_ASSERT(node);
 	vector<unique_ptr<ParsedExpression>> children;
 	auto fname = SQLValueOpToString(node->op);
-	return make_unique<FunctionExpression>(DEFAULT_SCHEMA, fname, move(children));
+	return make_unique<FunctionExpression>(fname, move(children));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_operator.cpp

@@ -15,21 +15,17 @@
 namespace duckdb {
 
 unique_ptr<ParsedExpression> Transformer::TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child) {
-	const auto schema = DEFAULT_SCHEMA;
-
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(move(child));
 
 	// built-in operator function
-	auto result = make_unique<FunctionExpression>(schema, op, move(children));
+	auto result = make_unique<FunctionExpression>(op, move(children));
 	result->is_operator = true;
 	return move(result);
 }
 
 unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
                                                                   unique_ptr<ParsedExpression> right) {
-	const auto schema = DEFAULT_SCHEMA;
-
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(move(left));
 	children.push_back(move(right));
@@ -38,7 +34,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &
 		// rewrite 'asdf' SIMILAR TO '.*sd.*' into regexp_full_match('asdf', '.*sd.*')
 		bool invert_similar = op == "!~";
 
-		auto result = make_unique<FunctionExpression>(schema, "regexp_full_match", move(children));
+		auto result = make_unique<FunctionExpression>("regexp_full_match", move(children));
 		if (invert_similar) {
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(result));
 		} else {
@@ -51,7 +47,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &
 			return make_unique<ComparisonExpression>(target_type, move(children[0]), move(children[1]));
 		}
 		// not a special operator: convert to a function expression
-		auto result = make_unique<FunctionExpression>(schema, op, move(children));
+		auto result = make_unique<FunctionExpression>(op, move(children));
 		result->is_operator = true;
 		return move(result);
 	}
@@ -165,9 +161,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			// NOT SIMILAR TO
 			invert_similar = true;
 		}
-		const auto schema = DEFAULT_SCHEMA;
 		const auto regex_function = "regexp_full_match";
-		auto result = make_unique<FunctionExpression>(schema, regex_function, move(children));
+		auto result = make_unique<FunctionExpression>(regex_function, move(children));
 
 		if (invert_similar) {
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(result));

package/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp

@@ -812,6 +812,10 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_TsmRoutine";
 	case duckdb_libpgquery::T_PGForeignKeyCacheInfo:
 		return "T_ForeignKeyCacheInfo";
+	case duckdb_libpgquery::T_PGAttachStmt:
+		return "T_PGAttachStmt";
+	case duckdb_libpgquery::T_PGUseStmt:
+		return "T_PGUseStmt";
 	default:
 		return "(UNKNOWN)";
 	}

package/src/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp

@@ -13,6 +13,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 	auto result = make_unique<AlterStatement>();
 
 	auto qname = TransformQualifiedName(stmt->sequence);
+	auto sequence_catalog = qname.catalog;
 	auto sequence_schema = qname.schema;
 	auto sequence_name = qname.name;
 
@@ -48,8 +49,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 				opt_values.emplace_back(target->name);
 			}
 			D_ASSERT(!opt_values.empty());
-			string owner_schema = "";
-			string owner_name = "";
+			string owner_schema = INVALID_SCHEMA;
+			string owner_name;
 			if (opt_values.size() == 2) {
 				owner_schema = opt_values[0];
 				owner_name = opt_values[1];
@@ -59,8 +60,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 			} else {
 				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
 			}
-			auto info = make_unique<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_schema, sequence_name,
-			                                             owner_schema, owner_name, stmt->missing_ok);
+			auto info = make_unique<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_catalog, sequence_schema,
+			                                             sequence_name, owner_schema, owner_name, stmt->missing_ok);
 			result->info = move(info);
 		} else {
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");

package/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp

@@ -21,6 +21,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 	// first we check the type of ALTER
 	for (auto c = stmt->cmds->head; c != nullptr; c = c->next) {
 		auto command = reinterpret_cast<duckdb_libpgquery::PGAlterTableCmd *>(lfirst(c));
+		AlterEntryData data(qname.catalog, qname.schema, qname.name, stmt->missing_ok);
 		// TODO: Include more options for command->subtype
 		switch (command->subtype) {
 		case duckdb_libpgquery::PG_AT_AddColumn: {
@@ -43,8 +44,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 					throw ParserException("Adding columns with constraints not yet supported");
 				}
 			}
-			result->info = make_unique<AddColumnInfo>(qname.schema, qname.name, stmt->missing_ok, move(centry),
-			                                          command->missing_ok);
+			result->info = make_unique<AddColumnInfo>(move(data), move(centry), command->missing_ok);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropColumn: {
@@ -53,8 +53,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Dropping columns is only supported for tables");
 			}
-			result->info = make_unique<RemoveColumnInfo>(qname.schema, qname.name, stmt->missing_ok, command->name,
-			                                             command->missing_ok, cascade);
+			result->info = make_unique<RemoveColumnInfo>(move(data), command->name, command->missing_ok, cascade);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_ColumnDefault: {
@@ -63,8 +62,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Alter column's default is only supported for tables");
 			}
-			result->info =
-			    make_unique<SetDefaultInfo>(qname.schema, qname.name, stmt->missing_ok, command->name, move(expr));
+			result->info = make_unique<SetDefaultInfo>(move(data), command->name, move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_AlterColumnType: {
@@ -81,16 +79,16 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 				auto colref = make_unique<ColumnRefExpression>(command->name);
 				expr = make_unique<CastExpression>(column_definition.Type(), move(colref));
 			}
-			result->info = make_unique<ChangeColumnTypeInfo>(qname.schema, qname.name, stmt->missing_ok, command->name,
-			                                                 column_definition.Type(), move(expr));
+			result->info =
+			    make_unique<ChangeColumnTypeInfo>(move(data), command->name, column_definition.Type(), move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_SetNotNull: {
-			result->info = make_unique<SetNotNullInfo>(qname.schema, qname.name, stmt->missing_ok, command->name);
+			result->info = make_unique<SetNotNullInfo>(move(data), command->name);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropNotNull: {
-			result->info = make_unique<DropNotNullInfo>(qname.schema, qname.name, stmt->missing_ok, command->name);
+			result->info = make_unique<DropNotNullInfo>(move(data), command->name);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_DropConstraint:

package/src/duckdb/src/parser/transform/statement/transform_attach.cpp

@@ -0,0 +1,32 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/statement/attach_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGNode *node) {
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAttachStmt *>(node);
+	auto result = make_unique<AttachStatement>();
+	auto info = make_unique<AttachInfo>();
+	info->name = stmt->name ? stmt->name : string();
+	info->path = stmt->path;
+
+	if (stmt->options) {
+		duckdb_libpgquery::PGListCell *cell = nullptr;
+		for_each_cell(cell, stmt->options->head) {
+			auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
+			Value val;
+			if (def_elem->arg) {
+				val = TransformValue(*((duckdb_libpgquery::PGValue *)def_elem->arg))->value;
+			} else {
+				val = Value::BOOLEAN(true);
+			}
+			info->options[StringUtil::Lower(def_elem->defname)] = move(val);
+		}
+	}
+	result->info = move(info);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/statement/transform_checkpoint.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/call_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 
@@ -9,9 +10,13 @@ unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGN
 
 	vector<unique_ptr<ParsedExpression>> children;
 	// transform into "CALL checkpoint()" or "CALL force_checkpoint()"
+	auto checkpoint_name = checkpoint->force ? "force_checkpoint" : "checkpoint";
 	auto result = make_unique<CallStatement>();
-	result->function =
-	    make_unique<FunctionExpression>(checkpoint->force ? "force_checkpoint" : "checkpoint", move(children));
+	auto function = make_unique<FunctionExpression>(checkpoint_name, move(children));
+	if (checkpoint->name) {
+		function->children.push_back(make_unique<ConstantExpression>(Value(checkpoint->name)));
+	}
+	result->function = move(function);
 	return move(result);
 }
 

package/src/duckdb/src/parser/transform/statement/transform_copy.cpp

@@ -91,6 +91,7 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 		auto &table = *reinterpret_cast<BaseTableRef *>(ref.get());
 		info.table = table.table_name;
 		info.schema = table.schema_name;
+		info.catalog = table.catalog_name;
 	} else {
 		result->select_statement = TransformSelectNode((duckdb_libpgquery::PGSelectStmt *)stmt->query);
 	}

package/src/duckdb/src/parser/transform/statement/transform_create_function.cpp

@@ -32,6 +32,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 
 	auto info =
 	    make_unique<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));
+	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->name = qname.name;
 

package/src/duckdb/src/parser/transform/statement/transform_create_schema.cpp

@@ -11,6 +11,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery
 	auto info = make_unique<CreateSchemaInfo>();
 
 	D_ASSERT(stmt->schemaname);
+	info->catalog = stmt->catalogname ? stmt->catalogname : INVALID_CATALOG;
 	info->schema = stmt->schemaname;
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 

package/src/duckdb/src/parser/transform/statement/transform_create_sequence.cpp

@@ -14,6 +14,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 	auto info = make_unique<CreateSequenceInfo>();
 
 	auto qname = TransformQualifiedName(stmt->sequence);
+	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->name = qname.name;
 

package/src/duckdb/src/parser/transform/statement/transform_create_table.cpp

@@ -78,11 +78,11 @@ unique_ptr<CreateStatement> Transformer::TransformCreateTable(duckdb_libpgquery:
 	}
 	D_ASSERT(stmt->relation);
 
-	info->schema = INVALID_SCHEMA;
-	if (stmt->relation->schemaname) {
-		info->schema = stmt->relation->schemaname;
-	}
-	info->table = stmt->relation->relname;
+	info->catalog = INVALID_CATALOG;
+	auto qname = TransformQualifiedName(stmt->relation);
+	info->catalog = qname.catalog;
+	info->schema = qname.schema;
+	info->table = qname.name;
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 	info->temporary =
 	    stmt->relation->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;

package/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp

@@ -21,6 +21,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateTableAs(duckdb_libpgquer
 
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateTableInfo>();
+	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->table = qname.name;
 	info->on_conflict = TransformOnConflict(stmt->onconflict);

package/src/duckdb/src/parser/transform/statement/transform_create_type.cpp

@@ -6,18 +6,6 @@
 
 namespace duckdb {
 
-vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list) {
-	vector<string> result;
-	if (!column_list) {
-		return result;
-	}
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
-		result.emplace_back(target->name);
-	}
-	return result;
-}
-
 Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
 	if (!column_list) {
 		Vector result(LogicalType::VARCHAR);
@@ -51,7 +39,12 @@ unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::
 	D_ASSERT(stmt);
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateTypeInfo>();
-	info->name = ReadPgListToString(stmt->typeName)[0];
+
+	auto qualified_name = TransformQualifiedName(stmt->typeName);
+	info->catalog = qualified_name.catalog;
+	info->schema = qualified_name.schema;
+	info->name = qualified_name.name;
+
 	switch (stmt->kind) {
 	case duckdb_libpgquery::PG_NEWTYPE_ENUM: {
 		info->internal = false;

package/src/duckdb/src/parser/transform/statement/transform_create_view.cpp

@@ -15,13 +15,13 @@ unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateViewInfo>();
 
-	if (stmt->view->schemaname) {
-		info->schema = stmt->view->schemaname;
-	}
-	info->view_name = stmt->view->relname;
+	auto qname = TransformQualifiedName(stmt->view);
+	info->catalog = qname.catalog;
+	info->schema = qname.schema;
+	info->view_name = qname.name;
 	info->temporary = !stmt->view->relpersistence;
-	if (info->temporary) {
-		info->schema = TEMP_SCHEMA;
+	if (info->temporary && IsInvalidCatalog(info->catalog)) {
+		info->catalog = TEMP_CATALOG;
 	}
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 

package/src/duckdb/src/parser/transform/statement/transform_drop.cpp

@@ -36,6 +36,9 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 	case duckdb_libpgquery::PG_OBJECT_TYPE:
 		info.type = CatalogType::TYPE_ENTRY;
 		break;
+	case duckdb_libpgquery::PG_OBJECT_DATABASE:
+		info.type = CatalogType::DATABASE_ENTRY;
+		break;
 	default:
 		throw NotImplementedException("Cannot drop this type yet");
 	}
@@ -52,11 +55,17 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 	}
 	default: {
 		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
-		if (view_list->length == 2) {
+		if (view_list->length == 3) {
+			info.catalog = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+			info.schema = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
+			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->next->data.ptr_value)->val.str;
+		} else if (view_list->length == 2) {
 			info.schema = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
 			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
-		} else {
+		} else if (view_list->length == 1) {
 			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+		} else {
+			throw ParserException("Expected \"catalog.schema.name\", \"schema.name\"or \"name\"");
 		}
 		break;
 	}

package/src/duckdb/src/parser/transform/statement/transform_export.cpp

@@ -12,7 +12,11 @@ unique_ptr<ExportStatement> Transformer::TransformExport(duckdb_libpgquery::PGNo
 	// handle export options
 	TransformCopyOptions(*info, stmt->options);
 
-	return make_unique<ExportStatement>(move(info));
+	auto result = make_unique<ExportStatement>(move(info));
+	if (stmt->database) {
+		result->database = stmt->database;
+	}
+	return result;
 }
 
 } // namespace duckdb