duckdb 0.7.1 → 0.7.2-dev1034.0

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;
 

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

@@ -0,0 +1,121 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+
+namespace duckdb {
+
+static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry = true) {
+	if (expr->type == ExpressionType::COLUMN_REF) {
+		auto &colref = (ColumnRefExpression &)*expr;
+		if (colref.IsQualified()) {
+			throw ParserException("PIVOT IN list cannot contain qualified column references");
+		}
+		entry.values.emplace_back(colref.GetColumnName());
+	} else if (expr->type == ExpressionType::VALUE_CONSTANT) {
+		auto &constant_expr = (ConstantExpression &)*expr;
+		entry.values.push_back(std::move(constant_expr.value));
+	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
+		auto &function = (FunctionExpression &)*expr;
+		if (function.function_name != "row") {
+			throw ParserException("PIVOT IN list must contain columns or lists of columns");
+		}
+		for (auto &child : function.children) {
+			TransformPivotInList(child, entry, false);
+		}
+	} else if (root_entry && expr->type == ExpressionType::STAR) {
+		entry.star_expr = std::move(expr);
+	} else {
+		throw ParserException("PIVOT IN list must contain columns or lists of columns");
+	}
+}
+
+PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot) {
+	PivotColumn col;
+	if (pivot->pivot_columns) {
+		TransformExpressionList(*pivot->pivot_columns, col.pivot_expressions);
+		for (auto &expr : col.pivot_expressions) {
+			if (expr->IsScalar()) {
+				throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString());
+			}
+			if (expr->HasSubquery()) {
+				throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString());
+			}
+		}
+	} else if (pivot->unpivot_columns) {
+		col.unpivot_names = TransformStringList(pivot->unpivot_columns);
+	} else {
+		throw InternalException("Either pivot_columns or unpivot_columns must be defined");
+	}
+	if (pivot->pivot_value) {
+		for (auto node = pivot->pivot_value->head; node != nullptr; node = node->next) {
+			auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+			auto expr = TransformExpression(n);
+			PivotColumnEntry entry;
+			entry.alias = expr->alias;
+			TransformPivotInList(expr, entry);
+			col.entries.push_back(std::move(entry));
+		}
+	}
+	if (pivot->pivot_enum) {
+		col.pivot_enum = pivot->pivot_enum;
+	}
+	return col;
+}
+
+vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList *list) {
+	vector<PivotColumn> result;
+	for (auto node = list->head; node != nullptr; node = node->next) {
+		auto pivot = (duckdb_libpgquery::PGPivot *)node->data.ptr_value;
+		result.push_back(TransformPivotColumn(pivot));
+	}
+	return result;
+}
+
+unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr *root) {
+	auto result = make_unique<PivotRef>();
+	result->source = TransformTableRefNode(root->source);
+	if (root->aggrs) {
+		TransformExpressionList(*root->aggrs, result->aggregates);
+	}
+	if (root->unpivots) {
+		result->unpivot_names = TransformStringList(root->unpivots);
+	}
+	result->pivots = TransformPivotList(root->pivots);
+	if (root->groups) {
+		result->groups = TransformStringList(root->groups);
+	}
+	for (auto &pivot : result->pivots) {
+		idx_t expected_size;
+		bool is_pivot = result->unpivot_names.empty();
+		if (!result->unpivot_names.empty()) {
+			// unpivot
+			if (pivot.unpivot_names.size() != 1) {
+				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
+			}
+			D_ASSERT(pivot.pivot_expressions.empty());
+			expected_size = pivot.entries[0].values.size();
+		} else {
+			// pivot
+			expected_size = pivot.pivot_expressions.size();
+			D_ASSERT(pivot.unpivot_names.empty());
+		}
+		for (auto &entry : pivot.entries) {
+			if (entry.star_expr && is_pivot) {
+				throw ParserException("PIVOT IN list must contain columns or lists of columns - star expressions are "
+				                      "only supported for UNPIVOT");
+			}
+			if (entry.values.size() != expected_size) {
+				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				                      expected_size, entry.values.size());
+			}
+		}
+	}
+	result->include_nulls = root->include_nulls;
+	result->alias = TransformAlias(root->alias, result->column_name_alias);
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -16,6 +16,8 @@ unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNod
 		return TransformRangeSubselect(reinterpret_cast<duckdb_libpgquery::PGRangeSubselect *>(n));
 	case duckdb_libpgquery::T_PGRangeFunction:
 		return TransformRangeFunction(reinterpret_cast<duckdb_libpgquery::PGRangeFunction *>(n));
+	case duckdb_libpgquery::T_PGPivotExpr:
+		return TransformPivot(reinterpret_cast<duckdb_libpgquery::PGPivotExpr *>(n));
 	default:
 		throw NotImplementedException("From Type %d not supported", n->type);
 	}

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

@@ -3,6 +3,7 @@
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 namespace duckdb {
 
@@ -28,12 +29,24 @@ Transformer::Transformer(Transformer *parent)
     : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
 }
 
+Transformer::~Transformer() {
+}
+
+void Transformer::Clear() {
+	SetParamCount(0);
+	pivot_entries.clear();
+}
+
 bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
 	InitializeStackCheck();
 	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
-		SetParamCount(0);
-		auto stmt = TransformStatement((duckdb_libpgquery::PGNode *)entry->data.ptr_value);
+		Clear();
+		auto n = (duckdb_libpgquery::PGNode *)entry->data.ptr_value;
+		auto stmt = TransformStatement(n);
 		D_ASSERT(stmt);
+		if (HasPivotEntries()) {
+			stmt = CreatePivotStatement(std::move(stmt));
+		}
 		stmt->n_param = ParamCount();
 		statements.push_back(std::move(stmt));
 	}
@@ -154,7 +167,6 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	default:
 		throw NotImplementedException(NodetypeToString(stmt->type));
 	}
-	return nullptr;
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/bind_context.cpp

@@ -13,7 +13,7 @@
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "re2/re2.h"
+#include "duckdb/planner/expression_binder/constant_binder.hpp"
 
 #include <algorithm>
 
@@ -319,31 +319,15 @@ bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, con
 	return false;
 }
 
-bool CheckRegex(const string &column_name, duckdb_re2::RE2 *regex) {
-	if (!regex) {
-		return true;
-	}
-	return RE2::PartialMatch(column_name, *regex);
-}
-
 void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
                                                vector<unique_ptr<ParsedExpression>> &new_select_list) {
 	if (bindings_list.empty()) {
-		throw BinderException("SELECT * expression without FROM clause!");
+		throw BinderException("* expression without FROM clause!");
 	}
 	case_insensitive_set_t excluded_columns;
 	if (expr.relation_name.empty()) {
 		// SELECT * case
 		// bind all expressions of each table in-order
-		unique_ptr<duckdb_re2::RE2> regex;
-		bool found_match = true;
-		if (!expr.regex.empty()) {
-			regex = make_unique<duckdb_re2::RE2>(expr.regex);
-			if (!regex->error().empty()) {
-				throw BinderException("Failed to compile regex \"%s\": %s", expr.regex, regex->error());
-			}
-			found_match = false;
-		}
 		unordered_set<UsingColumnSet *> handled_using_columns;
 		for (auto &entry : bindings_list) {
 			auto binding = entry.second;
@@ -351,10 +335,6 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
-				if (!CheckRegex(column_name, regex.get())) {
-					continue;
-				}
-				found_match = true;
 				// check if this column is a USING column
 				auto using_binding = GetUsingBinding(column_name, binding->alias);
 				if (using_binding) {
@@ -384,9 +364,6 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
 			}
 		}
-		if (!found_match) {
-			throw BinderException("No matching columns found that match regex \"%s\"", expr.regex);
-		}
 	} else {
 		// SELECT tbl.* case
 		// SELECT struct.* case
@@ -555,4 +532,20 @@ void BindContext::AddContext(BindContext other) {
 	}
 }
 
+void BindContext::RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list) {
+	for (auto &other_binding : other_bindings_list) {
+		if (bindings.find(other_binding.first) != bindings.end()) {
+			bindings.erase(other_binding.first);
+		}
+	}
+
+	vector<idx_t> delete_list_indexes;
+	for (auto &other_binding : other_bindings_list) {
+		auto it =
+		    std::remove_if(bindings_list.begin(), bindings_list.end(),
+		                   [other_binding](std::pair<string, Binding *> &x) { return x.first == other_binding.first; });
+		bindings_list.erase(it, bindings_list.end());
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp

@@ -7,7 +7,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
@@ -81,7 +81,7 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 	}
 }
 
-BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -208,8 +208,9 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	auto bound_function = func->functions.GetFunctionByOffset(best_function);
 
 	// Bind any sort columns, unless the aggregate is order-insensitive
-	auto order_bys = make_unique<BoundOrderModifier>();
+	unique_ptr<BoundOrderModifier> order_bys;
 	if (!aggr.order_bys->orders.empty()) {
+		order_bys = make_unique<BoundOrderModifier>();
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
 			auto &order_expr = (BoundExpression &)*order.expression;
@@ -218,16 +219,17 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 			const auto null_order = (order.null_order == OrderByNullType::ORDER_DEFAULT)
 			                            ? config.options.default_null_order
 			                            : order.null_order;
-			order_bys->orders.emplace_back(BoundOrderByNode(sense, null_order, std::move(order_expr.expr)));
+			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr.expr));
 		}
 	}
 
-	auto aggregate = function_binder.BindAggregateFunction(
-	    bound_function, std::move(children), std::move(bound_filter),
-	    aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT, std::move(order_bys));
+	auto aggregate =
+	    function_binder.BindAggregateFunction(bound_function, std::move(children), std::move(bound_filter),
+	                                          aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
 	if (aggr.export_state) {
 		aggregate = ExportAggregateFunction::Bind(std::move(aggregate));
 	}
+	aggregate->order_bys = std::move(order_bys);
 
 	// check for all the aggregates if this aggregate already exists
 	idx_t aggr_index;

package/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp

@@ -175,11 +175,12 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpress
 		}
 	}
 	// We found the table, now create the struct_pack expression
-	vector<unique_ptr<ParsedExpression>> child_exprs;
+	vector<unique_ptr<ParsedExpression>> child_expressions;
+	child_expressions.reserve(binding->names.size());
 	for (const auto &column_name : binding->names) {
-		child_exprs.push_back(make_unique<ColumnRefExpression>(column_name, table_name));
+		child_expressions.push_back(make_unique<ColumnRefExpression>(column_name, table_name));
 	}
-	return make_unique<FunctionExpression>("struct_pack", std::move(child_exprs));
+	return make_unique<FunctionExpression>("struct_pack", std::move(child_expressions));
 }
 
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &colref, string &error_message) {

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -18,13 +18,6 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
                                             unique_ptr<ParsedExpression> *expr_ptr) {
 	// lookup the function in the catalog
 	QueryErrorContext error_context(binder.root_statement, function.query_location);
-
-	if (function.function_name == "unnest" || function.function_name == "unlist") {
-		// special case, not in catalog
-		// TODO make sure someone does not create such a function OR
-		// have unnest live in catalog, too
-		return BindUnnest(function, depth);
-	}
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
 	                              function.function_name, true, error_context);
 	if (!func) {
@@ -38,10 +31,28 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 			                       "function has to be called in a FROM clause (similar to a table).",
 			                       function.function_name)));
 		}
-		// not a table function - search again without if_exists to throw the error
-		Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-		                  function.function_name, false, error_context);
-		throw InternalException("Catalog::GetEntry for scalar function did not throw a second time");
+		// not a table function - check if the schema is set
+		if (!function.schema.empty()) {
+			// the schema is set - check if we can turn this the schema into a column ref
+			string error;
+			unique_ptr<ColumnRefExpression> colref;
+			if (function.catalog.empty()) {
+				colref = make_unique<ColumnRefExpression>(function.schema);
+			} else {
+				colref = make_unique<ColumnRefExpression>(function.schema, function.catalog);
+			}
+			auto new_colref = QualifyColumnName(*colref, error);
+			if (error.empty()) {
+				// we can! transform this into a function call on the column
+				// i.e. "x.lower()" becomes "lower(x)"
+				function.children.insert(function.children.begin(), std::move(colref));
+				function.catalog = INVALID_CATALOG;
+				function.schema = INVALID_SCHEMA;
+			}
+		}
+		// rebind the function
+		func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
+		                         function.function_name, false, error_context);
 	}
 
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
@@ -228,7 +239,7 @@ BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFu
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 
-BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth) {
+BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression) {
 	return BindResult(binder.FormatError(expr, UnsupportedUnnestMessage()));
 }
 

package/src/duckdb/src/planner/binder/expression/bind_lambda.cpp

@@ -48,7 +48,6 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 
 	// positional parameters as column references
 	for (idx_t i = 0; i < expr.params.size(); i++) {
-
 		if (expr.params[i]->GetExpressionClass() != ExpressionClass::COLUMN_REF) {
 			throw BinderException("Parameter must be a column name.");
 		}
@@ -80,7 +79,9 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	// bind the parameter expressions
 	for (idx_t i = 0; i < expr.params.size(); i++) {
 		auto result = BindExpression(&expr.params[i], depth, false);
-		D_ASSERT(!result.HasError());
+		if (result.HasError()) {
+			throw InternalException("Error during lambda binding: %s", result.error);
+		}
 	}
 
 	auto result = BindExpression(&expr.expr, depth, false);