duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -12,7 +12,7 @@ BoundWindowExpression::BoundWindowExpression(ExpressionType type, LogicalType re
                                              unique_ptr<AggregateFunction> aggregate,
                                              unique_ptr<FunctionData> bind_info)
     : Expression(type, ExpressionClass::BOUND_WINDOW, std::move(return_type)), aggregate(std::move(aggregate)),
-      bind_info(std::move(bind_info)), ignore_nulls(false) {
+      bind_info(std::move(bind_info)), ignore_nulls(false), distinct(false) {
 }
 
 string BoundWindowExpression::ToString() const {
@@ -30,9 +30,28 @@ bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	if (ignore_nulls != other.ignore_nulls) {
 		return false;
 	}
+	if (distinct != other.distinct) {
+		return false;
+	}
 	if (start != other.start || end != other.end) {
 		return false;
 	}
+	if (exclude_clause != other.exclude_clause) {
+		return false;
+	}
+
+	// If there are aggregates, check they are equal
+	if (aggregate.get() != other.aggregate.get()) {
+		if (!aggregate || !other.aggregate || *aggregate != *other.aggregate) {
+			return false;
+		}
+	}
+	// If there's function data, check if they are equal
+	if (bind_info.get() != other.bind_info.get()) {
+		if (!bind_info || !other.bind_info || !bind_info->Equals(*other.bind_info)) {
+			return false;
+		}
+	}
 	// check if the child expressions are equivalent
 	if (!Expression::ListEquals(children, other.children)) {
 		return false;
@@ -51,9 +70,39 @@ bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	return KeysAreCompatible(other);
 }
 
+bool BoundWindowExpression::PartitionsAreEquivalent(const BoundWindowExpression &other) const {
+	// Partitions are not order sensitive.
+	if (partitions.size() != other.partitions.size()) {
+		return false;
+	}
+	// TODO: Should partitions be an expression_set_t?
+	expression_set_t others;
+	for (const auto &partition : other.partitions) {
+		others.insert(*partition);
+	}
+	for (const auto &partition : partitions) {
+		if (!others.count(*partition)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+idx_t BoundWindowExpression::GetSharedOrders(const BoundWindowExpression &other) const {
+	const auto overlap = MinValue<idx_t>(orders.size(), other.orders.size());
+
+	idx_t result = 0;
+	for (; result < overlap; ++result) {
+		if (!orders[result].Equals(other.orders[result])) {
+			return false;
+		}
+	}
+
+	return result;
+}
+
 bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
-	// check if the partitions are equivalent
-	if (!Expression::ListEquals(partitions, other.partitions)) {
+	if (!PartitionsAreEquivalent(other)) {
 		return false;
 	}
 	// check if the orderings are equivalent
@@ -99,12 +148,21 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 
 	new_window->start = start;
 	new_window->end = end;
+	new_window->exclude_clause = exclude_clause;
 	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
 	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
 	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
 	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
 	new_window->ignore_nulls = ignore_nulls;
+	new_window->distinct = distinct;
 
+	for (auto &es : expr_stats) {
+		if (es) {
+			new_window->expr_stats.push_back(es->ToUnique());
+		} else {
+			new_window->expr_stats.push_back(nullptr);
+		}
+	}
 	return std::move(new_window);
 }
 
@@ -126,6 +184,8 @@ void BoundWindowExpression::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault(209, "end_expr", end_expr, unique_ptr<Expression>());
 	serializer.WritePropertyWithDefault(210, "offset_expr", offset_expr, unique_ptr<Expression>());
 	serializer.WritePropertyWithDefault(211, "default_expr", default_expr, unique_ptr<Expression>());
+	serializer.WriteProperty(212, "exclude_clause", exclude_clause);
+	serializer.WriteProperty(213, "distinct", distinct);
 }
 
 unique_ptr<Expression> BoundWindowExpression::Deserialize(Deserializer &deserializer) {
@@ -153,6 +213,8 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(Deserializer &deserial
 	deserializer.ReadPropertyWithDefault(209, "end_expr", result->end_expr, unique_ptr<Expression>());
 	deserializer.ReadPropertyWithDefault(210, "offset_expr", result->offset_expr, unique_ptr<Expression>());
 	deserializer.ReadPropertyWithDefault(211, "default_expr", result->default_expr, unique_ptr<Expression>());
+	deserializer.ReadProperty(212, "exclude_clause", result->exclude_clause);
+	deserializer.ReadProperty(213, "distinct", result->distinct);
 	return std::move(result);
 }
 

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

@@ -38,14 +38,24 @@ bool Expression::IsScalar() const {
 	return is_scalar;
 }
 
-bool Expression::HasSideEffects() const {
-	bool has_side_effects = false;
+bool Expression::IsVolatile() const {
+	bool is_volatile = false;
 	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (child.HasSideEffects()) {
-			has_side_effects = true;
+		if (child.IsVolatile()) {
+			is_volatile = true;
 		}
 	});
-	return has_side_effects;
+	return is_volatile;
+}
+
+bool Expression::IsConsistent() const {
+	bool is_consistent = true;
+	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
+		if (!child.IsConsistent()) {
+			is_consistent = false;
+		}
+	});
+	return is_consistent;
 }
 
 bool Expression::PropagatesNullValues() const {

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

@@ -88,7 +88,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_pt
 				                      "cannot be referenced before it is defined",
 				                      colref.column_names[0]);
 			}
-			if (node.select_list[index]->HasSideEffects()) {
+			if (node.select_list[index]->IsVolatile()) {
 				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has side "
 				                      "effects. This is not yet supported.",
 				                      colref.column_names[0]);
@@ -112,10 +112,10 @@ BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t
 		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"));
+		return BindResult(BinderException(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"));
+		return BindResult(BinderException(op, "GROUPING statement cannot have more than 64 groups"));
 	}
 	vector<idx_t> group_indexes;
 	group_indexes.reserve(op.children.size());
@@ -123,8 +123,7 @@ BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t
 		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())));
+			return BindResult(BinderException(op, "GROUPING child \"%s\" must be a grouping column", child->GetName()));
 		}
 		group_indexes.push_back(idx);
 	}
@@ -150,7 +149,7 @@ BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_
 
 bool BaseSelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
 	if (!colref.IsQualified()) {
-		return alias_map.find(colref.column_names[0]) != alias_map.end() ? true : false;
+		return alias_map.find(colref.column_names[0]) != alias_map.end();
 	}
 	return false;
 }

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

@@ -44,14 +44,15 @@ BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref
 
 BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 
-	// if this is a lambda parameters, then we temporarily add a BoundLambdaRef,
-	// which we capture and remove later
-	if (lambda_bindings) {
-		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
-			if (colref.GetColumnName() == (*lambda_bindings)[i].dummy_name) {
-				// FIXME: support lambdas in CHECK constraints
-				// FIXME: like so: return (*lambda_bindings)[i].Bind(colref, i, depth);
-				throw NotImplementedException("Lambda functions are currently not supported in CHECK constraints.");
+	if (!colref.IsQualified()) {
+		if (lambda_bindings) {
+			for (idx_t i = lambda_bindings->size(); i > 0; i--) {
+				if ((*lambda_bindings)[i - 1].HasMatchingBinding(colref.GetName())) {
+					// FIXME: support lambdas in CHECK constraints
+					// FIXME: like so: return (*lambda_bindings)[i - 1].Bind(colref, i, depth);
+					// FIXME: and move this to LambdaRefExpression::FindMatchingBinding
+					throw NotImplementedException("Lambda functions are currently not supported in CHECK constraints.");
+				}
 			}
 		}
 	}

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

@@ -12,19 +12,22 @@ ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensiti
     : node(node), alias_map(alias_map), visited_select_indexes() {
 }
 
-BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
-                                        bool root_expression) {
+bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
+                                  bool root_expression, BindResult &result) {
 	if (expr.IsQualified()) {
-		return BindResult(StringUtil::Format("Alias %s cannot be qualified.", expr.ToString()));
+		// qualified columns cannot be aliases
+		return false;
 	}
 
 	auto alias_entry = alias_map.find(expr.column_names[0]);
 	if (alias_entry == alias_map.end()) {
-		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
+		// no alias found
+		return false;
 	}
 
 	if (visited_select_indexes.find(alias_entry->second) != visited_select_indexes.end()) {
-		return BindResult("Cannot resolve self-referential alias");
+		// self-referential alias cannot be resolved
+		return false;
 	}
 
 	// found an alias: bind the alias expression
@@ -33,9 +36,9 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 
 	// since the alias has been found, pass a depth of 0. See Issue 4978 (#16)
 	// ColumnAliasBinders are only in Having, Qualify and Where Binders
-	auto result = enclosing_binder.BindExpression(expression, 0, root_expression);
+	result = enclosing_binder.BindExpression(expression, depth, root_expression);
 	visited_select_indexes.erase(alias_entry->second);
-	return result;
+	return true;
 }
 
 } // namespace duckdb

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

@@ -17,16 +17,21 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo
 
 BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
-	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
-	if (!alias_result.HasError()) {
+	BindResult alias_result;
+	auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result);
+	if (found_alias) {
 		if (depth > 0) {
-			throw BinderException("Having clause cannot reference alias in correlated subquery");
+			throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery",
+			                      expr.GetColumnName());
 		}
 		return alias_result;
 	}
+
 	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 		if (depth > 0) {
-			throw BinderException("Having clause cannot reference column in correlated subquery and group by all");
+			throw BinderException(
+			    "Having clause cannot reference column \"%s\" in correlated subquery and group by all",
+			    expr.GetColumnName());
 		}
 		auto expr = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 		if (expr.HasError()) {

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

@@ -19,31 +19,6 @@ BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, i
 		return BindResult("window functions are not allowed in index expressions");
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in index expressions");
-	case ExpressionClass::COLUMN_REF: {
-		if (table) {
-			// WAL replay
-			// we assume that the parsed expressions have qualified column names
-			// and that the columns exist in the table
-			auto &col_ref = expr.Cast<ColumnRefExpression>();
-			auto col_idx = table->GetColumnIndex(col_ref.column_names.back());
-			auto col_type = table->GetColumn(col_idx).GetType();
-
-			// find the col_idx in the index.column_ids
-			auto col_id_idx = DConstants::INVALID_INDEX;
-			for (idx_t i = 0; i < info->column_ids.size(); i++) {
-				if (col_idx.index == info->column_ids[i]) {
-					col_id_idx = i;
-				}
-			}
-
-			if (col_id_idx == DConstants::INVALID_INDEX) {
-				throw InternalException("failed to replay CREATE INDEX statement - column id not found");
-			}
-			return BindResult(
-			    make_uniq<BoundColumnRefExpression>(col_ref.GetColumnName(), col_type, ColumnBinding(0, col_id_idx)));
-		}
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

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

@@ -25,7 +25,8 @@ OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, Selec
 	this->extra_list = &node.select_list;
 }
 
-unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, idx_t index) {
+unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, const idx_t index,
+                                                              const LogicalType &logical_type) {
 	string alias;
 	if (extra_list && index < extra_list->size()) {
 		alias = extra_list->at(index)->ToString();
@@ -34,8 +35,7 @@ unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &
 			alias = expr.alias;
 		}
 	}
-	return make_uniq<BoundColumnRefExpression>(std::move(alias), LogicalType::INVALID,
-	                                           ColumnBinding(projection_index, index));
+	return make_uniq<BoundColumnRefExpression>(std::move(alias), logical_type, ColumnBinding(projection_index, index));
 }
 
 unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
@@ -43,7 +43,7 @@ unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpres
 		throw InternalException("CreateExtraReference called without extra_list");
 	}
 	projection_map[*expr] = extra_list->size();
-	auto result = CreateProjectionReference(*expr, extra_list->size());
+	auto result = CreateProjectionReference(*expr, extra_list->size(), LogicalType::INVALID);
 	extra_list->push_back(std::move(expr));
 	return result;
 }
@@ -58,10 +58,7 @@ unique_ptr<Expression> OrderBinder::BindConstant(ParsedExpression &expr, const V
 	}
 	// INTEGER constant: we use the integer as an index into the select list (e.g. ORDER BY 1)
 	auto index = (idx_t)val.GetValue<int64_t>();
-	if (index < 1 || index > max_count) {
-		throw BinderException("ORDER term out of range - should be between 1 and %lld", (idx_t)max_count);
-	}
-	return CreateProjectionReference(expr, index - 1);
+	return CreateProjectionReference(expr, index - 1, LogicalType::ANY);
 }
 
 unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
@@ -89,7 +86,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		auto entry = alias_map.find(colref.column_names[0]);
 		if (entry != alias_map.end()) {
 			// it does! point it to that entry
-			return CreateProjectionReference(*expr, entry->second);
+			return CreateProjectionReference(*expr, entry->second, LogicalType::INVALID);
 		}
 		break;
 	}
@@ -98,7 +95,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		if (posref.index < 1 || posref.index > max_count) {
 			throw BinderException("ORDER term out of range - should be between 1 and %lld", (idx_t)max_count);
 		}
-		return CreateProjectionReference(*expr, posref.index - 1);
+		return CreateProjectionReference(*expr, posref.index - 1, LogicalType::ANY);
 	}
 	case ExpressionClass::PARAMETER: {
 		throw ParameterNotAllowedException("Parameter not supported in ORDER BY clause");
@@ -119,7 +116,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		}
 		// there is a matching entry in the projection list
 		// just point to that entry
-		return CreateProjectionReference(*expr, entry->second);
+		return CreateProjectionReference(*expr, entry->second, LogicalType::INVALID);
 	}
 	if (!extra_list) {
 		// no extra list specified: we cannot push an extra ORDER BY clause

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

@@ -22,8 +22,9 @@ BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr,
 		return result;
 	}
 
-	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
-	if (!alias_result.HasError()) {
+	BindResult alias_result;
+	auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result);
+	if (found_alias) {
 		return alias_result;
 	}
 

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

@@ -8,18 +8,23 @@ namespace duckdb {
 TableFunctionBinder::TableFunctionBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
+BindResult TableFunctionBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
+	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
+	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
+	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
+}
+
 BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression) {
 
-	// if this is a lambda parameters, then we temporarily add a BoundLambdaRef,
-	// which we capture and remove later
-	if (lambda_bindings) {
-		auto &colref = expr.Cast<ColumnRefExpression>();
-		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
-			if (colref.GetColumnName() == (*lambda_bindings)[i].dummy_name) {
-				return (*lambda_bindings)[i].Bind(colref, i, depth);
-			}
+	// try binding as a lambda parameter
+	auto &col_ref = expr.Cast<ColumnRefExpression>();
+	if (!col_ref.IsQualified()) {
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		if (lambda_ref) {
+			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
 		}
 	}
+
 	auto value_function = ExpressionBinder::GetSQLValueFunction(expr.GetColumnName());
 	if (value_function) {
 		return BindExpression(value_function, depth, root_expression);
@@ -33,6 +38,8 @@ BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> &exp
                                                bool root_expression) {
 	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
+	case ExpressionClass::LAMBDA_REF:
+		return BindLambdaReference(expr.Cast<LambdaRefExpression>(), depth);
 	case ExpressionClass::COLUMN_REF:
 		return BindColumnReference(expr.Cast<ColumnRefExpression>(), depth, root_expression);
 	case ExpressionClass::SUBQUERY:

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

@@ -16,12 +16,11 @@ BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, id
 		return result;
 	}
 
-	BindResult alias_result = column_alias_binder->BindAlias(*this, expr, depth, root_expression);
-	// This code path cannot be exercised at thispoint. #1547 might change that.
-	if (!alias_result.HasError()) {
+	BindResult alias_result;
+	auto found_alias = column_alias_binder->BindAlias(*this, expr, depth, root_expression, alias_result);
+	if (found_alias) {
 		return alias_result;
 	}
-
 	return result;
 }
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/planner/expression_binder.hpp"
 
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -61,6 +62,8 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<CollateExpression>(), depth);
 	case ExpressionClass::COLUMN_REF:
 		return BindExpression(expr_ref.Cast<ColumnRefExpression>(), depth);
+	case ExpressionClass::LAMBDA_REF:
+		return BindExpression(expr_ref.Cast<LambdaRefExpression>(), depth);
 	case ExpressionClass::COMPARISON:
 		return BindExpression(expr_ref.Cast<ComparisonExpression>(), depth);
 	case ExpressionClass::CONJUNCTION:
@@ -69,15 +72,15 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<ConstantExpression>(), depth);
 	case ExpressionClass::FUNCTION: {
 		auto &function = expr_ref.Cast<FunctionExpression>();
-		if (function.function_name == "unnest" || function.function_name == "unlist") {
+		if (IsUnnestFunction(function.function_name)) {
 			// special case, not in catalog
 			return BindUnnest(function, depth, root_expression);
 		}
-		// binding function expression has extra parameter needed for macro's
+		// binding a function expression requires an extra parameter for macros
 		return BindExpression(function, depth, expr);
 	}
 	case ExpressionClass::LAMBDA:
-		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, false, LogicalTypeId::INVALID);
+		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, LogicalTypeId::INVALID, nullptr);
 	case ExpressionClass::OPERATOR:
 		return BindExpression(expr_ref.Cast<OperatorExpression>(), depth);
 	case ExpressionClass::SUBQUERY:
@@ -88,43 +91,40 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindPositionalReference(expr, depth, root_expression);
 	}
 	case ExpressionClass::STAR:
-		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
+		return BindResult(BinderException(expr_ref, "STAR expression is not supported here"));
 	default:
 		throw NotImplementedException("Unimplemented expression class");
 	}
 }
 
-bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr) {
+BindResult ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr, ErrorData error_message) {
 	// try to bind in one of the outer queries, if the binding error occurred in a subquery
 	auto &active_binders = binder.GetActiveBinders();
 	// make a copy of the set of binders, so we can restore it later
 	auto binders = active_binders;
-
+	auto bind_error = std::move(error_message);
 	// we already failed with the current binder
 	active_binders.pop_back();
 	idx_t depth = 1;
-	bool success = false;
-
 	while (!active_binders.empty()) {
 		auto &next_binder = active_binders.back().get();
 		ExpressionBinder::QualifyColumnNames(next_binder.binder, expr);
-		auto bind_result = next_binder.Bind(expr, depth);
-		if (bind_result.empty()) {
-			success = true;
+		bind_error = next_binder.Bind(expr, depth);
+		if (!bind_error.HasError()) {
 			break;
 		}
 		depth++;
 		active_binders.pop_back();
 	}
 	active_binders = binders;
-	return success;
+	return BindResult(bind_error);
 }
 
-void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, string &error) {
+void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, ErrorData &error) {
 	if (expr) {
-		string bind_error = Bind(expr, depth);
-		if (error.empty()) {
-			error = bind_error;
+		ErrorData bind_error = Bind(expr, depth);
+		if (!error.HasError()) {
+			error = std::move(bind_error);
 		}
 	}
 }
@@ -166,6 +166,8 @@ bool ExpressionBinder::ContainsType(const LogicalType &type, LogicalTypeId targe
 	case LogicalTypeId::LIST:
 	case LogicalTypeId::MAP:
 		return ContainsType(ListType::GetChildType(type), target);
+	case LogicalTypeId::ARRAY:
+		return ContainsType(ArrayType::GetChildType(type), target);
 	default:
 		return false;
 	}
@@ -195,6 +197,9 @@ LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeI
 		return LogicalType::LIST(ExchangeType(ListType::GetChildType(type), target, new_type));
 	case LogicalTypeId::MAP:
 		return LogicalType::MAP(ExchangeType(ListType::GetChildType(type), target, new_type));
+	case LogicalTypeId::ARRAY:
+		return LogicalType::ARRAY(ExchangeType(ArrayType::GetChildType(type), target, new_type),
+		                          ArrayType::GetSize(type));
 	default:
 		return type;
 	}
@@ -212,11 +217,14 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
                                               bool root_expression) {
 	// bind the main expression
 	auto error_msg = Bind(expr, 0, root_expression);
-	if (!error_msg.empty()) {
-		// failed to bind: try to bind correlated columns in the expression (if any)
-		bool success = BindCorrelatedColumns(expr);
-		if (!success) {
-			throw BinderException(error_msg);
+	if (error_msg.HasError()) {
+		// Try binding the correlated column. If binding the correlated column
+		// has error messages, those should be propagated up. So for the test case
+		// having subquery failed to bind:14 the real error message should be something like
+		// aggregate with constant input must be bound to a root node.
+		auto result = BindCorrelatedColumns(expr, error_msg);
+		if (result.HasError()) {
+			result.error.Throw();
 		}
 		auto &bound_expr = expr->Cast<BoundExpression>();
 		ExtractCorrelatedExpressions(binder, *bound_expr.expr);
@@ -245,27 +253,45 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 	return result;
 }
 
-string ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
+ErrorData ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
 	// bind the node, but only if it has not been bound yet
+	auto query_location = expr->query_location;
 	auto &expression = *expr;
 	auto alias = expression.alias;
 	if (expression.GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION) {
 		// already bound, don't bind it again
-		return string();
+		return ErrorData();
 	}
 	// bind the expression
 	BindResult result = BindExpression(expr, depth, root_expression);
 	if (result.HasError()) {
-		return result.error;
+		return std::move(result.error);
 	}
 	// successfully bound: replace the node with a BoundExpression
+	result.expression->query_location = query_location;
 	expr = make_uniq<BoundExpression>(std::move(result.expression));
 	auto &be = expr->Cast<BoundExpression>();
 	be.alias = alias;
 	if (!alias.empty()) {
 		be.expr->alias = alias;
 	}
-	return string();
+	return ErrorData();
+}
+
+bool ExpressionBinder::IsUnnestFunction(const string &function_name) {
+	return function_name == "unnest" || function_name == "unlist";
+}
+
+bool ExpressionBinder::IsLambdaFunction(const FunctionExpression &function) {
+	// check for lambda parameters, ignore ->> operator (JSON extension)
+	if (function.function_name != "->>") {
+		for (auto &child : function.children) {
+			if (child->expression_class == ExpressionClass::LAMBDA) {
+				return true;
+			}
+		}
+	}
+	return false;
 }
 
 } // namespace duckdb

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

@@ -175,7 +175,7 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 		break;
 	}
 	case TableReferenceType::TABLE_FUNCTION:
-	case TableReferenceType::EMPTY:
+	case TableReferenceType::EMPTY_FROM:
 	case TableReferenceType::BASE_TABLE:
 	case TableReferenceType::CTE:
 		break;
@@ -202,6 +202,7 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	case QueryNodeType::CTE_NODE: {
 		auto &cte_node = node.Cast<BoundCTENode>();
 		EnumerateQueryNodeChildren(*cte_node.child, callback);
+		EnumerateQueryNodeChildren(*cte_node.query, callback);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -15,6 +15,7 @@ FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
 	case PhysicalType::UINT16:
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
+	case PhysicalType::UINT128:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32: