duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -108,7 +108,8 @@ static unique_ptr<SelectNode> PivotFilteredAggregate(PivotRef &ref, vector<uniqu
 		for (auto &pivot_column : ref.pivots) {
 			for (auto &pivot_expr : pivot_column.pivot_expressions) {
 				auto column_ref = make_uniq<CastExpression>(LogicalType::VARCHAR, pivot_expr->Copy());
-				auto constant_value = make_uniq<ConstantExpression>(pivot_value.values[pivot_value_idx++]);
+				auto constant_value = make_uniq<ConstantExpression>(
+				    pivot_value.values[pivot_value_idx++].DefaultCastAs(LogicalType::VARCHAR));
 				auto comp_expr = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
 				                                                 std::move(column_ref), std::move(constant_value));
 				if (filter) {
@@ -355,13 +356,13 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	// parse the aggregate, and extract the referenced columns from the aggregate
 	for (auto &aggr : ref.aggregates) {
 		if (aggr->type != ExpressionType::FUNCTION) {
-			throw BinderException(FormatError(*aggr, "Pivot expression must be an aggregate"));
+			throw BinderException(*aggr, "Pivot expression must be an aggregate");
 		}
 		if (aggr->HasSubquery()) {
-			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain subqueries"));
+			throw BinderException(*aggr, "Pivot expression cannot contain subqueries");
 		}
 		if (aggr->IsWindow()) {
-			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain window functions"));
+			throw BinderException(*aggr, "Pivot expression cannot contain window functions");
 		}
 		// bind the function as an aggregate to ensure it is an aggregate and not a scalar function
 		auto &aggr_function = aggr->Cast<FunctionExpression>();
@@ -376,9 +377,8 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		if (!pivot.pivot_enum.empty()) {
 			auto type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
 			if (type.id() != LogicalTypeId::ENUM) {
-				throw BinderException(
-				    FormatError(ref, StringUtil::Format("Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
-				                                        pivot.pivot_enum, type.ToString())));
+				throw BinderException(ref, "Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
+				                      pivot.pivot_enum, type.ToString());
 			}
 			auto enum_size = EnumType::GetSize(type);
 			for (idx_t i = 0; i < enum_size; i++) {
@@ -404,12 +404,11 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 				val = Value::LIST(LogicalType::VARCHAR, entry.values);
 			}
 			if (pivots.find(val) != pivots.end()) {
-				throw BinderException(FormatError(
-				    ref, StringUtil::Format("The value \"%s\" was specified multiple times in the IN clause",
-				                            val.ToString())));
+				throw BinderException(ref, "The value \"%s\" was specified multiple times in the IN clause",
+				                      val.ToString());
 			}
 			if (entry.values.size() != pivot.pivot_expressions.size()) {
-				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				throw BinderException(ref, "PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
 				                      pivot.pivot_expressions.size(), entry.values.size());
 			}
 			pivots.insert(val);
@@ -418,7 +417,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	auto &client_config = ClientConfig::GetConfig(context);
 	auto pivot_limit = client_config.pivot_limit;
 	if (total_pivots >= pivot_limit) {
-		throw BinderException("Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.",
+		throw BinderException(ref, "Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.",
 		                      client_config.pivot_limit);
 	}
 
@@ -527,8 +526,8 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	}
 	if (!handled_columns.empty()) {
 		for (auto &entry : handled_columns) {
-			throw BinderException("Column \"%s\" referenced in UNPIVOT but no matching entry was found in the table",
-			                      entry);
+			throw BinderException(
+			    ref, "Column \"%s\" referenced in UNPIVOT but no matching entry was found in the table", entry);
 		}
 	}
 	vector<Value> unpivot_names;
@@ -550,6 +549,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	for (idx_t v_idx = 1; v_idx < unpivot.entries.size(); v_idx++) {
 		if (unpivot.entries[v_idx].values.size() != unpivot.entries[0].values.size()) {
 			throw BinderException(
+			    ref,
 			    "UNPIVOT value count mismatch - entry has %llu values, but expected all entries to have %llu values",
 			    unpivot.entries[v_idx].values.size(), unpivot.entries[0].values.size());
 		}
@@ -559,7 +559,8 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		vector<unique_ptr<ParsedExpression>> expressions;
 		expressions.reserve(unpivot.entries.size());
 		for (auto &entry : unpivot.entries) {
-			expressions.push_back(make_uniq<ColumnRefExpression>(entry.values[v_idx].ToString()));
+			auto colref = make_uniq<ColumnRefExpression>(entry.values[v_idx].ToString());
+			expressions.push_back(std::move(colref));
 		}
 		unpivot_expressions.push_back(std::move(expressions));
 	}
@@ -575,8 +576,8 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 
 	// construct the UNNEST expression for the set of unpivoted columns
 	if (ref.unpivot_names.size() != unpivot_expressions.size()) {
-		throw BinderException("UNPIVOT name count mismatch - got %d names but %d expressions", ref.unpivot_names.size(),
-		                      unpivot_expressions.size());
+		throw BinderException(ref, "UNPIVOT name count mismatch - got %d names but %d expressions",
+		                      ref.unpivot_names.size(), unpivot_expressions.size());
 	}
 	for (idx_t i = 0; i < unpivot_expressions.size(); i++) {
 		auto list_expr = make_uniq<FunctionExpression>("list_value", std::move(unpivot_expressions[i]));

package/src/duckdb/src/planner/binder/tableref/bind_showref.cpp

@@ -0,0 +1,85 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/tableref/showref.hpp"
+#include "duckdb/planner/tableref/bound_table_function.hpp"
+#include "duckdb/planner/operator/logical_column_data_get.hpp"
+#include "duckdb/function/pragma/pragma_functions.hpp"
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/tableref/subqueryref.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundTableRef> Binder::BindShowQuery(ShowRef &ref) {
+	// bind the child plan of the DESCRIBE statement
+	auto child_binder = Binder::CreateBinder(context, this);
+	auto plan = child_binder->Bind(*ref.query);
+
+	// construct a column data collection with the result
+	vector<string> return_names = {"column_name", "column_type", "null", "key", "default", "extra"};
+	vector<LogicalType> return_types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
+	                                    LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
+	DataChunk output;
+	output.Initialize(Allocator::Get(context), return_types);
+
+	auto collection = make_uniq<ColumnDataCollection>(context, return_types);
+	ColumnDataAppendState append_state;
+	collection->InitializeAppend(append_state);
+	for (idx_t column_idx = 0; column_idx < plan.types.size(); column_idx++) {
+		auto type = plan.types[column_idx];
+		auto &name = plan.names[column_idx];
+
+		// "name", TypeId::VARCHAR
+		output.SetValue(0, output.size(), Value(name));
+		// "type", TypeId::VARCHAR
+		output.SetValue(1, output.size(), Value(type.ToString()));
+		// "null", TypeId::VARCHAR
+		output.SetValue(2, output.size(), Value("YES"));
+		// "pk", TypeId::BOOL
+		output.SetValue(3, output.size(), Value());
+		// "dflt_value", TypeId::VARCHAR
+		output.SetValue(4, output.size(), Value());
+		// "extra", TypeId::VARCHAR
+		output.SetValue(5, output.size(), Value());
+
+		output.SetCardinality(output.size() + 1);
+		if (output.size() == STANDARD_VECTOR_SIZE) {
+			collection->Append(append_state, output);
+			output.Reset();
+		}
+	}
+	collection->Append(append_state, output);
+
+	auto show = make_uniq<LogicalColumnDataGet>(GenerateTableIndex(), return_types, std::move(collection));
+	bind_context.AddGenericBinding(show->table_index, "__show_select", return_names, return_types);
+	return make_uniq<BoundTableFunction>(std::move(show));
+}
+
+unique_ptr<BoundTableRef> Binder::BindShowTable(ShowRef &ref) {
+	auto lname = StringUtil::Lower(ref.table_name);
+
+	string sql;
+	if (lname == "\"databases\"") {
+		sql = PragmaShowDatabases();
+	} else if (lname == "\"tables\"") {
+		sql = PragmaShowTables();
+	} else if (lname == "__show_tables_expanded") {
+		sql = PragmaShowTablesExpanded();
+	} else {
+		sql = PragmaShow(ref.table_name);
+	}
+	auto select = CreateViewInfo::ParseSelect(sql);
+	auto subquery = make_uniq<SubqueryRef>(std::move(select));
+	return Bind(*subquery);
+}
+
+unique_ptr<BoundTableRef> Binder::Bind(ShowRef &ref) {
+	if (ref.show_type == ShowType::SUMMARY) {
+		return BindSummarize(ref);
+	}
+	if (ref.query) {
+		return BindShowQuery(ref);
+	} else {
+		return BindShowTable(ref);
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -30,7 +30,7 @@ static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function)
 }
 
 bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
+                                         unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
 	auto binder = Binder::CreateBinder(this->context, this, true);
 	unique_ptr<QueryNode> subquery_node;
 	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
@@ -55,7 +55,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
                                          vector<unique_ptr<ParsedExpression>> &expressions,
                                          vector<LogicalType> &arguments, vector<Value> &parameters,
                                          named_parameter_map_t &named_parameters,
-                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
+                                         unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
 	if (IsTableInTableOutFunction(table_function)) {
 		// special case binding for table-in table-out function
 		arguments.emplace_back(LogicalTypeId::TABLE);
@@ -88,7 +88,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			// this separate subquery binding path is only used by python_map
 			// FIXME: this should be unified with `BindTableInTableOutFunction` above
 			if (seen_subquery) {
-				error = "Table function can have at most one subquery parameter ";
+				error = ErrorData("Table function can have at most one subquery parameter");
 				return false;
 			}
 			auto binder = Binder::CreateBinder(this->context, this, true);
@@ -116,10 +116,10 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 		if (parameter_name.empty()) {
 			// unnamed parameter
 			if (!named_parameters.empty()) {
-				error = "Unnamed parameters cannot come after named parameters";
+				error = ErrorData("Unnamed parameters cannot come after named parameters");
 				return false;
 			}
-			arguments.emplace_back(sql_type);
+			arguments.emplace_back(constant.IsNull() ? LogicalType::SQLNULL : sql_type);
 			parameters.emplace_back(std::move(constant));
 		} else {
 			named_parameters[parameter_name] = std::move(constant);
@@ -155,14 +155,6 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			auto &arrow_bind = bind_data->Cast<PyTableFunctionData>();
 			arrow_bind.external_dependency = std::move(external_dependency);
 		}
-		if (table_function.name == "read_csv" || table_function.name == "read_csv_auto") {
-			auto &csv_bind = bind_data->Cast<ReadCSVData>();
-			if (csv_bind.single_threaded) {
-				table_function.extra_info = "(Single-Threaded)";
-			} else {
-				table_function.extra_info = "(Multi-Threaded)";
-			}
-		}
 	} else {
 		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
 		                            table_function.name);
@@ -212,7 +204,7 @@ unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, v
 }
 
 unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
-	QueryErrorContext error_context(root_statement, ref.query_location);
+	QueryErrorContext error_context(ref.query_location);
 
 	D_ASSERT(ref.function->type == ExpressionType::FUNCTION);
 	auto &fexpr = ref.function->Cast<FunctionExpression>();
@@ -250,17 +242,19 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	vector<Value> parameters;
 	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
-	string error;
+	ErrorData error;
 	if (!BindTableFunctionParameters(function, fexpr.children, arguments, parameters, named_parameters, subquery,
 	                                 error)) {
-		throw BinderException(FormatError(ref, error));
+		error.AddQueryLocation(ref);
+		error.Throw();
 	}
 
 	// select the function based on the input parameters
 	FunctionBinder function_binder(context);
 	idx_t best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
 	if (best_function_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(FormatError(ref, error));
+		error.AddQueryLocation(ref);
+		error.Throw();
 	}
 	auto table_function = function.functions.GetFunctionByOffset(best_function_idx);
 

package/src/duckdb/src/planner/binder/tableref/plan_cteref.cpp

@@ -5,15 +5,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
-	auto index = ref.bind_index;
-
-	vector<LogicalType> types;
-	types.reserve(ref.types.size());
-	for (auto &type : ref.types) {
-		types.push_back(type);
-	}
-
-	return make_uniq<LogicalCTERef>(index, ref.cte_index, types, ref.bound_columns, ref.materialized_cte);
+	return make_uniq<LogicalCTERef>(ref.bind_index, ref.cte_index, ref.types, ref.bound_columns, ref.materialized_cte);
 }
 
 } // namespace duckdb

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

@@ -50,7 +50,8 @@ shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Bin
 }
 
 Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
-    : context(context), parent(std::move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
+    : context(context), bind_context(*this), parent(std::move(parent_p)), bound_tables(0),
+      inherit_ctes(inherit_ctes_p) {
 	if (parent) {
 
 		// We have to inherit macro and lambda parameter bindings and from the parent binder, if there is a parent.
@@ -95,8 +96,6 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind(statement.Cast<ExplainStatement>());
 	case StatementType::VACUUM_STATEMENT:
 		return Bind(statement.Cast<VacuumStatement>());
-	case StatementType::SHOW_STATEMENT:
-		return Bind(statement.Cast<ShowStatement>());
 	case StatementType::CALL_STATEMENT:
 		return Bind(statement.Cast<CallStatement>());
 	case StatementType::EXPORT_STATEMENT:
@@ -117,6 +116,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind(statement.Cast<AttachStatement>());
 	case StatementType::DETACH_STATEMENT:
 		return Bind(statement.Cast<DetachStatement>());
+	case StatementType::COPY_DATABASE_STATEMENT:
+		return Bind(statement.Cast<CopyDatabaseStatement>());
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));
@@ -191,7 +192,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::SUBQUERY:
 		result = Bind(ref.Cast<SubqueryRef>());
 		break;
-	case TableReferenceType::EMPTY:
+	case TableReferenceType::EMPTY_FROM:
 		result = Bind(ref.Cast<EmptyTableRef>());
 		break;
 	case TableReferenceType::TABLE_FUNCTION:
@@ -203,6 +204,9 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::PIVOT:
 		result = Bind(ref.Cast<PivotRef>());
 		break;
+	case TableReferenceType::SHOW_REF:
+		result = Bind(ref.Cast<ShowRef>());
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
 	default:
@@ -227,7 +231,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	case TableReferenceType::TABLE_FUNCTION:
 		root = CreatePlan(ref.Cast<BoundTableFunction>());
 		break;
-	case TableReferenceType::EMPTY:
+	case TableReferenceType::EMPTY_FROM:
 		root = CreatePlan(ref.Cast<BoundEmptyTableRef>());
 		break;
 	case TableReferenceType::EXPRESSION_LIST:
@@ -349,25 +353,25 @@ void Binder::AddCorrelatedColumn(const CorrelatedColumnInfo &info) {
 	}
 }
 
-bool Binder::HasMatchingBinding(const string &table_name, const string &column_name, string &error_message) {
+bool Binder::HasMatchingBinding(const string &table_name, const string &column_name, ErrorData &error) {
 	string empty_schema;
-	return HasMatchingBinding(empty_schema, table_name, column_name, error_message);
+	return HasMatchingBinding(empty_schema, table_name, column_name, error);
 }
 
 bool Binder::HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
-                                string &error_message) {
+                                ErrorData &error) {
 	string empty_catalog;
-	return HasMatchingBinding(empty_catalog, schema_name, table_name, column_name, error_message);
+	return HasMatchingBinding(empty_catalog, schema_name, table_name, column_name, error);
 }
 
 bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema_name, const string &table_name,
-                                const string &column_name, string &error_message) {
+                                const string &column_name, ErrorData &error) {
 	optional_ptr<Binding> binding;
 	D_ASSERT(!lambda_bindings);
 	if (macro_binding && table_name == macro_binding->alias) {
 		binding = optional_ptr<Binding>(macro_binding.get());
 	} else {
-		binding = bind_context.GetBinding(table_name, error_message);
+		binding = bind_context.GetBinding(table_name, error);
 	}
 
 	if (!binding) {
@@ -391,7 +395,7 @@ bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema
 	bool binding_found;
 	binding_found = binding->HasMatchingBinding(column_name);
 	if (!binding_found) {
-		error_message = binding->ColumnNotFoundError(column_name);
+		error = binding->ColumnNotFoundError(column_name);
 	}
 	return binding_found;
 }
@@ -411,6 +415,18 @@ void Binder::SetCanContainNulls(bool can_contain_nulls_p) {
 	can_contain_nulls = can_contain_nulls_p;
 }
 
+void Binder::SetAlwaysRequireRebind() {
+	reference<Binder> current_binder = *this;
+	while (true) {
+		auto &current = current_binder.get();
+		current.properties.always_require_rebind = true;
+		if (!current.parent) {
+			break;
+		}
+		current_binder = *current.parent;
+	}
+}
+
 void Binder::AddTableName(string table_name) {
 	auto root_binder = GetRootBinder();
 	root_binder->table_names.insert(std::move(table_name));
@@ -421,19 +437,6 @@ const unordered_set<string> &Binder::GetTableNames() {
 	return root_binder->table_names;
 }
 
-string Binder::FormatError(ParsedExpression &expr_context, const string &message) {
-	return FormatError(expr_context.query_location, message);
-}
-
-string Binder::FormatError(TableRef &ref_context, const string &message) {
-	return FormatError(ref_context.query_location, message);
-}
-
-string Binder::FormatErrorRecursive(idx_t query_location, const string &message, vector<ExceptionFormatValue> &values) {
-	QueryErrorContext context(root_statement, query_location);
-	return context.FormatErrorRecursive(message, values);
-}
-
 // FIXME: this is extremely naive
 void VerifyNotExcluded(ParsedExpression &expr) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
@@ -486,7 +489,9 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		result.types.push_back(result_type);
 		projection_expressions.push_back(std::move(expr));
 	}
-
+	if (new_returning_list.empty()) {
+		throw BinderException("RETURNING list is empty!");
+	}
 	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));
 	projection->AddChild(std::move(child_operator));
 	D_ASSERT(result.types.size() == result.names.size());

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/planner/bound_result_modifier.hpp"
+#include "duckdb/parser/expression_map.hpp"
 
 namespace duckdb {
 
@@ -92,6 +93,29 @@ bool BoundOrderModifier::Equals(const unique_ptr<BoundOrderModifier> &left,
 	return BoundOrderModifier::Equals(*left, *right);
 }
 
+bool BoundOrderModifier::Simplify(const vector<unique_ptr<Expression>> &groups) {
+	// for each ORDER BY - check if it is actually necessary
+	// expressions that are in the groups do not need to be ORDERED BY
+	// `ORDER BY` on a group has no effect, because for each aggregate, the group is unique
+	// similarly, we only need to ORDER BY each aggregate once
+	expression_set_t seen_expressions;
+	for (auto &target : groups) {
+		seen_expressions.insert(*target);
+	}
+	vector<BoundOrderByNode> new_order_nodes;
+	for (auto &order_node : orders) {
+		if (seen_expressions.find(*order_node.expression) != seen_expressions.end()) {
+			// we do not need to order by this node
+			continue;
+		}
+		seen_expressions.insert(*order_node.expression);
+		new_order_nodes.push_back(std::move(order_node));
+	}
+	orders.swap(new_order_nodes);
+
+	return orders.empty();
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 

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

@@ -19,7 +19,7 @@ BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, v
 
 string BoundAggregateExpression::ToString() const {
 	return FunctionExpression::ToString<BoundAggregateExpression, Expression, BoundOrderModifier>(
-	    *this, string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
+	    *this, string(), string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
 }
 
 hash_t BoundAggregateExpression::Hash() const {

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

@@ -1,6 +1,7 @@
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_default_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/function/cast_rules.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/config.hpp"
@@ -28,7 +29,7 @@ BoundCastExpression::BoundCastExpression(ClientContext &context, unique_ptr<Expr
 
 unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
                                                  BoundCastInfo bound_cast, bool try_cast) {
-	if (expr->return_type == target_type) {
+	if (ExpressionBinder::GetExpressionReturnType(*expr) == target_type) {
 		return expr;
 	}
 	auto &expr_type = expr->return_type;
@@ -102,6 +103,14 @@ unique_ptr<Expression> BoundCastExpression::AddCastToType(ClientContext &context
 	return AddCastToTypeInternal(std::move(expr), target_type, cast_functions, get_input, try_cast);
 }
 
+unique_ptr<Expression> BoundCastExpression::AddArrayCastToList(ClientContext &context, unique_ptr<Expression> expr) {
+	if (expr->return_type.id() != LogicalTypeId::ARRAY) {
+		return expr;
+	}
+	auto &child_type = ArrayType::GetChildType(expr->return_type);
+	return BoundCastExpression::AddCastToType(context, std::move(expr), LogicalType::LIST(child_type));
+}
+
 bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type) {
 	D_ASSERT(source_type.IsValid() && target_type.IsValid());
 	if (source_type.id() == LogicalTypeId::BOOLEAN || target_type.id() == LogicalTypeId::BOOLEAN) {

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

@@ -5,6 +5,7 @@
 #include "duckdb/function/function_serialization.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/core_functions/lambda_functions.hpp"
 
 namespace duckdb {
 
@@ -17,17 +18,32 @@ BoundFunctionExpression::BoundFunctionExpression(LogicalType return_type, Scalar
 	D_ASSERT(!function.name.empty());
 }
 
-bool BoundFunctionExpression::HasSideEffects() const {
-	return function.side_effects == FunctionSideEffects::HAS_SIDE_EFFECTS ? true : Expression::HasSideEffects();
+bool BoundFunctionExpression::IsVolatile() const {
+	return function.stability == FunctionStability::VOLATILE ? true : Expression::IsVolatile();
+}
+
+bool BoundFunctionExpression::IsConsistent() const {
+	return function.stability != FunctionStability::CONSISTENT ? false : Expression::IsConsistent();
 }
 
 bool BoundFunctionExpression::IsFoldable() const {
 	// functions with side effects cannot be folded: they have to be executed once for every row
-	return function.side_effects == FunctionSideEffects::HAS_SIDE_EFFECTS ? false : Expression::IsFoldable();
+	if (function.bind_lambda) {
+		// This is a lambda function
+		D_ASSERT(bind_info);
+		auto &lambda_bind_data = bind_info->Cast<ListLambdaBindData>();
+		if (lambda_bind_data.lambda_expr) {
+			auto &expr = *lambda_bind_data.lambda_expr;
+			if (expr.IsVolatile()) {
+				return false;
+			}
+		}
+	}
+	return function.stability == FunctionStability::VOLATILE ? false : Expression::IsFoldable();
 }
 
 string BoundFunctionExpression::ToString() const {
-	return FunctionExpression::ToString<BoundFunctionExpression, Expression>(*this, string(), function.name,
+	return FunctionExpression::ToString<BoundFunctionExpression, Expression>(*this, string(), string(), function.name,
 	                                                                         is_operator);
 }
 bool BoundFunctionExpression::PropagatesNullValues() const {

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

@@ -6,24 +6,24 @@
 namespace duckdb {
 
 BoundLambdaRefExpression::BoundLambdaRefExpression(string alias_p, LogicalType type, ColumnBinding binding,
-                                                   idx_t lambda_index, idx_t depth)
+                                                   idx_t lambda_idx, idx_t depth)
     : Expression(ExpressionType::BOUND_LAMBDA_REF, ExpressionClass::BOUND_LAMBDA_REF, std::move(type)),
-      binding(binding), lambda_index(lambda_index), depth(depth) {
+      binding(binding), lambda_idx(lambda_idx), depth(depth) {
 	this->alias = std::move(alias_p);
 }
 
-BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index,
+BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_idx,
                                                    idx_t depth)
-    : BoundLambdaRefExpression(string(), std::move(type), binding, lambda_index, depth) {
+    : BoundLambdaRefExpression(string(), std::move(type), binding, lambda_idx, depth) {
 }
 
 unique_ptr<Expression> BoundLambdaRefExpression::Copy() {
-	return make_uniq<BoundLambdaRefExpression>(alias, return_type, binding, lambda_index, depth);
+	return make_uniq<BoundLambdaRefExpression>(alias, return_type, binding, lambda_idx, depth);
 }
 
 hash_t BoundLambdaRefExpression::Hash() const {
 	auto result = Expression::Hash();
-	result = CombineHash(result, duckdb::Hash<uint64_t>(lambda_index));
+	result = CombineHash(result, duckdb::Hash<uint64_t>(lambda_idx));
 	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
 	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
@@ -34,15 +34,14 @@ bool BoundLambdaRefExpression::Equals(const BaseExpression &other_p) const {
 		return false;
 	}
 	auto &other = other_p.Cast<BoundLambdaRefExpression>();
-	return other.binding == binding && other.lambda_index == lambda_index && other.depth == depth;
+	return other.binding == binding && other.lambda_idx == lambda_idx && other.depth == depth;
 }
 
 string BoundLambdaRefExpression::ToString() const {
 	if (!alias.empty()) {
 		return alias;
 	}
-	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "." +
-	       to_string(lambda_index) + "]";
+	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "." + to_string(lambda_idx) +
+	       "]";
 }
-
 } // namespace duckdb