duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -12,11 +12,16 @@ StarExpression::StarExpression(string relation_name_p)
 }
 
 string StarExpression::ToString() const {
+	string result;
+	if (unpacked) {
+		D_ASSERT(columns);
+		result += "*";
+	}
 	if (expr) {
 		D_ASSERT(columns);
-		return "COLUMNS(" + expr->ToString() + ")";
+		result += "COLUMNS(" + expr->ToString() + ")";
+		return result;
 	}
-	string result;
 	if (columns) {
 		result += "COLUMNS(";
 	}
@@ -60,6 +65,9 @@ bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
 	if (a.columns != b.columns) {
 		return false;
 	}
+	if (a.unpacked != b.unpacked) {
+		return false;
+	}
 	if (a.replace_list.size() != b.replace_list.size()) {
 		return false;
 	}
@@ -78,6 +86,30 @@ bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
 	return true;
 }
 
+bool StarExpression::IsStar(const ParsedExpression &a) {
+	if (a.GetExpressionClass() != ExpressionClass::STAR) {
+		return false;
+	}
+	auto &star = a.Cast<StarExpression>();
+	return star.columns == false;
+}
+
+bool StarExpression::IsColumns(const ParsedExpression &a) {
+	if (a.GetExpressionClass() != ExpressionClass::STAR) {
+		return false;
+	}
+	auto &star = a.Cast<StarExpression>();
+	return star.columns == true && star.unpacked == false;
+}
+
+bool StarExpression::IsColumnsUnpacked(const ParsedExpression &a) {
+	if (a.GetExpressionClass() != ExpressionClass::STAR) {
+		return false;
+	}
+	auto &star = a.Cast<StarExpression>();
+	return star.columns == true && star.unpacked == true;
+}
+
 unique_ptr<ParsedExpression> StarExpression::Copy() const {
 	auto copy = make_uniq<StarExpression>(relation_name);
 	copy->exclude_list = exclude_list;
@@ -87,6 +119,7 @@ unique_ptr<ParsedExpression> StarExpression::Copy() const {
 	copy->columns = columns;
 	copy->expr = expr ? expr->Copy() : nullptr;
 	copy->CopyProperties(*this);
+	copy->unpacked = unpacked;
 	return std::move(copy);
 }
 

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

@@ -17,6 +17,9 @@ ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string
       owner_name(std::move(owner_name_p)) {
 }
 
+ChangeOwnershipInfo::ChangeOwnershipInfo() : AlterInfo(AlterType::CHANGE_OWNERSHIP) {
+}
+
 CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 	return entry_catalog_type;
 }
@@ -31,8 +34,9 @@ string ChangeOwnershipInfo::ToString() const {
 
 	result += "ALTER ";
 	result += TypeToString(entry_catalog_type);
+	result += " ";
 	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		result += " IF EXISTS";
+		result += "IF EXISTS";
 	}
 	result += QualifierToString(catalog, schema, name);
 	result += " OWNED BY ";

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

@@ -1,8 +1,25 @@
 #include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
+#include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/optional_idx.hpp"
+
 namespace duckdb {
 
+optional_idx AttachInfo::GetBlockAllocSize() const {
+
+	for (auto &entry : options) {
+		if (entry.first == "block_size") {
+			// Extract the block allocation size. This is NOT the actual memory available on a block (block_size),
+			// even though the corresponding option we expose to the user is called "block_size".
+			idx_t block_alloc_size = UBigIntValue::Get(entry.second.DefaultCastAs(LogicalType::UBIGINT));
+			Storage::VerifyBlockAllocSize(block_alloc_size);
+			return block_alloc_size;
+		}
+	}
+	return optional_idx();
+}
+
 unique_ptr<AttachInfo> AttachInfo::Copy() const {
 	auto result = make_uniq<AttachInfo>();
 	result->name = name;

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

@@ -4,13 +4,13 @@
 
 namespace duckdb {
 
-CreateIndexInfo::CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+CreateIndexInfo::CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY, INVALID_SCHEMA) {
 }
 
 CreateIndexInfo::CreateIndexInfo(const duckdb::CreateIndexInfo &info)
-    : CreateInfo(CatalogType::INDEX_ENTRY), table(info.table), index_name(info.index_name), options(info.options),
-      index_type(info.index_type), constraint_type(info.constraint_type), column_ids(info.column_ids),
-      scan_types(info.scan_types), names(info.names) {
+    : CreateInfo(CatalogType::INDEX_ENTRY, info.schema), table(info.table), index_name(info.index_name),
+      options(info.options), index_type(info.index_type), constraint_type(info.constraint_type),
+      column_ids(info.column_ids), scan_types(info.scan_types), names(info.names) {
 }
 
 static void RemoveTableQualificationRecursive(unique_ptr<ParsedExpression> &expr, const string &table_name) {
@@ -27,6 +27,38 @@ static void RemoveTableQualificationRecursive(unique_ptr<ParsedExpression> &expr
 	}
 }
 
+vector<string> CreateIndexInfo::ExpressionsToList() const {
+	vector<string> list;
+
+	for (idx_t i = 0; i < parsed_expressions.size(); i++) {
+		auto &expr = parsed_expressions[i];
+		auto copy = expr->Copy();
+		// column ref expressions are qualified with the table name
+		// we need to remove them to reproduce the original query
+		RemoveTableQualificationRecursive(copy, table);
+		bool add_parenthesis = true;
+		if (copy->type == ExpressionType::COLUMN_REF) {
+			auto &column_ref = copy->Cast<ColumnRefExpression>();
+			if (!column_ref.IsQualified()) {
+				// Only when column references are not qualified, i.e (col1, col2)
+				// then these expressions do not need to be wrapped in parenthesis
+				add_parenthesis = false;
+			}
+		}
+		if (add_parenthesis) {
+			list.push_back(StringUtil::Format("(%s)", copy->ToString()));
+		} else {
+			list.push_back(StringUtil::Format("%s", copy->ToString()));
+		}
+	}
+	return list;
+}
+
+string CreateIndexInfo::ExpressionsToString() const {
+	auto list = ExpressionsToList();
+	return StringUtil::Join(list, ", ");
+}
+
 string CreateIndexInfo::ToString() const {
 	string result;
 
@@ -48,30 +80,7 @@ string CreateIndexInfo::ToString() const {
 		result += " ";
 	}
 	result += "(";
-	for (idx_t i = 0; i < parsed_expressions.size(); i++) {
-		auto &expr = parsed_expressions[i];
-		auto copy = expr->Copy();
-		if (i > 0) {
-			result += ", ";
-		}
-		// column ref expressions are qualified with the table name
-		// we need to remove them to reproduce the original query
-		RemoveTableQualificationRecursive(copy, table);
-		bool add_parenthesis = true;
-		if (copy->type == ExpressionType::COLUMN_REF) {
-			auto &column_ref = copy->Cast<ColumnRefExpression>();
-			if (!column_ref.IsQualified()) {
-				// Only when column references are not qualified, i.e (col1, col2)
-				// then these expressions do not need to be wrapped in parenthesis
-				add_parenthesis = false;
-			}
-		}
-		if (add_parenthesis) {
-			result += StringUtil::Format("(%s)", copy->ToString());
-		} else {
-			result += StringUtil::Format("%s", copy->ToString());
-		}
-	}
+	result += ExpressionsToString();
 	result += ")";
 	if (!options.empty()) {
 		result += " WITH (";

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

@@ -1,19 +1,61 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
 CreateMacroInfo::CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
 }
 
+CreateMacroInfo::CreateMacroInfo(CatalogType type, unique_ptr<MacroFunction> function,
+                                 vector<unique_ptr<MacroFunction>> extra_functions)
+    : CreateFunctionInfo(type, INVALID_SCHEMA) {
+	macros.push_back(std::move(function));
+	for (auto &macro : extra_functions) {
+		macros.push_back(std::move(macro));
+	}
+}
+
+string CreateMacroInfo::ToString() const {
+	string result;
+	for (auto &function : macros) {
+		if (!result.empty()) {
+			result += ", ";
+		}
+		result += function->ToSQL();
+	}
+	// prefix with CREATE MACRO
+	string prefix = "CREATE MACRO ";
+	if (!catalog.empty()) {
+		prefix += KeywordHelper::WriteOptionallyQuoted(catalog);
+		prefix += ".";
+	}
+	if (!schema.empty()) {
+		prefix += KeywordHelper::WriteOptionallyQuoted(schema);
+		prefix += ".";
+	}
+	prefix += KeywordHelper::WriteOptionallyQuoted(name);
+	result = prefix + " " + result + ";";
+	return result;
+}
+
 unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {
 	auto result = make_uniq<CreateMacroInfo>(type);
-	result->function = function->Copy();
+	for (auto &macro : macros) {
+		result->macros.push_back(macro->Copy());
+	}
 	result->name = name;
 	CopyProperties(*result);
 	return std::move(result);
 }
 
+vector<unique_ptr<MacroFunction>> CreateMacroInfo::GetAllButFirstFunction() const {
+	vector<unique_ptr<MacroFunction>> result;
+	for (idx_t i = 1; i < macros.size(); i++) {
+		result.push_back(macros[i]->Copy());
+	}
+	return result;
+}
+
 } // namespace duckdb

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

@@ -6,7 +6,8 @@ namespace duckdb {
 TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
 }
 
-TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) {
+TransactionInfo::TransactionInfo(TransactionType type)
+    : ParseInfo(TYPE), type(type), modifier(TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER) {
 }
 
 string TransactionInfo::ToString() const {
@@ -26,8 +27,27 @@ string TransactionInfo::ToString() const {
 		                        EnumUtil::ToString(type));
 	}
 	}
+	switch (modifier) {
+	case TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER:
+		break;
+	case TransactionModifierType::TRANSACTION_READ_ONLY:
+		result += " READ ONLY";
+		break;
+	case TransactionModifierType::TRANSACTION_READ_WRITE:
+		result += " READ WRITE";
+		break;
+	default:
+		throw InternalException("ToString for TransactionStatement with modifier type: %s not implemented",
+		                        EnumUtil::ToString(modifier));
+	}
 	result += ";";
 	return result;
 }
 
+unique_ptr<TransactionInfo> TransactionInfo::Copy() const {
+	auto result = make_uniq<TransactionInfo>(type);
+	result->modifier = modifier;
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/query_node.hpp"
-#include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/parser/query_node/cte_node.hpp"
+#include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 #include "duckdb/parser/tableref/list.hpp"
@@ -201,96 +201,100 @@ void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
 }
 
 void ParsedExpressionIterator::EnumerateTableRefChildren(
-    TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
+    TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
+    const std::function<void(TableRef &ref)> &ref_callback) {
 	switch (ref.type) {
 	case TableReferenceType::EXPRESSION_LIST: {
 		auto &el_ref = ref.Cast<ExpressionListRef>();
 		for (idx_t i = 0; i < el_ref.values.size(); i++) {
 			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
-				callback(el_ref.values[i][j]);
+				expr_callback(el_ref.values[i][j]);
 			}
 		}
 		break;
 	}
 	case TableReferenceType::JOIN: {
 		auto &j_ref = ref.Cast<JoinRef>();
-		EnumerateTableRefChildren(*j_ref.left, callback);
-		EnumerateTableRefChildren(*j_ref.right, callback);
+		EnumerateTableRefChildren(*j_ref.left, expr_callback, ref_callback);
+		EnumerateTableRefChildren(*j_ref.right, expr_callback, ref_callback);
 		if (j_ref.condition) {
-			callback(j_ref.condition);
+			expr_callback(j_ref.condition);
 		}
 		break;
 	}
 	case TableReferenceType::PIVOT: {
 		auto &p_ref = ref.Cast<PivotRef>();
-		EnumerateTableRefChildren(*p_ref.source, callback);
+		EnumerateTableRefChildren(*p_ref.source, expr_callback, ref_callback);
 		for (auto &aggr : p_ref.aggregates) {
-			callback(aggr);
+			expr_callback(aggr);
 		}
 		break;
 	}
 	case TableReferenceType::SUBQUERY: {
 		auto &sq_ref = ref.Cast<SubqueryRef>();
-		EnumerateQueryNodeChildren(*sq_ref.subquery->node, callback);
+		EnumerateQueryNodeChildren(*sq_ref.subquery->node, expr_callback, ref_callback);
 		break;
 	}
 	case TableReferenceType::TABLE_FUNCTION: {
 		auto &tf_ref = ref.Cast<TableFunctionRef>();
-		callback(tf_ref.function);
+		expr_callback(tf_ref.function);
 		break;
 	}
 	case TableReferenceType::BASE_TABLE:
 	case TableReferenceType::EMPTY_FROM:
 	case TableReferenceType::SHOW_REF:
 	case TableReferenceType::COLUMN_DATA:
+	case TableReferenceType::DELIM_GET:
 		// these TableRefs do not need to be unfolded
 		break;
 	case TableReferenceType::INVALID:
 	case TableReferenceType::CTE:
 		throw NotImplementedException("TableRef type not implemented for traversal");
 	}
+	ref_callback(ref);
 }
 
 void ParsedExpressionIterator::EnumerateQueryNodeChildren(
-    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
+    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &expr_callback,
+    const std::function<void(TableRef &ref)> &ref_callback) {
 	switch (node.type) {
 	case QueryNodeType::RECURSIVE_CTE_NODE: {
 		auto &rcte_node = node.Cast<RecursiveCTENode>();
-		EnumerateQueryNodeChildren(*rcte_node.left, callback);
-		EnumerateQueryNodeChildren(*rcte_node.right, callback);
+		EnumerateQueryNodeChildren(*rcte_node.left, expr_callback, ref_callback);
+		EnumerateQueryNodeChildren(*rcte_node.right, expr_callback, ref_callback);
 		break;
 	}
 	case QueryNodeType::CTE_NODE: {
 		auto &cte_node = node.Cast<CTENode>();
-		EnumerateQueryNodeChildren(*cte_node.query, callback);
-		EnumerateQueryNodeChildren(*cte_node.child, callback);
+		EnumerateQueryNodeChildren(*cte_node.query, expr_callback, ref_callback);
+		EnumerateQueryNodeChildren(*cte_node.child, expr_callback, ref_callback);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {
 		auto &sel_node = node.Cast<SelectNode>();
 		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
-			callback(sel_node.select_list[i]);
+			expr_callback(sel_node.select_list[i]);
 		}
 		for (idx_t i = 0; i < sel_node.groups.group_expressions.size(); i++) {
-			callback(sel_node.groups.group_expressions[i]);
+			expr_callback(sel_node.groups.group_expressions[i]);
 		}
 		if (sel_node.where_clause) {
-			callback(sel_node.where_clause);
+			expr_callback(sel_node.where_clause);
 		}
 		if (sel_node.having) {
-			callback(sel_node.having);
+			expr_callback(sel_node.having);
 		}
 		if (sel_node.qualify) {
-			callback(sel_node.qualify);
+			expr_callback(sel_node.qualify);
 		}
 
-		EnumerateTableRefChildren(*sel_node.from_table.get(), callback);
+		EnumerateTableRefChildren(*sel_node.from_table.get(), expr_callback, ref_callback);
 		break;
 	}
 	case QueryNodeType::SET_OPERATION_NODE: {
 		auto &setop_node = node.Cast<SetOperationNode>();
-		EnumerateQueryNodeChildren(*setop_node.left, callback);
-		EnumerateQueryNodeChildren(*setop_node.right, callback);
+		EnumerateQueryNodeChildren(*setop_node.left, expr_callback, ref_callback);
+		EnumerateQueryNodeChildren(*setop_node.right, expr_callback, ref_callback);
 		break;
 	}
 	default:
@@ -298,11 +302,11 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	}
 
 	if (!node.modifiers.empty()) {
-		EnumerateQueryNodeModifiers(node, callback);
+		EnumerateQueryNodeModifiers(node, expr_callback);
 	}
 
 	for (auto &kv : node.cte_map.map) {
-		EnumerateQueryNodeChildren(*kv.second->query->node, callback);
+		EnumerateQueryNodeChildren(*kv.second->query->node, expr_callback, ref_callback);
 	}
 }
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/parser/parser.hpp"
 
+#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/parser/query_error_context.hpp"
@@ -8,7 +9,6 @@
 #include "duckdb/parser/statement/extension_statement.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/transformer.hpp"
 #include "parser/parser.hpp"
@@ -42,6 +42,16 @@ static bool ReplaceUnicodeSpaces(const string &query, string &new_query, vector<
 	return true;
 }
 
+static bool IsValidDollarQuotedStringTagFirstChar(const unsigned char &c) {
+	// the first character can be between A-Z, a-z, or \200 - \377
+	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c >= 0x80;
+}
+
+static bool IsValidDollarQuotedStringTagSubsequentChar(const unsigned char &c) {
+	// subsequent characters can also be between 0-9
+	return IsValidDollarQuotedStringTagFirstChar(c) || (c >= '0' && c <= '9');
+}
+
 // This function strips unicode space characters from the query and replaces them with regular spaces
 // It returns true if any unicode space characters were found and stripped
 // See here for a list of unicode space characters - https://jkorpela.fi/chars/spaces.html
@@ -50,6 +60,7 @@ bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) {
 	const idx_t USP_LEN = 3;
 	idx_t pos = 0;
 	unsigned char quote;
+	string_t dollar_quote_tag;
 	vector<UnicodeSpace> unicode_spaces;
 	auto query = const_uchar_ptr_cast(query_str.c_str());
 	auto qsize = query_str.size();
@@ -95,6 +106,24 @@ regular:
 			quote = query[pos];
 			pos++;
 			goto in_quotes;
+		} else if (query[pos] == '$' &&
+		           (query[pos + 1] == '$' || IsValidDollarQuotedStringTagFirstChar(query[pos + 1]))) {
+			// (optionally tagged) dollar-quoted string
+			auto start = &query[++pos];
+			for (; pos + 2 < qsize; pos++) {
+				if (query[pos] == '$') {
+					// end of tag
+					dollar_quote_tag =
+					    string_t(const_char_ptr_cast(start), NumericCast<uint32_t, int64_t>(&query[pos] - start));
+					goto in_dollar_quotes;
+				}
+
+				if (!IsValidDollarQuotedStringTagSubsequentChar(query[pos])) {
+					// invalid char in dollar-quoted string, continue as normal
+					goto regular;
+				}
+			}
+			goto end;
 		} else if (query[pos] == '-' && query[pos + 1] == '-') {
 			goto in_comment;
 		}
@@ -113,6 +142,17 @@ in_quotes:
 		}
 	}
 	goto end;
+in_dollar_quotes:
+	for (; pos + 2 < qsize; pos++) {
+		if (query[pos] == '$' &&
+		    qsize - (pos + 1) >= dollar_quote_tag.GetSize() + 1 && // found '$' and enough space left
+		    query[pos + dollar_quote_tag.GetSize() + 1] == '$' &&  // ending '$' at the right spot
+		    memcmp(&query[pos + 1], dollar_quote_tag.GetData(), dollar_quote_tag.GetSize()) == 0) { // tags match
+			pos += dollar_quote_tag.GetSize() + 1;
+			goto regular;
+		}
+	}
+	goto end;
 in_comment:
 	for (; pos < qsize; pos++) {
 		if (query[pos] == '\n' || query[pos] == '\r') {

package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp

@@ -6,6 +6,7 @@ namespace duckdb {
 
 string RecursiveCTENode::ToString() const {
 	string result;
+	result = cte_map.ToString();
 	result += "(" + left->ToString() + ")";
 	result += " UNION ";
 	if (union_all) {

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

@@ -3,32 +3,47 @@
 
 namespace duckdb {
 
-ExplainStatement::ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type)
-    : SQLStatement(StatementType::EXPLAIN_STATEMENT), stmt(std::move(stmt)), explain_type(explain_type) {
+ExplainStatement::ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type,
+                                   ExplainFormat explain_format)
+    : SQLStatement(StatementType::EXPLAIN_STATEMENT), stmt(std::move(stmt)), explain_type(explain_type),
+      explain_format(explain_format) {
 }
 
 ExplainStatement::ExplainStatement(const ExplainStatement &other)
-    : SQLStatement(other), stmt(other.stmt->Copy()), explain_type(other.explain_type) {
+    : SQLStatement(other), stmt(other.stmt->Copy()), explain_type(other.explain_type),
+      explain_format(other.explain_format) {
 }
 
 unique_ptr<SQLStatement> ExplainStatement::Copy() const {
 	return unique_ptr<ExplainStatement>(new ExplainStatement(*this));
 }
 
-static string ExplainTypeToString(ExplainType type) {
-	switch (type) {
-	case ExplainType::EXPLAIN_STANDARD:
-		return "EXPLAIN";
-	case ExplainType::EXPLAIN_ANALYZE:
-		return "EXPLAIN ANALYZE";
-	default:
-		throw InternalException("ToString for ExplainType with type: %s not implemented", EnumUtil::ToString(type));
+string ExplainStatement::OptionsToString() const {
+	string options;
+	if (explain_type == ExplainType::EXPLAIN_ANALYZE) {
+		options += "(";
+		options += "ANALYZE";
 	}
+	if (explain_format != ExplainFormat::DEFAULT) {
+		if (options.empty()) {
+			options += "(";
+		} else {
+			options += ", ";
+		}
+		options += StringUtil::Format("FORMAT %s", EnumUtil::ToString(explain_format));
+	}
+	if (!options.empty()) {
+		options += ")";
+	}
+	return options;
 }
 
 string ExplainStatement::ToString() const {
-	string result = "";
-	result += ExplainTypeToString(explain_type);
+	string result = "EXPLAIN";
+	auto options = OptionsToString();
+	if (!options.empty()) {
+		result += " " + options;
+	}
 	result += " " + stmt->ToString();
 	return result;
 }

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

@@ -1,9 +1,14 @@
 #include "duckdb/parser/statement/relation_statement.hpp"
+#include "duckdb/main/relation/query_relation.hpp"
 
 namespace duckdb {
 
 RelationStatement::RelationStatement(shared_ptr<Relation> relation_p)
     : SQLStatement(StatementType::RELATION_STATEMENT), relation(std::move(relation_p)) {
+	if (relation->type == RelationType::QUERY_RELATION) {
+		auto &query_relation = relation->Cast<QueryRelation>();
+		query = query_relation.query;
+	}
 }
 
 unique_ptr<SQLStatement> RelationStatement::Copy() const {

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

@@ -3,13 +3,13 @@
 
 namespace duckdb {
 
-SetStatement::SetStatement(std::string name_p, SetScope scope_p, SetType type_p)
+SetStatement::SetStatement(string name_p, SetScope scope_p, SetType type_p)
     : SQLStatement(StatementType::SET_STATEMENT), name(std::move(name_p)), scope(scope_p), set_type(type_p) {
 }
 
 // Set Variable
 
-SetVariableStatement::SetVariableStatement(std::string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p)
+SetVariableStatement::SetVariableStatement(string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p)
     : SetStatement(std::move(name_p), scope_p, SetType::SET), value(std::move(value_p)) {
 }
 
@@ -31,6 +31,8 @@ static string ScopeToString(SetScope scope) {
 		return "SESSION";
 	case SetScope::GLOBAL:
 		return "GLOBAL";
+	case SetScope::VARIABLE:
+		return "VARIABLE";
 	default:
 		throw InternalException("ToString not implemented for SetScope of type: %s", EnumUtil::ToString(scope));
 	}

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

@@ -2,12 +2,12 @@
 
 namespace duckdb {
 
-TransactionStatement::TransactionStatement(TransactionType type)
-    : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(make_uniq<TransactionInfo>(type)) {
+TransactionStatement::TransactionStatement(unique_ptr<TransactionInfo> info)
+    : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(std::move(info)) {
 }
 
 TransactionStatement::TransactionStatement(const TransactionStatement &other)
-    : SQLStatement(other), info(make_uniq<TransactionInfo>(other.info->type)) {
+    : SQLStatement(other), info(other.info->Copy()) {
 }
 
 unique_ptr<SQLStatement> TransactionStatement::Copy() const {