duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -1,7 +1,9 @@
+#include "duckdb/common/serializer/enum_serializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 
 #include "duckdb/parser/expression/operator_expression.hpp"
@@ -24,7 +26,7 @@ static ExpressionType WindowToExpressionType(string &fun_name) {
 		return ExpressionType::WINDOW_FIRST_VALUE;
 	} else if (fun_name == "last_value" || fun_name == "last") {
 		return ExpressionType::WINDOW_LAST_VALUE;
-	} else if (fun_name == "nth_value" || fun_name == "last") {
+	} else if (fun_name == "nth_value") {
 		return ExpressionType::WINDOW_NTH_VALUE;
 	} else if (fun_name == "cume_dist") {
 		return ExpressionType::WINDOW_CUME_DIST;
@@ -94,6 +96,27 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_sp
 	}
 }
 
+bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
+	if (expr.expression_class != ExpressionClass::STAR) {
+		return false;
+	}
+	auto &star = (StarExpression &)expr;
+	if (!star.columns && star.exclude_list.empty() && star.replace_list.empty()) {
+		return true;
+	}
+	return false;
+}
+
+bool Transformer::InWindowDefinition() {
+	if (in_window_definition) {
+		return true;
+	}
+	if (parent) {
+		return parent->InWindowDefinition();
+	}
+	return false;
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
 	auto name = root->funcname;
 	string catalog, schema, function_name;
@@ -113,12 +136,25 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		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");
+		throw ParserException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
 	}
 
-	auto lowercase_name = StringUtil::Lower(function_name);
+	//  transform children
+	vector<unique_ptr<ParsedExpression>> children;
+	if (root->args) {
+		TransformExpressionList(*root->args, children);
+	}
+	if (children.size() == 1 && ExpressionIsEmptyStar(*children[0]) && !root->agg_distinct && !root->agg_order) {
+		// COUNT(*) gets translated into COUNT()
+		children.clear();
+	}
 
+	auto lowercase_name = StringUtil::Lower(function_name);
 	if (root->over) {
+		if (InWindowDefinition()) {
+			throw ParserException("window functions are not allowed in window definitions");
+		}
+
 		const auto win_fun_type = WindowToExpressionType(lowercase_name);
 		if (win_fun_type == ExpressionType::INVALID) {
 			throw InternalException("Unknown/unsupported window function");
@@ -151,39 +187,32 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			expr->filter_expr = std::move(filter_expr);
 		}
 
-		if (root->args) {
-			vector<unique_ptr<ParsedExpression>> function_list;
-			TransformExpressionList(*root->args, function_list);
-
-			if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
-				for (auto &child : function_list) {
-					expr->children.push_back(std::move(child));
+		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
+			expr->children = std::move(children);
+		} else {
+			if (!children.empty()) {
+				expr->children.push_back(std::move(children[0]));
+			}
+			if (win_fun_type == ExpressionType::WINDOW_LEAD || win_fun_type == ExpressionType::WINDOW_LAG) {
+				if (children.size() > 1) {
+					expr->offset_expr = std::move(children[1]);
 				}
-			} else {
-				if (!function_list.empty()) {
-					expr->children.push_back(std::move(function_list[0]));
+				if (children.size() > 2) {
+					expr->default_expr = std::move(children[2]);
+				}
+				if (children.size() > 3) {
+					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
+				}
+			} else if (win_fun_type == ExpressionType::WINDOW_NTH_VALUE) {
+				if (children.size() > 1) {
+					expr->children.push_back(std::move(children[1]));
 				}
-				if (win_fun_type == ExpressionType::WINDOW_LEAD || win_fun_type == ExpressionType::WINDOW_LAG) {
-					if (function_list.size() > 1) {
-						expr->offset_expr = std::move(function_list[1]);
-					}
-					if (function_list.size() > 2) {
-						expr->default_expr = std::move(function_list[2]);
-					}
-					if (function_list.size() > 3) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
-				} else if (win_fun_type == ExpressionType::WINDOW_NTH_VALUE) {
-					if (function_list.size() > 1) {
-						expr->children.push_back(std::move(function_list[1]));
-					}
-					if (function_list.size() > 2) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
-				} else {
-					if (function_list.size() > 1) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
+				if (children.size() > 2) {
+					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
+				}
+			} else {
+				if (children.size() > 1) {
+					throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
 				}
 			}
 		}
@@ -205,8 +234,10 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			window_ref = it->second;
 			D_ASSERT(window_ref);
 		}
+		in_window_definition = true;
 		TransformWindowDef(window_ref, expr.get());
 		TransformWindowFrame(window_spec, expr.get());
+		in_window_definition = false;
 		expr->query_location = root->location;
 		return std::move(expr);
 	}
@@ -215,14 +246,6 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		throw ParserException("IGNORE NULLS is not supported for non-window functions");
 	}
 
-	//  TransformExpressionList??
-	vector<unique_ptr<ParsedExpression>> children;
-	if (root->args != nullptr) {
-		for (auto node = root->args->head; node != nullptr; node = node->next) {
-			auto child_expr = TransformExpression((duckdb_libpgquery::PGNode *)node->data.ptr_value);
-			children.push_back(std::move(child_expr));
-		}
-	}
 	unique_ptr<ParsedExpression> filter_expr;
 	if (root->agg_filter) {
 		filter_expr = TransformExpression(root->agg_filter);
@@ -289,6 +312,26 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		coalesce_op->children.push_back(std::move(children[0]));
 		coalesce_op->children.push_back(std::move(children[1]));
 		return std::move(coalesce_op);
+	} else if (lowercase_name == "list" && order_bys->orders.size() == 1) {
+		// list(expr ORDER BY expr <sense> <nulls>) => list_sort(list(expr), <sense>, <nulls>)
+		if (children.size() != 1) {
+			throw ParserException("Wrong number of arguments to LIST.");
+		}
+		auto arg_expr = children[0].get();
+		auto &order_by = order_bys->orders[0];
+		if (arg_expr->Equals(order_by.expression.get())) {
+			auto sense = make_unique<ConstantExpression>(EnumSerializer::EnumToString(order_by.type));
+			auto nulls = make_unique<ConstantExpression>(EnumSerializer::EnumToString(order_by.null_order));
+			order_bys = nullptr;
+			auto unordered = make_unique<FunctionExpression>(
+			    catalog, schema, lowercase_name.c_str(), std::move(children), std::move(filter_expr),
+			    std::move(order_bys), root->agg_distinct, false, root->export_state);
+			lowercase_name = "list_sort";
+			children.clear();
+			children.emplace_back(std::move(unordered));
+			children.emplace_back(std::move(sense));
+			children.emplace_back(std::move(nulls));
+		}
 	}
 
 	auto function = make_unique<FunctionExpression>(std::move(catalog), std::move(schema), lowercase_name.c_str(),

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

@@ -84,7 +84,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		return std::move(subquery_expr);

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

@@ -44,7 +44,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		break;

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

@@ -2,16 +2,22 @@
 
 namespace duckdb {
 
+vector<string> Transformer::TransformStringList(duckdb_libpgquery::PGList *list) {
+	vector<string> result;
+	if (!list) {
+		return result;
+	}
+	for (auto node = list->head; node != nullptr; node = node->next) {
+		result.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
+	}
+	return result;
+}
+
 string Transformer::TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias) {
 	if (!root) {
 		return "";
 	}
-	if (root->colnames) {
-		for (auto node = root->colnames->head; node != nullptr; node = node->next) {
-			column_name_alias.emplace_back(
-			    reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
-		}
-	}
+	column_name_alias = TransformStringList(root->colnames);
 	return root->aliasname;
 }
 

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

@@ -6,9 +6,33 @@
 
 namespace duckdb {
 
+unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
+	auto result = make_unique<CommonTableExpressionInfo>();
+	result->aliases = aliases;
+	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	return result;
+}
+
+void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
+	for (auto &cte_entry : stored_cte_map) {
+		for (auto &entry : cte_entry->map) {
+			auto found_entry = cte_map.map.find(entry.first);
+			if (found_entry != cte_map.map.end()) {
+				// entry already present - use top-most entry
+				continue;
+			}
+			cte_map.map[entry.first] = entry.second->Copy();
+		}
+	}
+	if (parent) {
+		parent->ExtractCTEsRecursive(cte_map);
+	}
+}
+
 void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, CommonTableExpressionMap &cte_map) {
 	// TODO: might need to update in case of future lawsuit
 	D_ASSERT(de_with_clause);
+	stored_cte_map.push_back(&cte_map);
 
 	D_ASSERT(de_with_clause->ctes);
 	for (auto cte_ele = de_with_clause->ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {

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

@@ -176,6 +176,13 @@ bool Transformer::TransformGroupBy(duckdb_libpgquery::PGList *group, SelectNode
 			result.grouping_sets = std::move(new_sets);
 		}
 	}
+	if (result.group_expressions.size() == 1 && result.grouping_sets.size() == 1 &&
+	    ExpressionIsEmptyStar(*result.group_expressions[0])) {
+		// GROUP BY *
+		result.group_expressions.clear();
+		result.grouping_sets.clear();
+		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
+	}
 	return true;
 }
 

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

@@ -36,13 +36,6 @@ bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<Orde
 				throw NotImplementedException("Unimplemented order by type");
 			}
 			auto order_expression = TransformExpression(target);
-			if (order_expression->GetExpressionClass() == ExpressionClass::STAR) {
-				auto &star_expr = (StarExpression &)*order_expression;
-				D_ASSERT(star_expr.relation_name.empty());
-				if (star_expr.columns) {
-					throw ParserException("COLUMNS expr is not supported in ORDER BY");
-				}
-			}
 			result.emplace_back(type, null_order, std::move(order_expression));
 		} else {
 			throw NotImplementedException("ORDER BY list member type %d\n", temp->type);

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

@@ -52,7 +52,8 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 			children.push_back(make_pair(entry_name, entry_type));
 		}
 		D_ASSERT(!children.empty());
-		result_type = LogicalType::STRUCT(std::move(children));
+		result_type = LogicalType::STRUCT(children);
+
 	} else if (base_type == LogicalTypeId::MAP) {
 
 		if (!type_name->typmods || type_name->typmods->length != 2) {
@@ -207,7 +208,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 		// array bounds: turn the type into a list
 		idx_t extra_stack = 0;
 		for (auto cell = type_name->arrayBounds->head; cell != nullptr; cell = cell->next) {
-			result_type = LogicalType::LIST(std::move(result_type));
+			result_type = LogicalType::LIST(result_type);
 			StackCheck(extra_stack++);
 		}
 	}

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

@@ -29,6 +29,10 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 		auto query_node = TransformSelect(stmt->query, true)->node->Copy();
 		macro_func = make_unique<TableMacroFunction>(std::move(query_node));
 	}
+	if (HasPivotEntries()) {
+		throw ParserException("Cannot use PIVOT statement syntax in a macro. Use the SQL standard PIVOT syntax in the "
+		                      "FROM clause instead.");
+	}
 
 	auto info =
 	    make_unique<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));

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

@@ -26,6 +26,10 @@ unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 
 	info->query = TransformSelect(stmt->query, false);
+	if (HasPivotEntries()) {
+		throw ParserException("Cannot use PIVOT statement syntax in a view. Use the SQL standard PIVOT syntax in the "
+		                      "FROM clause instead.");
+	}
 
 	if (stmt->aliases && stmt->aliases->length > 0) {
 		for (auto c = stmt->aliases->head; c != nullptr; c = lnext(c)) {

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

@@ -0,0 +1,179 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/statement/create_statement.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/statement/multi_statement.hpp"
+#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/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, unique_ptr<ParsedExpression> column) {
+	if (parent) {
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
+		return;
+	}
+	auto result = make_unique<CreatePivotEntry>();
+	result->enum_name = std::move(enum_name);
+	result->base = std::move(base);
+	result->column = std::move(column);
+
+	pivot_entries.push_back(std::move(result));
+}
+
+bool Transformer::HasPivotEntries() {
+	if (parent) {
+		return parent->HasPivotEntries();
+	}
+	return !pivot_entries.empty();
+}
+
+idx_t Transformer::PivotEntryCount() {
+	if (parent) {
+		return parent->PivotEntryCount();
+	}
+	return pivot_entries.size();
+}
+
+unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
+	auto result = make_unique<CreateStatement>();
+	auto info = make_unique<CreateTypeInfo>();
+
+	info->temporary = true;
+	info->internal = false;
+	info->catalog = INVALID_CATALOG;
+	info->schema = INVALID_SCHEMA;
+	info->name = std::move(entry->enum_name);
+	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
+
+	// generate the query that will result in the enum creation
+	auto select_node = std::move(entry->base);
+	auto columnref = entry->column->Copy();
+	auto cast = make_unique<CastExpression>(LogicalType::VARCHAR, columnref->Copy());
+	select_node->select_list.push_back(std::move(cast));
+
+	auto is_not_null = make_unique<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(std::move(modifier));
+
+	auto select = make_unique<SelectStatement>();
+	select->node = std::move(select_node);
+	info->query = std::move(select);
+	info->type = LogicalType::INVALID;
+
+	result->info = std::move(info);
+	return std::move(result);
+}
+
+// unique_ptr<SQLStatement> GenerateDropEnumStmt(string enum_name) {
+//	auto result = make_unique<DropStatement>();
+//	result->info->if_exists = true;
+//	result->info->schema = INVALID_SCHEMA;
+//	result->info->catalog = INVALID_CATALOG;
+//	result->info->name = std::move(enum_name);
+//	result->info->type = CatalogType::TYPE_ENTRY;
+//	return std::move(result);
+//}
+
+unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStatement> statement) {
+	auto result = make_unique<MultiStatement>();
+	for (auto &pivot : pivot_entries) {
+		result->statements.push_back(GenerateCreateEnumStmt(std::move(pivot)));
+	}
+	result->statements.push_back(std::move(statement));
+	// FIXME: drop the types again!?
+	//	for(auto &pivot : pivot_entries) {
+	//		result->statements.push_back(GenerateDropEnumStmt(std::move(pivot->enum_name)));
+	//	}
+	return std::move(result);
+}
+
+unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt) {
+	auto pivot = stmt->pivot;
+	auto source = TransformTableRefNode(pivot->source);
+
+	auto select_node = make_unique<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_unique<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.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>();
+		ExtractCTEsRecursive(new_select->cte_map);
+		new_select->from_table = source->Copy();
+		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>());
+
+	auto pivot_ref = make_unique<PivotRef>();
+	pivot_ref->source = std::move(source);
+	if (pivot->unpivots) {
+		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
+	} else {
+		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_unique<FunctionExpression>("count_star", std::move(children));
+			pivot_ref->aggregates.push_back(std::move(function));
+		}
+	}
+	if (pivot->groups) {
+		pivot_ref->groups = TransformStringList(pivot->groups);
+	}
+	pivot_ref->pivots = std::move(columns);
+	select_node->from_table = std::move(pivot_ref);
+	return std::move(select_node);
+}
+
+} // namespace duckdb

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: {
@@ -36,7 +36,6 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		info = make_unique<RenameTableInfo>(std::move(data), new_name);
 		break;
 	}
-
 	case duckdb_libpgquery::PG_OBJECT_VIEW: {
 		// change view name
 		string new_name = stmt->newname;

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

@@ -4,6 +4,14 @@
 
 namespace duckdb {
 
+unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt *stmt) {
+	if (stmt->pivot) {
+		return TransformPivotStatement(stmt);
+	} else {
+		return TransformSelectInternal(stmt);
+	}
+}
+
 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>();

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

@@ -8,7 +8,7 @@
 
 namespace duckdb {
 
-unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt *stmt) {
+unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *stmt) {
 	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
 	auto stack_checker = StackCheck();
 
@@ -26,8 +26,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 				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);

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

@@ -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;