duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -10,20 +10,23 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 
 namespace duckdb {
 
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, string column_name) {
+void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column) {
 	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column_name));
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
 		return;
 	}
-	auto result = make_unique<CreatePivotEntry>();
+	auto result = make_uniq<CreatePivotEntry>();
 	result->enum_name = std::move(enum_name);
 	result->base = std::move(base);
-	result->column_name = std::move(column_name);
+	result->column = std::move(column);
 
 	pivot_entries.push_back(std::move(result));
 }
@@ -43,8 +46,8 @@ idx_t Transformer::PivotEntryCount() {
 }
 
 unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateTypeInfo>();
+	auto result = make_uniq<CreateStatement>();
+	auto info = make_uniq<CreateTypeInfo>();
 
 	info->temporary = true;
 	info->internal = false;
@@ -55,16 +58,21 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 
 	// generate the query that will result in the enum creation
 	auto select_node = std::move(entry->base);
-	auto columnref = make_unique<ColumnRefExpression>(std::move(entry->column_name));
-	auto cast = make_unique<CastExpression>(LogicalType::VARCHAR, columnref->Copy());
+	auto columnref = entry->column->Copy();
+	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
 	select_node->select_list.push_back(std::move(cast));
 
+	auto is_not_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
+	select_node->where_clause = std::move(is_not_null);
+
 	// order by the column
-	auto modifier = make_unique<OrderModifier>();
-	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(columnref));
+	select_node->modifiers.push_back(make_uniq<DistinctModifier>());
+	auto modifier = make_uniq<OrderModifier>();
+	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
+	                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
 	select_node->modifiers.push_back(std::move(modifier));
 
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = std::move(select_node);
 	info->query = std::move(select);
 	info->type = LogicalType::INVALID;
@@ -74,7 +82,7 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 }
 
 // unique_ptr<SQLStatement> GenerateDropEnumStmt(string enum_name) {
-//	auto result = make_unique<DropStatement>();
+//	auto result = make_uniq<DropStatement>();
 //	result->info->if_exists = true;
 //	result->info->schema = INVALID_SCHEMA;
 //	result->info->catalog = INVALID_CATALOG;
@@ -84,7 +92,7 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 //}
 
 unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStatement> statement) {
-	auto result = make_unique<MultiStatement>();
+	auto result = make_uniq<MultiStatement>();
 	for (auto &pivot : pivot_entries) {
 		result->statements.push_back(GenerateCreateEnumStmt(std::move(pivot)));
 	}
@@ -99,45 +107,69 @@ unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStateme
 unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt) {
 	auto pivot = stmt->pivot;
 	auto source = TransformTableRefNode(pivot->source);
-	auto columns = TransformPivotList(pivot->columns);
 
-	auto select_node = make_unique<SelectNode>();
+	auto select_node = make_uniq<SelectNode>();
 	// handle the CTEs
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), select_node->cte_map);
 	}
+	if (!pivot->columns) {
+		// no pivot columns - not actually a pivot
+		select_node->from_table = std::move(source);
+		if (pivot->groups) {
+			auto groups = TransformStringList(pivot->groups);
+			GroupingSet set;
+			for (idx_t gr = 0; gr < groups.size(); gr++) {
+				auto &group = groups[gr];
+				auto colref = make_uniq<ColumnRefExpression>(group);
+				select_node->select_list.push_back(colref->Copy());
+				select_node->groups.group_expressions.push_back(std::move(colref));
+				set.insert(gr);
+			}
+			select_node->groups.grouping_sets.push_back(std::move(set));
+		}
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, select_node->select_list);
+		}
+		return std::move(select_node);
+	}
 
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
+	auto columns = TransformPivotList(pivot->columns);
 	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
 		if (!col.pivot_enum.empty() || !col.entries.empty()) {
 			continue;
 		}
-		if (col.names.size() != 1) {
+		if (col.pivot_expressions.size() != 1) {
 			throw InternalException("PIVOT statement with multiple names in pivot entry!?");
 		}
 		auto enum_name = "__pivot_enum_" + std::to_string(pivot_idx) + "_" + std::to_string(c);
 
-		auto new_select = make_unique<SelectNode>();
+		auto new_select = make_uniq<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);
 		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.names[0]);
+		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy());
 		col.pivot_enum = enum_name;
 	}
 
 	// generate the actual query, including the pivot
-	select_node->select_list.push_back(make_unique<StarExpression>());
+	select_node->select_list.push_back(make_uniq<StarExpression>());
 
-	auto pivot_ref = make_unique<PivotRef>();
+	auto pivot_ref = make_uniq<PivotRef>();
 	pivot_ref->source = std::move(source);
-	if (pivot->aggrs) {
-		TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+	if (pivot->unpivots) {
+		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	} else {
-		if (!pivot->unpivots) {
-			throw InternalException("No unpivots and no aggrs");
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+		} else {
+			// pivot but no aggregates specified - push a count star
+			vector<unique_ptr<ParsedExpression>> children;
+			auto function = make_uniq<FunctionExpression>("count_star", std::move(children));
+			pivot_ref->aggregates.push_back(std::move(function));
 		}
-		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	}
 	if (pivot->groups) {
 		pivot_ref->groups = TransformStringList(pivot->groups);

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

@@ -12,7 +12,7 @@ namespace duckdb {
 unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGPragmaStmt *>(node);
 
-	auto result = make_unique<PragmaStatement>();
+	auto result = make_uniq<PragmaStatement>();
 	auto &info = *result->info;
 
 	info.name = stmt->name;
@@ -23,21 +23,21 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 			auto expr = TransformExpression(node);
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
-				auto &comp = (ComparisonExpression &)*expr;
+				auto &comp = expr->Cast<ComparisonExpression>();
 				if (comp.right->type != ExpressionType::VALUE_CONSTANT) {
 					throw ParserException("Named parameter requires a constant on the RHS");
 				}
 				if (comp.left->type != ExpressionType::COLUMN_REF) {
 					throw ParserException("Named parameter requires a column reference on the LHS");
 				}
-				auto &columnref = (ColumnRefExpression &)*comp.left;
-				auto &constant = (ConstantExpression &)*comp.right;
+				auto &columnref = comp.left->Cast<ColumnRefExpression>();
+				auto &constant = comp.right->Cast<ConstantExpression>();
 				info.named_parameters[columnref.GetName()] = constant.value;
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
 				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node);
-				info.parameters.push_back(((ConstantExpression &)*constant).value);
+				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);
 			} else if (expr->type == ExpressionType::COLUMN_REF) {
-				auto &colref = (ColumnRefExpression &)*expr;
+				auto &colref = expr->Cast<ColumnRefExpression>();
 				if (!colref.IsQualified()) {
 					info.parameters.emplace_back(colref.GetColumnName());
 				} else {
@@ -70,7 +70,7 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 		if (sqlite_compat_pragmas.find(info.name) != sqlite_compat_pragmas.end()) {
 			break;
 		}
-		auto set_statement = make_unique<SetVariableStatement>(info.name, info.parameters[0], SetScope::AUTOMATIC);
+		auto set_statement = make_uniq<SetVariableStatement>(info.name, 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_prepare.cpp

@@ -13,7 +13,7 @@ unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PG
 		throw NotImplementedException("Prepared statement argument types are not supported, use CAST");
 	}
 
-	auto result = make_unique<PrepareStatement>();
+	auto result = make_uniq<PrepareStatement>();
 	result->name = string(stmt->name);
 	result->statement = TransformStatement(stmt->query);
 	if (!result->statement->named_param_map.empty()) {
@@ -28,7 +28,7 @@ unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PG
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExecuteStmt *>(node);
 	D_ASSERT(stmt);
 
-	auto result = make_unique<ExecuteStatement>();
+	auto result = make_uniq<ExecuteStatement>();
 	result->name = string(stmt->name);
 
 	if (stmt->params) {
@@ -49,7 +49,7 @@ unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PG
 		throw ParserException("DEALLOCATE requires a name");
 	}
 
-	auto result = make_unique<DropStatement>();
+	auto result = make_uniq<DropStatement>();
 	result->info->type = CatalogType::PREPARED_STATEMENT;
 	result->info->name = string(stmt->name);
 	return result;

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

@@ -6,7 +6,9 @@ namespace duckdb {
 unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGRenameStmt *>(node);
 	D_ASSERT(stmt);
-	D_ASSERT(stmt->relation);
+	if (!stmt->relation) {
+		throw NotImplementedException("Altering schemas is not yet supported");
+	}
 
 	unique_ptr<AlterInfo> info;
 
@@ -17,8 +19,6 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 	if (stmt->relation->relname) {
 		data.name = stmt->relation->relname;
 	}
-	if (stmt->relation->schemaname) {
-	}
 	// first we check the type of ALTER
 	switch (stmt->renameType) {
 	case duckdb_libpgquery::PG_OBJECT_COLUMN: {
@@ -27,20 +27,19 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		// get the old name and the new name
 		string old_name = stmt->subname;
 		string new_name = stmt->newname;
-		info = make_unique<RenameColumnInfo>(std::move(data), old_name, new_name);
+		info = make_uniq<RenameColumnInfo>(std::move(data), old_name, new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_TABLE: {
 		// change table name
 		string new_name = stmt->newname;
-		info = make_unique<RenameTableInfo>(std::move(data), new_name);
+		info = make_uniq<RenameTableInfo>(std::move(data), new_name);
 		break;
 	}
-
 	case duckdb_libpgquery::PG_OBJECT_VIEW: {
 		// change view name
 		string new_name = stmt->newname;
-		info = make_unique<RenameViewInfo>(std::move(data), new_name);
+		info = make_uniq<RenameViewInfo>(std::move(data), new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_DATABASE:
@@ -49,7 +48,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 	}
 	D_ASSERT(info);
 
-	auto result = make_unique<AlterStatement>();
+	auto result = make_uniq<AlterStatement>();
 	result->info = std::move(info);
 	return result;
 }

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

@@ -14,7 +14,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 
 unique_ptr<SelectStatement> Transformer::TransformSelect(duckdb_libpgquery::PGNode *node, bool is_select) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(node);
-	auto result = make_unique<SelectStatement>();
+	auto result = make_uniq<SelectStatement>();
 
 	// Both Insert/Create Table As uses this.
 	if (is_select) {

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

@@ -16,8 +16,8 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 
 	switch (stmt->op) {
 	case duckdb_libpgquery::PG_SETOP_NONE: {
-		node = make_unique<SelectNode>();
-		auto result = (SelectNode *)node.get();
+		node = make_uniq<SelectNode>();
+		auto &result = node->Cast<SelectNode>();
 		if (stmt->withClause) {
 			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
@@ -26,8 +26,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 				auto window_def = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(window_ele->data.ptr_value);
 				D_ASSERT(window_def);
 				D_ASSERT(window_def->name);
-				auto window_name = StringUtil::Lower(string(window_def->name));
-
+				string window_name(window_def->name);
 				auto it = window_clauses.find(window_name);
 				if (it != window_clauses.end()) {
 					throw ParserException("window \"%s\" is already defined", window_name);
@@ -38,55 +37,55 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 
 		// checks distinct clause
 		if (stmt->distinctClause != nullptr) {
-			auto modifier = make_unique<DistinctModifier>();
+			auto modifier = make_uniq<DistinctModifier>();
 			// checks distinct on clause
 			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(stmt->distinctClause->head->data.ptr_value);
 			if (target) {
 				//  add the columns defined in the ON clause to the select list
 				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets);
 			}
-			result->modifiers.push_back(std::move(modifier));
+			result.modifiers.push_back(std::move(modifier));
 		}
 
 		// do this early so the value lists also have a `FROM`
 		if (stmt->valuesLists) {
 			// VALUES list, create an ExpressionList
 			D_ASSERT(!stmt->fromClause);
-			result->from_table = TransformValuesList(stmt->valuesLists);
-			result->select_list.push_back(make_unique<StarExpression>());
+			result.from_table = TransformValuesList(stmt->valuesLists);
+			result.select_list.push_back(make_uniq<StarExpression>());
 		} else {
 			if (!stmt->targetList) {
 				throw ParserException("SELECT clause without selection list");
 			}
 			// select list
-			TransformExpressionList(*stmt->targetList, result->select_list);
-			result->from_table = TransformFrom(stmt->fromClause);
+			TransformExpressionList(*stmt->targetList, result.select_list);
+			result.from_table = TransformFrom(stmt->fromClause);
 		}
 
 		// where
-		result->where_clause = TransformExpression(stmt->whereClause);
+		result.where_clause = TransformExpression(stmt->whereClause);
 		// group by
-		TransformGroupBy(stmt->groupClause, *result);
+		TransformGroupBy(stmt->groupClause, result);
 		// having
-		result->having = TransformExpression(stmt->havingClause);
+		result.having = TransformExpression(stmt->havingClause);
 		// qualify
-		result->qualify = TransformExpression(stmt->qualifyClause);
+		result.qualify = TransformExpression(stmt->qualifyClause);
 		// sample
-		result->sample = TransformSampleOptions(stmt->sampleOptions);
+		result.sample = TransformSampleOptions(stmt->sampleOptions);
 		break;
 	}
 	case duckdb_libpgquery::PG_SETOP_UNION:
 	case duckdb_libpgquery::PG_SETOP_EXCEPT:
 	case duckdb_libpgquery::PG_SETOP_INTERSECT:
 	case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME: {
-		node = make_unique<SetOperationNode>();
-		auto result = (SetOperationNode *)node.get();
+		node = make_uniq<SetOperationNode>();
+		auto &result = node->Cast<SetOperationNode>();
 		if (stmt->withClause) {
 			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
-		result->left = TransformSelectNode(stmt->larg);
-		result->right = TransformSelectNode(stmt->rarg);
-		if (!result->left || !result->right) {
+		result.left = TransformSelectNode(stmt->larg);
+		result.right = TransformSelectNode(stmt->rarg);
+		if (!result.left || !result.right) {
 			throw Exception("Failed to transform setop children.");
 		}
 
@@ -94,23 +93,23 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		switch (stmt->op) {
 		case duckdb_libpgquery::PG_SETOP_UNION:
 			select_distinct = !stmt->all;
-			result->setop_type = SetOperationType::UNION;
+			result.setop_type = SetOperationType::UNION;
 			break;
 		case duckdb_libpgquery::PG_SETOP_EXCEPT:
-			result->setop_type = SetOperationType::EXCEPT;
+			result.setop_type = SetOperationType::EXCEPT;
 			break;
 		case duckdb_libpgquery::PG_SETOP_INTERSECT:
-			result->setop_type = SetOperationType::INTERSECT;
+			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;
+			result.setop_type = SetOperationType::UNION_BY_NAME;
 			break;
 		default:
 			throw Exception("Unexpected setop type");
 		}
 		if (select_distinct) {
-			result->modifiers.push_back(make_unique<DistinctModifier>());
+			result.modifiers.push_back(make_uniq<DistinctModifier>());
 		}
 		if (stmt->sampleOptions) {
 			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");
@@ -125,13 +124,13 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	vector<OrderByNode> orders;
 	TransformOrderBy(stmt->sortClause, orders);
 	if (!orders.empty()) {
-		auto order_modifier = make_unique<OrderModifier>();
+		auto order_modifier = make_uniq<OrderModifier>();
 		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_unique<LimitPercentModifier>();
+			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
 			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt->limitCount)->limit_percent;
 			limit_percent_modifier->limit = TransformExpression(expr_node);
 			if (stmt->limitOffset) {
@@ -139,7 +138,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 			}
 			node->modifiers.push_back(std::move(limit_percent_modifier));
 		} else {
-			auto limit_modifier = make_unique<LimitModifier>();
+			auto limit_modifier = make_uniq<LimitModifier>();
 			if (stmt->limitCount) {
 				limit_modifier->limit = TransformExpression(stmt->limitCount);
 			}

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

@@ -52,7 +52,7 @@ unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PG
 
 	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val)->value;
 
-	return make_unique<SetVariableStatement>(name, value, ToSetScope(stmt->scope));
+	return make_uniq<SetVariableStatement>(name, value, ToSetScope(stmt->scope));
 }
 
 unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt) {
@@ -65,7 +65,7 @@ unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::
 	auto name = std::string(stmt->name);
 	D_ASSERT(!name.empty()); // parser protect us!
 
-	return make_unique<ResetVariableStatement>(name, ToSetScope(stmt->scope));
+	return make_uniq<ResetVariableStatement>(name, ToSetScope(stmt->scope));
 }
 
 unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *node) {

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

@@ -30,13 +30,13 @@ unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGNode *n
 
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowStmt *>(node);
 	if (stmt->is_summary) {
-		auto result = make_unique<ShowStatement>();
+		auto result = make_uniq<ShowStatement>();
 		auto &info = *result->info;
 		info.is_summary = stmt->is_summary;
 
-		auto select = make_unique<SelectNode>();
-		select->select_list.push_back(make_unique<StarExpression>());
-		auto basetable = make_unique<BaseTableRef>();
+		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;
@@ -46,7 +46,7 @@ unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGNode *n
 		return std::move(result);
 	}
 
-	auto result = make_unique<PragmaStatement>();
+	auto result = make_uniq<PragmaStatement>();
 
 	auto show_name = stmt->name;
 	TransformShowName(result, show_name);

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

@@ -9,7 +9,7 @@ unique_ptr<ShowStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PG
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowSelectStmt *>(node);
 	auto select_stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(stmt->stmt);
 
-	auto result = make_unique<ShowStatement>();
+	auto result = make_uniq<ShowStatement>();
 	auto &info = *result->info;
 	info.is_summary = stmt->is_summary;
 

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

@@ -9,11 +9,11 @@ unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgq
 	switch (stmt->kind) {
 	case duckdb_libpgquery::PG_TRANS_STMT_BEGIN:
 	case duckdb_libpgquery::PG_TRANS_STMT_START:
-		return make_unique<TransactionStatement>(TransactionType::BEGIN_TRANSACTION);
+		return make_uniq<TransactionStatement>(TransactionType::BEGIN_TRANSACTION);
 	case duckdb_libpgquery::PG_TRANS_STMT_COMMIT:
-		return make_unique<TransactionStatement>(TransactionType::COMMIT);
+		return make_uniq<TransactionStatement>(TransactionType::COMMIT);
 	case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK:
-		return make_unique<TransactionStatement>(TransactionType::ROLLBACK);
+		return make_uniq<TransactionStatement>(TransactionType::ROLLBACK);
 	default:
 		throw NotImplementedException("Transaction type %d not implemented yet", stmt->kind);
 	}

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

@@ -5,7 +5,7 @@ namespace duckdb {
 
 unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list,
                                                               duckdb_libpgquery::PGNode *where_clause) {
-	auto result = make_unique<UpdateSetInfo>();
+	auto result = make_uniq<UpdateSetInfo>();
 
 	auto root = target_list;
 	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
@@ -21,7 +21,7 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGUpdateStmt *>(node);
 	D_ASSERT(stmt);
 
-	auto result = make_unique<UpdateStatement>();
+	auto result = make_uniq<UpdateStatement>();
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
 	}

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

@@ -50,13 +50,13 @@ unique_ptr<OnConflictInfo> Transformer::DummyOnConflictClause(duckdb_libpgquery:
 	switch (type) {
 	case duckdb_libpgquery::PGOnConflictActionAlias::PG_ONCONFLICT_ALIAS_REPLACE: {
 		// This can not be fully resolved yet until the bind stage
-		auto result = make_unique<OnConflictInfo>();
+		auto result = make_uniq<OnConflictInfo>();
 		result->action_type = OnConflictAction::REPLACE;
 		return result;
 	}
 	case duckdb_libpgquery::PGOnConflictActionAlias::PG_ONCONFLICT_ALIAS_IGNORE: {
 		// We can just fully replace this with DO NOTHING, and be done with it
-		auto result = make_unique<OnConflictInfo>();
+		auto result = make_uniq<OnConflictInfo>();
 		result->action_type = OnConflictAction::NOTHING;
 		return result;
 	}
@@ -71,7 +71,7 @@ unique_ptr<OnConflictInfo> Transformer::TransformOnConflictClause(duckdb_libpgqu
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGOnConflictClause *>(node);
 	D_ASSERT(stmt);
 
-	auto result = make_unique<OnConflictInfo>();
+	auto result = make_uniq<OnConflictInfo>();
 	result->action_type = TransformOnConflictAction(stmt);
 	if (stmt->infer) {
 		// A filter for the ON CONFLICT ... is specified

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

@@ -15,7 +15,7 @@ unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGNode *no
 	} else {
 		name = qualified_name.schema + "." + qualified_name.name;
 	}
-	return make_unique<SetVariableStatement>("schema", std::move(name), SetScope::AUTOMATIC);
+	return make_uniq<SetVariableStatement>("schema", std::move(name), SetScope::AUTOMATIC);
 }
 
 } // namespace duckdb

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

@@ -36,7 +36,7 @@ unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGNode
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVacuumStmt *>(node);
 	D_ASSERT(stmt);
 
-	auto result = make_unique<VacuumStatement>(ParseOptions(stmt->options));
+	auto result = make_uniq<VacuumStatement>(ParseOptions(stmt->options));
 
 	if (stmt->relation) {
 		result->info->ref = TransformRangeVar(stmt->relation);

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

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVar *root) {
-	auto result = make_unique<BaseTableRef>();
+	auto result = make_uniq<BaseTableRef>();
 
 	result->alias = TransformAlias(root->alias, result->column_name_alias);
 	if (root->relname) {

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

@@ -6,12 +6,12 @@ namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root) {
 	if (!root) {
-		return make_unique<EmptyTableRef>();
+		return make_uniq<EmptyTableRef>();
 	}
 
 	if (root->length > 1) {
 		// Cross Product
-		auto result = make_unique<JoinRef>(JoinRefType::CROSS);
+		auto result = make_uniq<JoinRef>(JoinRefType::CROSS);
 		JoinRef *cur_root = result.get();
 		idx_t list_size = 0;
 		for (auto node = root->head; node != nullptr; node = node->next) {
@@ -23,7 +23,7 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 				cur_root->right = std::move(next);
 			} else {
 				auto old_res = std::move(result);
-				result = make_unique<JoinRef>(JoinRefType::CROSS);
+				result = make_uniq<JoinRef>(JoinRefType::CROSS);
 				result->left = std::move(old_res);
 				result->right = std::move(next);
 				cur_root = result.get();

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

@@ -6,7 +6,7 @@
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *root) {
-	auto result = make_unique<JoinRef>(JoinRefType::REGULAR);
+	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
 	switch (root->jointype) {
 	case duckdb_libpgquery::PG_JOIN_INNER: {
 		result->type = JoinType::INNER;
@@ -28,6 +28,10 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 		result->type = JoinType::SEMI;
 		break;
 	}
+	case duckdb_libpgquery::PG_JOIN_ANTI: {
+		result->type = JoinType::ANTI;
+		break;
+	}
 	case duckdb_libpgquery::PG_JOIN_POSITION: {
 		result->ref_type = JoinRefType::POSITIONAL;
 		break;
@@ -40,8 +44,15 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 	// Check the type of left arg and right arg before transform
 	result->left = TransformTableRefNode(root->larg);
 	result->right = TransformTableRefNode(root->rarg);
-	if (root->isNatural) {
+	switch (root->joinreftype) {
+	case duckdb_libpgquery::PG_JOIN_NATURAL:
 		result->ref_type = JoinRefType::NATURAL;
+		break;
+	case duckdb_libpgquery::PG_JOIN_ASOF:
+		result->ref_type = JoinRefType::ASOF;
+		break;
+	default:
+		break;
 	}
 	result->query_location = root->location;