duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -12,13 +12,54 @@
 
 namespace duckdb {
 
+void Transformer::ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
+                                              duckdb_libpgquery::PGNode *arg) {
+	// otherwise
+	if (result_options.find(name) != result_options.end()) {
+		throw ParserException("Unexpected duplicate option \"%s\"", name);
+	}
+	if (!arg) {
+		result_options[name] = vector<Value>();
+		return;
+	}
+	switch (arg->type) {
+	case duckdb_libpgquery::T_PGList: {
+		auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(arg);
+		for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
+			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
+			result_options[name].push_back(Value(target->name));
+		}
+		break;
+	}
+	case duckdb_libpgquery::T_PGAStar:
+		result_options[name].push_back(Value("*"));
+		break;
+	case duckdb_libpgquery::T_PGFuncCall: {
+		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(arg);
+		auto func_expr = TransformFuncCall(*func_call);
+
+		Value value;
+		if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
+			throw ParserException("Unsupported expression in option list: %s", func_expr->ToString());
+		}
+		result_options[name].push_back(std::move(value));
+		break;
+	}
+	default: {
+		auto val = PGPointerCast<duckdb_libpgquery::PGValue>(arg);
+		result_options[name].push_back(TransformValue(*val)->value);
+		break;
+	}
+	}
+}
+
 void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpgquery::PGList> options) {
 	if (!options) {
 		return;
 	}
 
-	// iterate over each option
 	duckdb_libpgquery::PGListCell *cell;
+	// iterate over each option
 	for_each_cell(cell, options->head) {
 		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
 		if (StringUtil::Lower(def_elem->defname) == "format") {
@@ -30,43 +71,10 @@ void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpg
 			info.format = StringUtil::Lower(format_val->val.str);
 			continue;
 		}
-		// otherwise
-		if (info.options.find(def_elem->defname) != info.options.end()) {
-			throw ParserException("Unexpected duplicate option \"%s\"", def_elem->defname);
-		}
-		if (!def_elem->arg) {
-			info.options[def_elem->defname] = vector<Value>();
-			continue;
-		}
-		switch (def_elem->arg->type) {
-		case duckdb_libpgquery::T_PGList: {
-			auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
-			for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-				auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-				info.options[def_elem->defname].push_back(Value(target->name));
-			}
-			break;
-		}
-		case duckdb_libpgquery::T_PGAStar:
-			info.options[def_elem->defname].push_back(Value("*"));
-			break;
-		case duckdb_libpgquery::T_PGFuncCall: {
-			auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(def_elem->arg);
-			auto func_expr = TransformFuncCall(*func_call);
 
-			Value value;
-			if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
-				throw ParserException("Unsupported expression in COPY options: %s", func_expr->ToString());
-			}
-			info.options[def_elem->defname].push_back(std::move(value));
-			break;
-		}
-		default: {
-			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			info.options[def_elem->defname].push_back(TransformValue(*val)->value);
-			break;
-		}
-		}
+		// The rest ends up in the options
+		string name = def_elem->defname;
+		ParseGenericOptionListEntry(info.options, name, def_elem->arg);
 	}
 }
 

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

@@ -0,0 +1,29 @@
+#include "duckdb/parser/statement/copy_database_statement.hpp"
+#include "duckdb/parser/statement/pragma_statement.hpp"
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+
+namespace duckdb {
+
+unique_ptr<SQLStatement> Transformer::TransformCopyDatabase(duckdb_libpgquery::PGCopyDatabaseStmt &stmt) {
+	if (stmt.copy_database_flag) {
+		// copy a specific subset of the database
+		CopyDatabaseType type;
+		if (StringUtil::Equals(stmt.copy_database_flag, "schema")) {
+			type = CopyDatabaseType::COPY_SCHEMA;
+		} else if (StringUtil::Equals(stmt.copy_database_flag, "data")) {
+			type = CopyDatabaseType::COPY_DATA;
+		} else {
+			throw NotImplementedException("Unsupported flag for COPY DATABASE");
+		}
+		return make_uniq<CopyDatabaseStatement>(stmt.from_database, stmt.to_database, type);
+	} else {
+		auto result = make_uniq<PragmaStatement>();
+		result->info->name = "copy_database";
+		result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.from_database)));
+		result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.to_database)));
+		return std::move(result);
+	}
+}
+
+} // namespace duckdb

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

@@ -1,10 +1,10 @@
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 
@@ -42,18 +42,9 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 	}
 
 	info->on_conflict = TransformOnConflict(stmt.onconflict);
-
 	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
-	auto index_type_name = StringUtil::Upper(string(stmt.accessMethod));
-
-	if (index_type_name == "ART") {
-		info->index_type = IndexType::ART;
-	} else {
-		info->index_type = IndexType::EXTENSION;
-	}
-
-	info->index_type_name = index_type_name;
+	info->index_type = StringUtil::Upper(string(stmt.accessMethod));
 
 	if (stmt.relation->schemaname) {
 		info->schema = stmt.relation->schemaname;
@@ -65,7 +56,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 	if (stmt.idxname) {
 		info->index_name = stmt.idxname;
 	} else {
-		throw NotImplementedException("Index without a name not supported yet!");
+		throw NotImplementedException("Please provide an index name, e.g., CREATE INDEX my_name ...");
 	}
 
 	// Parse the options list

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

@@ -4,7 +4,6 @@
 #include "duckdb/parser/constraint.hpp"
 #include "duckdb/parser/expression/collate_expression.hpp"
 #include "duckdb/catalog/catalog_entry/table_column_type.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 

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

@@ -17,7 +17,7 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDe
 	result->condition = TransformExpression(stmt.whereClause);
 	result->table = TransformRangeVar(*stmt.relation);
 	if (result->table->type != TableReferenceType::BASE_TABLE) {
-		throw Exception("Can only delete from base tables!");
+		throw InvalidInputException("Can only delete from base tables!");
 	}
 	if (stmt.usingClause) {
 		for (auto n = stmt.usingClause->head; n != nullptr; n = n->next) {

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
 #include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
@@ -39,12 +40,6 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGDropStm
 	}
 
 	switch (stmt.removeType) {
-	case duckdb_libpgquery::PG_OBJECT_TYPE: {
-		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects);
-		auto target = PGPointerCast<duckdb_libpgquery::PGTypeName>(view_list->head->data.ptr_value);
-		info.name = PGPointerCast<duckdb_libpgquery::PGValue>(target->names->tail->data.ptr_value)->val.str;
-		break;
-	}
 	case duckdb_libpgquery::PG_OBJECT_SCHEMA: {
 		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects->head->data.ptr_value);
 		if (view_list->length == 2) {
@@ -79,4 +74,28 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGDropStm
 	return std::move(result);
 }
 
+unique_ptr<DropStatement> Transformer::TransformDropSecret(duckdb_libpgquery::PGDropSecretStmt &stmt) {
+	auto result = make_uniq<DropStatement>();
+	auto info = make_uniq<DropInfo>();
+	auto extra_info = make_uniq<ExtraDropSecretInfo>();
+
+	info->type = CatalogType::SECRET_ENTRY;
+	info->name = stmt.secret_name;
+	info->if_not_found = stmt.missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
+
+	extra_info->persist_mode = EnumUtil::FromString<SecretPersistType>(StringUtil::Upper(stmt.persist_type));
+	extra_info->secret_storage = stmt.secret_storage;
+
+	if (extra_info->persist_mode == SecretPersistType::TEMPORARY) {
+		if (!extra_info->secret_storage.empty()) {
+			throw ParserException("Can not combine TEMPORARY with specifying a storage for drop secret");
+		}
+	}
+
+	info->extra_drop_info = std::move(extra_info);
+	result->info = std::move(info);
+
+	return result;
+}
+
 } // namespace duckdb

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

@@ -1,12 +1,13 @@
 #include "duckdb/parser/statement/pragma_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 
 unique_ptr<PragmaStatement> Transformer::TransformImport(duckdb_libpgquery::PGImportStmt &stmt) {
 	auto result = make_uniq<PragmaStatement>();
 	result->info->name = "import_database";
-	result->info->parameters.emplace_back(stmt.filename);
+	result->info->parameters.emplace_back(make_uniq<ConstantExpression>(Value(stmt.filename)));
 	return result;
 }
 

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

@@ -27,25 +27,16 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragm
 					throw ParserException("Named parameter requires a column reference on the LHS");
 				}
 				auto &columnref = comp.left->Cast<ColumnRefExpression>();
-
-				Value rhs_value;
-				if (!Transformer::ConstructConstantFromExpression(*comp.right, rhs_value)) {
-					throw ParserException("Named parameter requires a constant on the RHS");
-				}
-
-				info.named_parameters[columnref.GetName()] = rhs_value;
-			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
-				auto constant = TransformConstant(*PGPointerCast<duckdb_libpgquery::PGAConst>(node.get()));
-				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);
+				info.named_parameters.insert(make_pair(columnref.GetName(), std::move(comp.right)));
 			} else if (expr->type == ExpressionType::COLUMN_REF) {
 				auto &colref = expr->Cast<ColumnRefExpression>();
 				if (!colref.IsQualified()) {
-					info.parameters.emplace_back(colref.GetColumnName());
+					info.parameters.emplace_back(make_uniq<ConstantExpression>(Value(colref.GetColumnName())));
 				} else {
-					info.parameters.emplace_back(expr->ToString());
+					info.parameters.emplace_back(make_uniq<ConstantExpression>(Value(expr->ToString())));
 				}
 			} else {
-				info.parameters.emplace_back(expr->ToString());
+				info.parameters.emplace_back(std::move(expr));
 			}
 		}
 	}
@@ -71,7 +62,8 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragm
 		if (sqlite_compat_pragmas.find(info.name) != sqlite_compat_pragmas.end()) {
 			break;
 		}
-		auto set_statement = make_uniq<SetVariableStatement>(info.name, info.parameters[0], SetScope::AUTOMATIC);
+		auto set_statement =
+		    make_uniq<SetVariableStatement>(info.name, std::move(info.parameters[0]), SetScope::AUTOMATIC);
 		return std::move(set_statement);
 	}
 	case duckdb_libpgquery::PG_PRAGMA_TYPE_CALL:

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

@@ -0,0 +1,103 @@
+#include "duckdb/parser/statement/create_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/transformer.hpp"
+
+namespace duckdb {
+
+void Transformer::TransformCreateSecretOptions(CreateSecretInfo &info,
+                                               optional_ptr<duckdb_libpgquery::PGList> options) {
+	if (!options) {
+		return;
+	}
+
+	duckdb_libpgquery::PGListCell *cell;
+	// iterate over each option
+	for_each_cell(cell, options->head) {
+		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
+		auto lower_name = StringUtil::Lower(def_elem->defname);
+		if (lower_name == "scope") {
+			// format specifier: interpret this option
+			auto scope_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
+			if (!scope_val) {
+				throw ParserException("Unsupported parameter type for SCOPE");
+			} else if (scope_val->type == duckdb_libpgquery::T_PGString) {
+				info.scope.push_back(scope_val->val.str);
+				continue;
+			} else if (scope_val->type != duckdb_libpgquery::T_PGList) {
+				throw ParserException("%s has to be a string, or a list of strings", lower_name);
+			}
+
+			auto list = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
+			for (auto scope_cell = list->head; scope_cell != nullptr; scope_cell = lnext(scope_cell)) {
+				auto scope_val_entry = PGPointerCast<duckdb_libpgquery::PGValue>(scope_cell->data.ptr_value);
+				info.scope.push_back(scope_val_entry->val.str);
+			}
+			continue;
+		} else if (lower_name == "type") {
+			auto type_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
+			if (type_val->type != duckdb_libpgquery::T_PGString) {
+				throw ParserException("%s has to be a string", lower_name);
+			}
+			info.type = StringUtil::Lower(type_val->val.str);
+			continue;
+		} else if (lower_name == "provider") {
+			auto provider_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
+			if (provider_val->type != duckdb_libpgquery::T_PGString) {
+				throw ParserException("%s has to be a string", lower_name);
+			}
+			info.provider = StringUtil::Lower(provider_val->val.str);
+			continue;
+		}
+
+		// All the other options end up in the generic
+		case_insensitive_map_t<vector<Value>> vector_options;
+		ParseGenericOptionListEntry(vector_options, lower_name, def_elem->arg);
+
+		for (const auto &entry : vector_options) {
+			if (entry.second.size() != 1) {
+				throw ParserException("Invalid parameter passed to option '%s'", entry.first);
+			}
+
+			if (info.options.find(entry.first) != info.options.end()) {
+				throw BinderException("Duplicate query param found while parsing create secret: '%s'", entry.first);
+			}
+
+			info.options[entry.first] = entry.second.at(0);
+		}
+	}
+}
+
+unique_ptr<CreateStatement> Transformer::TransformSecret(duckdb_libpgquery::PGCreateSecretStmt &stmt) {
+	auto result = make_uniq<CreateStatement>();
+
+	auto create_secret_info =
+	    make_uniq<CreateSecretInfo>(TransformOnConflict(stmt.onconflict),
+	                                EnumUtil::FromString<SecretPersistType>(StringUtil::Upper(stmt.persist_type)));
+
+	if (stmt.secret_name) {
+		create_secret_info->name = StringUtil::Lower(stmt.secret_name);
+	}
+
+	if (stmt.secret_storage) {
+		create_secret_info->storage_type = StringUtil::Lower(stmt.secret_storage);
+	}
+
+	if (stmt.options) {
+		TransformCreateSecretOptions(*create_secret_info, stmt.options);
+	}
+
+	if (create_secret_info->type.empty()) {
+		throw ParserException("Failed to create secret - secret must have a type defined");
+	}
+	if (create_secret_info->name.empty()) {
+		create_secret_info->name = "__default_" + create_secret_info->type;
+	}
+
+	result->info = std::move(create_secret_info);
+
+	return result;
+}
+
+} // namespace duckdb

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

@@ -30,7 +30,14 @@ unique_ptr<SelectStatement> Transformer::TransformSelect(duckdb_libpgquery::PGSe
 }
 
 unique_ptr<SelectStatement> Transformer::TransformSelect(optional_ptr<duckdb_libpgquery::PGNode> node, bool is_select) {
-	return TransformSelect(PGCast<duckdb_libpgquery::PGSelectStmt>(*node), is_select);
+	switch (node->type) {
+	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
+		return TransformShowSelect(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(*node));
+	case duckdb_libpgquery::T_PGVariableShowStmt:
+		return TransformShow(PGCast<duckdb_libpgquery::PGVariableShowStmt>(*node));
+	default:
+		return TransformSelect(PGCast<duckdb_libpgquery::PGSelectStmt>(*node), is_select);
+	}
 }
 
 } // namespace duckdb

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

@@ -19,6 +19,7 @@ void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, Quer
 		order_modifier->orders = std::move(orders);
 		node.modifiers.push_back(std::move(order_modifier));
 	}
+
 	if (stmt.limitCount || stmt.limitOffset) {
 		if (stmt.limitCount && stmt.limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
 			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
@@ -122,13 +123,12 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		result.left = TransformSelectNode(*stmt.larg);
 		result.right = TransformSelectNode(*stmt.rarg);
 		if (!result.left || !result.right) {
-			throw Exception("Failed to transform setop children.");
+			throw InternalException("Failed to transform setop children.");
 		}
 
-		bool select_distinct = true;
+		result.setop_all = stmt.all;
 		switch (stmt.op) {
 		case duckdb_libpgquery::PG_SETOP_UNION:
-			select_distinct = !stmt.all;
 			result.setop_type = SetOperationType::UNION;
 			break;
 		case duckdb_libpgquery::PG_SETOP_EXCEPT:
@@ -138,14 +138,10 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 			result.setop_type = SetOperationType::INTERSECT;
 			break;
 		case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME:
-			select_distinct = !stmt.all;
 			result.setop_type = SetOperationType::UNION_BY_NAME;
 			break;
 		default:
-			throw Exception("Unexpected setop type");
-		}
-		if (select_distinct) {
-			result.modifiers.push_back(make_uniq<DistinctModifier>());
+			throw InternalException("Unexpected setop type");
 		}
 		if (stmt.sampleOptions) {
 			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");

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

@@ -2,6 +2,7 @@
 
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
 
 namespace duckdb {
 
@@ -48,11 +49,23 @@ unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PG
 		throw ParserException("SET needs a single scalar value parameter");
 	}
 	D_ASSERT(stmt.args->head && stmt.args->head->data.ptr_value);
-	auto const_val = PGPointerCast<duckdb_libpgquery::PGAConst>(stmt.args->head->data.ptr_value);
-	D_ASSERT(const_val->type == duckdb_libpgquery::T_PGAConst);
-
-	auto value = TransformValue(const_val->val)->value;
-	return make_uniq<SetVariableStatement>(name, value, ToSetScope(stmt.scope));
+	auto const_val = PGPointerCast<duckdb_libpgquery::PGNode>(stmt.args->head->data.ptr_value);
+	auto expr = TransformExpression(const_val);
+	if (expr->type == ExpressionType::COLUMN_REF) {
+		auto &colref = expr->Cast<ColumnRefExpression>();
+		Value val;
+		if (!colref.IsQualified()) {
+			val = Value(colref.GetColumnName());
+		} else {
+			val = Value(expr->ToString());
+		}
+		expr = make_uniq<ConstantExpression>(std::move(val));
+	}
+	if (expr->type == ExpressionType::VALUE_DEFAULT) {
+		// set to default = reset
+		return make_uniq<ResetVariableStatement>(name, ToSetScope(stmt.scope));
+	}
+	return make_uniq<SetVariableStatement>(name, std::move(expr), ToSetScope(stmt.scope));
 }
 
 unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt) {

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

@@ -1,54 +1,27 @@
 #include "duckdb/parser/statement/pragma_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/statement/show_statement.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/tableref/showref.hpp"
 
 namespace duckdb {
 
-static void TransformShowName(unique_ptr<PragmaStatement> &result, const string &name) {
-	auto &info = *result->info;
-	auto lname = StringUtil::Lower(name);
+unique_ptr<SelectStatement> Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) {
+	string name = stmt.name;
 
-	if (lname == "\"databases\"") {
-		info.name = "show_databases";
-	} else if (lname == "\"tables\"") {
-		// show all tables
-		info.name = "show_tables";
-	} else if (lname == "__show_tables_expanded") {
-		info.name = "show_tables_expanded";
-	} else {
-		// show one specific table
-		info.name = "show";
-		info.parameters.emplace_back(name);
-	}
-}
-
-unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) {
-	// we transform SHOW x into PRAGMA SHOW('x')
-	if (stmt.is_summary) {
-		auto result = make_uniq<ShowStatement>();
-		auto &info = *result->info;
-		info.is_summary = stmt.is_summary;
-
-		auto select = make_uniq<SelectNode>();
-		select->select_list.push_back(make_uniq<StarExpression>());
-		auto basetable = make_uniq<BaseTableRef>();
-		auto qualified_name = QualifiedName::Parse(stmt.name);
-		basetable->schema_name = qualified_name.schema;
-		basetable->table_name = qualified_name.name;
-		select->from_table = std::move(basetable);
-
-		info.query = std::move(select);
-		return std::move(result);
-	}
-
-	auto result = make_uniq<PragmaStatement>();
+	auto select_node = make_uniq<SelectNode>();
+	select_node->select_list.push_back(make_uniq<StarExpression>());
+	auto showref = make_uniq<ShowRef>();
+	showref->table_name = std::move(name);
+	showref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
+	select_node->from_table = std::move(showref);
 
-	auto show_name = stmt.name;
-	TransformShowName(result, show_name);
-	return std::move(result);
+	auto result = make_uniq<SelectStatement>();
+	result->node = std::move(select_node);
+	return result;
 }
 
 } // namespace duckdb

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

@@ -1,19 +1,26 @@
-#include "duckdb/parser/statement/show_statement.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/showref.hpp"
 
 namespace duckdb {
 
-unique_ptr<ShowStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
+unique_ptr<SelectStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
 	// we capture the select statement of SHOW
 	auto select_stmt = PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.stmt);
 
-	auto result = make_uniq<ShowStatement>();
-	auto &info = *result->info;
-	info.is_summary = stmt.is_summary;
+	auto select_node = make_uniq<SelectNode>();
+	select_node->select_list.push_back(make_uniq<StarExpression>());
 
-	info.query = TransformSelectNode(*select_stmt);
+	auto show_ref = make_uniq<ShowRef>();
+	show_ref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
+	show_ref->query = TransformSelectNode(*select_stmt);
+	select_node->from_table = std::move(show_ref);
 
+	auto result = make_uniq<SelectStatement>();
+	result->node = std::move(select_node);
 	return result;
 }
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/parser/statement/set_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 
@@ -14,7 +15,8 @@ unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGUseStmt
 	} else {
 		name = qualified_name.schema + "." + qualified_name.name;
 	}
-	return make_uniq<SetVariableStatement>("schema", std::move(name), SetScope::AUTOMATIC);
+	auto name_expr = make_uniq<ConstantExpression>(Value(name));
+	return make_uniq<SetVariableStatement>("schema", std::move(name_expr), SetScope::AUTOMATIC);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp

@@ -19,7 +19,7 @@ unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVa
 	if (root.sample) {
 		result->sample = TransformSampleOptions(root.sample);
 	}
-	result->query_location = root.location;
+	SetQueryLocation(*result, root.location);
 	return std::move(result);
 }
 

package/src/duckdb/src/parser/transform/tableref/transform_join.cpp

@@ -54,8 +54,7 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r
 	default:
 		break;
 	}
-	result->query_location = root.location;
-
+	SetQueryLocation(*result, root.location);
 	if (root.usingClause && root.usingClause->length > 0) {
 		// usingClause is a list of strings
 		for (auto node = root.usingClause->head; node != nullptr; node = node->next) {