duckdb 0.7.2-dev886.0 → 0.7.2-dev904.0

package/src/duckdb/src/planner/expression_binder/select_binder.cpp

@@ -1,145 +1,14 @@
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/binder.hpp"
-
 namespace duckdb {
 
 SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                            case_insensitive_map_t<idx_t> alias_map)
-    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info), alias_map(std::move(alias_map)) {
+    : BaseSelectBinder(binder, context, node, info, std::move(alias_map)) {
 }
 
 SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info)
     : SelectBinder(binder, context, node, info, case_insensitive_map_t<idx_t>()) {
 }
 
-BindResult SelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth);
-	case ExpressionClass::DEFAULT:
-		return BindResult("SELECT clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindWindow((WindowExpression &)expr, depth);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-idx_t SelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
-	// first check the group alias map, if expr is a ColumnRefExpression
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		if (!colref.IsQualified()) {
-			auto alias_entry = info.alias_map.find(colref.column_names[0]);
-			if (alias_entry != info.alias_map.end()) {
-				// found entry!
-				return alias_entry->second;
-			}
-		}
-	}
-	// no alias reference found
-	// check the list of group columns for a match
-	auto entry = info.map.find(&expr);
-	if (entry != info.map.end()) {
-		return entry->second;
-	}
-#ifdef DEBUG
-	for (auto entry : info.map) {
-		D_ASSERT(!entry.first->Equals(&expr));
-		D_ASSERT(!expr.Equals(entry.first));
-	}
-#endif
-	return DConstants::INVALID_INDEX;
-}
-
-BindResult SelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
-	// first try to bind the column reference regularly
-	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
-	if (!result.HasError()) {
-		return result;
-	}
-	// binding failed
-	// check in the alias map
-	auto &colref = (ColumnRefExpression &)**expr_ptr;
-	if (!colref.IsQualified()) {
-		auto alias_entry = alias_map.find(colref.column_names[0]);
-		if (alias_entry != alias_map.end()) {
-			// found entry!
-			auto index = alias_entry->second;
-			if (index >= node.select_list.size()) {
-				throw BinderException("Column \"%s\" referenced that exists in the SELECT clause - but this column "
-				                      "cannot be referenced before it is defined",
-				                      colref.column_names[0]);
-			}
-			if (node.select_list[index]->HasSideEffects()) {
-				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has side "
-				                      "effects. This is not yet supported.",
-				                      colref.column_names[0]);
-			}
-			if (node.select_list[index]->HasSubquery()) {
-				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has a subquery."
-				                      " This is not yet supported.",
-				                      colref.column_names[0]);
-			}
-			auto result = BindResult(node.select_list[index]->Copy());
-			if (result.expression->type == ExpressionType::BOUND_COLUMN_REF) {
-				auto &result_expr = (BoundColumnRefExpression &)*result.expression;
-				result_expr.depth = depth;
-			}
-			return result;
-		}
-	}
-	// entry was not found in the alias map: return the original error
-	return result;
-}
-
-BindResult SelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
-	if (op.children.empty()) {
-		throw InternalException("GROUPING requires at least one child");
-	}
-	if (node.groups.group_expressions.empty()) {
-		return BindResult(binder.FormatError(op, "GROUPING statement cannot be used without groups"));
-	}
-	if (op.children.size() >= 64) {
-		return BindResult(binder.FormatError(op, "GROUPING statement cannot have more than 64 groups"));
-	}
-	vector<idx_t> group_indexes;
-	group_indexes.reserve(op.children.size());
-	for (auto &child : op.children) {
-		ExpressionBinder::QualifyColumnNames(binder, child);
-		auto idx = TryBindGroup(*child, depth);
-		if (idx == DConstants::INVALID_INDEX) {
-			return BindResult(binder.FormatError(
-			    op, StringUtil::Format("GROUPING child \"%s\" must be a grouping column", child->GetName())));
-		}
-		group_indexes.push_back(idx);
-	}
-	auto col_idx = node.grouping_functions.size();
-	node.grouping_functions.push_back(std::move(group_indexes));
-	return BindResult(make_unique<BoundColumnRefExpression>(op.GetName(), LogicalType::BIGINT,
-	                                                        ColumnBinding(node.groupings_index, col_idx), depth));
-}
-
-BindResult SelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index) {
-	auto &group = node.groups.group_expressions[group_index];
-	return BindResult(make_unique<BoundColumnRefExpression>(expr.GetName(), group->return_type,
-	                                                        ColumnBinding(node.group_index, group_index), depth));
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/planner/expression_binder.hpp"
 
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/positional_reference_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
@@ -52,9 +53,15 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> *expr,
 		return BindExpression((ConjunctionExpression &)expr_ref, depth);
 	case ExpressionClass::CONSTANT:
 		return BindExpression((ConstantExpression &)expr_ref, depth);
-	case ExpressionClass::FUNCTION:
+	case ExpressionClass::FUNCTION: {
+		auto &function = (FunctionExpression &)expr_ref;
+		if (function.function_name == "unnest" || function.function_name == "unlist") {
+			// special case, not in catalog
+			return BindUnnest(function, depth, root_expression);
+		}
 		// binding function expression has extra parameter needed for macro's
-		return BindExpression((FunctionExpression &)expr_ref, depth, expr);
+		return BindExpression(function, depth, expr);
+	}
 	case ExpressionClass::LAMBDA:
 		return BindExpression((LambdaExpression &)expr_ref, depth, false, LogicalTypeId::INVALID);
 	case ExpressionClass::OPERATOR:

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -200,22 +200,24 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	}
 	case QueryNodeType::SELECT_NODE: {
 		auto &bound_select = (BoundSelectNode &)node;
-		for (idx_t i = 0; i < bound_select.select_list.size(); i++) {
-			EnumerateExpression(bound_select.select_list[i], callback);
+		for (auto &expr : bound_select.select_list) {
+			EnumerateExpression(expr, callback);
 		}
 		EnumerateExpression(bound_select.where_clause, callback);
-		for (idx_t i = 0; i < bound_select.groups.group_expressions.size(); i++) {
-			EnumerateExpression(bound_select.groups.group_expressions[i], callback);
+		for (auto &expr : bound_select.groups.group_expressions) {
+			EnumerateExpression(expr, callback);
 		}
 		EnumerateExpression(bound_select.having, callback);
-		for (idx_t i = 0; i < bound_select.aggregates.size(); i++) {
-			EnumerateExpression(bound_select.aggregates[i], callback);
+		for (auto &expr : bound_select.aggregates) {
+			EnumerateExpression(expr, callback);
 		}
-		for (idx_t i = 0; i < bound_select.unnests.size(); i++) {
-			EnumerateExpression(bound_select.unnests[i], callback);
+		for (auto &entry : bound_select.unnests) {
+			for (auto &expr : entry.second.expressions) {
+				EnumerateExpression(expr, callback);
+			}
 		}
-		for (idx_t i = 0; i < bound_select.windows.size(); i++) {
-			EnumerateExpression(bound_select.windows[i], callback);
+		for (auto &expr : bound_select.windows) {
+			EnumerateExpression(expr, callback);
 		}
 		if (bound_select.from_table) {
 			EnumerateTableRefChildren(*bound_select.from_table, callback);

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -1169,6 +1169,7 @@ typedef struct PGUpdateStmt {
 typedef struct PGPivot {
 	PGNodeTag type;
 	PGList *pivot_columns;  /* The column names to pivot on */
+	PGList *unpivot_columns;/* The column names to unpivot */
 	PGList *pivot_value;    /* The set of pivot values */
 	char *pivot_enum;       /* The enum to fetch the unique values from */
 } PGPivot;