duckdb 1.1.3 → 1.1.4-dev9.0

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

@@ -15,7 +15,7 @@
 
 namespace duckdb {
 
-static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &context, const string &alias,
+static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &context, const BindingAlias &alias,
                                                const string &column_name) {
 	auto expr = make_uniq_base<ParsedExpression, ColumnRefExpression>(column_name, alias);
 	ExpressionBinder expr_binder(binder, context);
@@ -24,7 +24,7 @@ static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &co
 }
 
 static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
-                                                 const string &left_alias, const string &right_alias,
+                                                 const BindingAlias &left_alias, const BindingAlias &right_alias,
                                                  const string &column_name, ExpressionType type) {
 	ExpressionBinder expr_binder(left_binder, context);
 	auto left = BindColumn(left_binder, context, left_alias, column_name);
@@ -32,7 +32,7 @@ static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder
 	return make_uniq<ComparisonExpression>(type, std::move(left), std::move(right));
 }
 
-bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
+bool Binder::TryFindBinding(const string &using_column, const string &join_side, BindingAlias &result) {
 	// for each using column, get the matching binding
 	auto bindings = bind_context.GetMatchingBindings(using_column);
 	if (bindings.empty()) {
@@ -40,46 +40,48 @@ bool Binder::TryFindBinding(const string &using_column, const string &join_side,
 	}
 	// find the join binding
 	for (auto &binding : bindings) {
-		if (!result.empty()) {
+		if (result.IsSet()) {
 			string error = "Column name \"";
 			error += using_column;
 			error += "\" is ambiguous: it exists more than once on ";
 			error += join_side;
 			error += " side of join.\nCandidates:";
-			for (auto &binding : bindings) {
+			for (auto &binding_ref : bindings) {
+				auto &other_binding = binding_ref.get();
 				error += "\n\t";
-				error += binding;
+				error += other_binding.GetAlias();
 				error += ".";
-				error += bind_context.GetActualColumnName(binding, using_column);
+				error += bind_context.GetActualColumnName(other_binding, using_column);
 			}
 			throw BinderException(error);
 		} else {
-			result = binding;
+			result = binding.get().alias;
 		}
 	}
 	return true;
 }
 
-string Binder::FindBinding(const string &using_column, const string &join_side) {
-	string result;
+BindingAlias Binder::FindBinding(const string &using_column, const string &join_side) {
+	BindingAlias result;
 	if (!TryFindBinding(using_column, join_side, result)) {
 		throw BinderException("Column \"%s\" does not exist on %s side of join!", using_column, join_side);
 	}
 	return result;
 }
 
-static void AddUsingBindings(UsingColumnSet &set, optional_ptr<UsingColumnSet> input_set, const string &input_binding) {
+static void AddUsingBindings(UsingColumnSet &set, optional_ptr<UsingColumnSet> input_set,
+                             const BindingAlias &input_binding) {
 	if (input_set) {
 		for (auto &entry : input_set->bindings) {
-			set.bindings.insert(entry);
+			set.bindings.push_back(entry);
 		}
 	} else {
-		set.bindings.insert(input_binding);
+		set.bindings.push_back(input_binding);
 	}
 }
 
-static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const string &left_binding,
-                              const string &right_binding) {
+static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const BindingAlias &left_binding,
+                              const BindingAlias &right_binding) {
 	switch (join_type) {
 	case JoinType::LEFT:
 	case JoinType::INNER:
@@ -97,9 +99,9 @@ static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const str
 	}
 }
 
-string Binder::RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
-                                    const string &using_column, const string &join_side) {
-	string binding;
+BindingAlias Binder::RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
+                                          const string &using_column, const string &join_side) {
+	BindingAlias binding;
 	if (!current_set) {
 		binding = current_binder.FindBinding(using_column, join_side);
 	} else {
@@ -186,7 +188,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		case_insensitive_set_t lhs_columns;
 		auto &lhs_binding_list = left_binder.bind_context.GetBindingsList();
 		for (auto &binding : lhs_binding_list) {
-			for (auto &column_name : binding.get().names) {
+			for (auto &column_name : binding->names) {
 				lhs_columns.insert(column_name);
 			}
 		}
@@ -194,7 +196,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		for (auto &column_name : lhs_columns) {
 			auto right_using_binding = right_binder.bind_context.GetUsingBinding(column_name);
 
-			string right_binding;
+			BindingAlias right_binding;
 			// loop over the set of lhs columns, and figure out if there is a table in the rhs with the same name
 			if (!right_using_binding) {
 				if (!right_binder.TryFindBinding(column_name, "right", right_binding)) {
@@ -212,21 +214,21 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			string left_candidates, right_candidates;
 			auto &rhs_binding_list = right_binder.bind_context.GetBindingsList();
 			for (auto &binding_ref : lhs_binding_list) {
-				auto &binding = binding_ref.get();
+				auto &binding = *binding_ref;
 				for (auto &column_name : binding.names) {
 					if (!left_candidates.empty()) {
 						left_candidates += ", ";
 					}
-					left_candidates += binding.alias + "." + column_name;
+					left_candidates += binding.GetAlias() + "." + column_name;
 				}
 			}
 			for (auto &binding_ref : rhs_binding_list) {
-				auto &binding = binding_ref.get();
+				auto &binding = *binding_ref;
 				for (auto &column_name : binding.names) {
 					if (!right_candidates.empty()) {
 						right_candidates += ", ";
 					}
-					right_candidates += binding.alias + "." + column_name;
+					right_candidates += binding.GetAlias() + "." + column_name;
 				}
 			}
 			error_msg += "\n   Left candidates: " + left_candidates;
@@ -273,8 +275,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
 			auto &using_column = extra_using_columns[i];
-			string left_binding;
-			string right_binding;
+			BindingAlias left_binding;
+			BindingAlias right_binding;
 
 			auto set = make_uniq<UsingColumnSet>();
 			auto &left_using_binding = left_using_bindings[i];
@@ -293,16 +295,14 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			AddUsingBindings(*set, left_using_binding, left_binding);
 			AddUsingBindings(*set, right_using_binding, right_binding);
 			SetPrimaryBinding(*set, ref.type, left_binding, right_binding);
-			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, *set, left_binding,
-			                                  using_column);
-			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, *set, right_binding,
-			                                  using_column);
+			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, *set, using_column);
+			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, *set, using_column);
 			AddUsingBindingSet(std::move(set));
 		}
 	}
 
-	auto right_bindings_list_copy = right_binder.bind_context.GetBindingsList();
-	auto left_bindings_list_copy = left_binder.bind_context.GetBindingsList();
+	auto right_bindings = right_binder.bind_context.GetBindingAliases();
+	auto left_bindings = left_binder.bind_context.GetBindingAliases();
 
 	bind_context.AddContext(std::move(left_binder.bind_context));
 	bind_context.AddContext(std::move(right_binder.bind_context));
@@ -338,7 +338,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	}
 
 	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI || result->type == JoinType::MARK) {
-		bind_context.RemoveContext(right_bindings_list_copy);
+		bind_context.RemoveContext(right_bindings);
 		if (result->type == JoinType::MARK) {
 			auto mark_join_idx = GenerateTableIndex();
 			string mark_join_alias = "__internal_mark_join_ref" + to_string(mark_join_idx);
@@ -348,7 +348,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		}
 	}
 	if (result->type == JoinType::RIGHT_SEMI || result->type == JoinType::RIGHT_ANTI) {
-		bind_context.RemoveContext(left_bindings_list_copy);
+		bind_context.RemoveContext(left_bindings);
 	}
 
 	return std::move(result);

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

@@ -58,7 +58,7 @@ static void ConstructPivots(PivotRef &ref, vector<PivotValueElement> &pivot_valu
 }
 
 static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
 		auto &child_colref = expr.Cast<ColumnRefExpression>();
 		if (child_colref.IsQualified()) {
 			throw BinderException("PIVOT expression cannot contain qualified columns");
@@ -69,6 +69,27 @@ static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set
 	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
 }
 
+void ExtractPivotAggregateExpression(ClientContext &context, ParsedExpression &expr,
+                                     vector<reference<FunctionExpression>> &aggregates) {
+	if (expr.GetExpressionType() == ExpressionType::FUNCTION) {
+		auto &aggr_function = expr.Cast<FunctionExpression>();
+
+		// check if this is an aggregate to ensure it is an aggregate and not a scalar function
+		auto &entry = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, aggr_function.catalog,
+		                                aggr_function.schema, aggr_function.function_name);
+		if (entry.type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
+			// aggregate
+			aggregates.push_back(aggr_function);
+			return;
+		}
+	}
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
+		throw BinderException(expr, "Columns can only be referenced within the aggregate of a PIVOT expression");
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](ParsedExpression &child) { ExtractPivotAggregateExpression(context, child, aggregates); });
+}
+
 static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns,
                                                        const case_insensitive_set_t &handled_columns) {
 	auto subquery = make_uniq<SelectNode>();
@@ -76,10 +97,11 @@ static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<uni
 	if (ref.groups.empty()) {
 		// if rows are not specified any columns that are not pivoted/aggregated on are added to the GROUP BY clause
 		for (auto &entry : all_columns) {
-			if (entry->type != ExpressionType::COLUMN_REF) {
+			auto column_entry = Binder::GetResolvedColumnExpression(*entry);
+			if (!column_entry) {
 				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
 			}
-			auto &columnref = entry->Cast<ColumnRefExpression>();
+			auto &columnref = column_entry->Cast<ColumnRefExpression>();
 			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
 				// not handled - add to grouping set
 				subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
@@ -98,7 +120,8 @@ static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<uni
 	return subquery;
 }
 
-static unique_ptr<SelectNode> PivotFilteredAggregate(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns,
+static unique_ptr<SelectNode> PivotFilteredAggregate(ClientContext &context, PivotRef &ref,
+                                                     vector<unique_ptr<ParsedExpression>> all_columns,
                                                      const case_insensitive_set_t &handled_columns,
                                                      vector<PivotValueElement> pivot_values) {
 	auto subquery = ConstructInitialGrouping(ref, std::move(all_columns), handled_columns);
@@ -124,15 +147,20 @@ static unique_ptr<SelectNode> PivotFilteredAggregate(PivotRef &ref, vector<uniqu
 		}
 		for (auto &aggregate : ref.aggregates) {
 			auto copied_aggr = aggregate->Copy();
-			auto &aggr = copied_aggr->Cast<FunctionExpression>();
+
+			vector<reference<FunctionExpression>> aggregates;
+			ExtractPivotAggregateExpression(context, *copied_aggr, aggregates);
+			D_ASSERT(aggregates.size() == 1);
+
+			auto &aggr = aggregates[0].get().Cast<FunctionExpression>();
 			aggr.filter = filter->Copy();
-			auto &aggr_name = aggregate->alias;
+			auto &aggr_name = aggregate->GetAlias();
 			auto name = pivot_value.name;
 			if (ref.aggregates.size() > 1 || !aggr_name.empty()) {
 				// if there are multiple aggregates specified we add the name of the aggregate as well
 				name += "_" + (aggr_name.empty() ? aggregate->GetName() : aggr_name);
 			}
-			aggr.alias = name;
+			copied_aggr->SetAlias(name);
 			subquery->select_list.push_back(std::move(copied_aggr));
 		}
 	}
@@ -154,19 +182,19 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 	idx_t group_count = 0;
 	for (auto &expr : subquery_stage1->select_list) {
 		bind_state.group_names.push_back(expr->GetName());
-		if (expr->alias.empty()) {
-			expr->alias = "__internal_pivot_group" + std::to_string(++group_count);
+		if (expr->GetAlias().empty()) {
+			expr->SetAlias("__internal_pivot_group" + std::to_string(++group_count));
 		}
-		bind_state.internal_group_names.push_back(expr->alias);
+		bind_state.internal_group_names.push_back(expr->GetAlias());
 	}
 	// group by all of the pivot values
 	idx_t pivot_count = 0;
 	for (auto &pivot_column : ref.pivots) {
 		for (auto &pivot_expr : pivot_column.pivot_expressions) {
-			if (pivot_expr->alias.empty()) {
-				pivot_expr->alias = "__internal_pivot_ref" + std::to_string(++pivot_count);
+			if (pivot_expr->GetAlias().empty()) {
+				pivot_expr->SetAlias("__internal_pivot_ref" + std::to_string(++pivot_count));
 			}
-			auto pivot_alias = pivot_expr->alias;
+			auto pivot_alias = pivot_expr->GetAlias();
 			subquery_stage1->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
 			    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage1->select_list.size() + 1))));
 			subquery_stage1->select_list.push_back(std::move(pivot_expr));
@@ -177,9 +205,9 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 	// finally add the aggregates
 	for (auto &aggregate : ref.aggregates) {
 		auto aggregate_alias = "__internal_pivot_aggregate" + std::to_string(++aggregate_count);
-		bind_state.aggregate_names.push_back(aggregate->alias);
+		bind_state.aggregate_names.push_back(aggregate->GetAlias());
 		bind_state.internal_aggregate_names.push_back(aggregate_alias);
-		aggregate->alias = std::move(aggregate_alias);
+		aggregate->SetAlias(std::move(aggregate_alias));
 		subquery_stage1->select_list.push_back(std::move(aggregate));
 	}
 	return subquery_stage1;
@@ -207,7 +235,7 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 		subquery_stage2->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
 		    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage2->select_list.size() + 1))));
 		auto group_reference = make_uniq<ColumnRefExpression>(bind_state.internal_group_names[gr]);
-		group_reference->alias = bind_state.internal_group_names[gr];
+		group_reference->SetAlias(bind_state.internal_group_names[gr]);
 		subquery_stage2->select_list.push_back(std::move(group_reference));
 	}
 
@@ -217,7 +245,7 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 		vector<unique_ptr<ParsedExpression>> list_children;
 		list_children.push_back(std::move(colref));
 		auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
-		aggregate->alias = bind_state.internal_aggregate_names[aggr];
+		aggregate->SetAlias(bind_state.internal_aggregate_names[aggr]);
 		subquery_stage2->select_list.push_back(std::move(aggregate));
 	}
 	// construct the pivot list
@@ -245,7 +273,7 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 	list_children.push_back(std::move(expr));
 	auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
 
-	aggregate->alias = pivot_name;
+	aggregate->SetAlias(pivot_name);
 	subquery_stage2->select_list.push_back(std::move(aggregate));
 
 	subquery_stage2->from_table = std::move(subquery_ref);
@@ -290,7 +318,7 @@ void ExtractPivotAggregates(BoundTableRef &node, vector<unique_ptr<Expression>>
 	}
 	auto &select2 = subq2.subquery->Cast<BoundSelectNode>();
 	for (auto &aggr : select2.aggregates) {
-		if (aggr->alias == "__collated_group") {
+		if (aggr->GetAlias() == "__collated_group") {
 			continue;
 		}
 		aggregates.push_back(aggr->Copy());
@@ -360,22 +388,27 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	// keep track of the columns by which we pivot/aggregate
 	// any columns which are not pivoted/aggregated on are added to the GROUP BY clause
 	case_insensitive_set_t handled_columns;
+
+	vector<reference<FunctionExpression>> pivot_aggregates;
 	// parse the aggregate, and extract the referenced columns from the aggregate
 	for (auto &aggr : ref.aggregates) {
-		if (aggr->type != ExpressionType::FUNCTION) {
-			throw BinderException(*aggr, "Pivot expression must be an aggregate");
-		}
 		if (aggr->HasSubquery()) {
 			throw BinderException(*aggr, "Pivot expression cannot contain subqueries");
 		}
 		if (aggr->IsWindow()) {
 			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>();
-		(void)Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, aggr_function.catalog, aggr_function.schema,
-		                                                       aggr_function.function_name);
-		ExtractPivotExpressions(*aggr, handled_columns);
+		idx_t aggregate_count = pivot_aggregates.size();
+		ExtractPivotAggregateExpression(context, *aggr, pivot_aggregates);
+		if (pivot_aggregates.size() != aggregate_count + 1) {
+			string error_str = pivot_aggregates.size() == aggregate_count
+			                       ? "but no aggregates were found"
+			                       : "but " + to_string(pivot_aggregates.size() - aggregate_count) + " were found";
+			throw BinderException(*aggr, "Pivot expression must contain exactly one aggregate, %s", error_str);
+		}
+	}
+	for (auto &aggr : pivot_aggregates) {
+		ExtractPivotExpressions(aggr.get(), handled_columns);
 	}
 
 	// first add all pivots to the set of handled columns, and check for duplicates
@@ -389,6 +422,9 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 				throw BinderException(ref, "Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
 				                      pivot.pivot_enum, type.ToString());
 			}
+			if (!type.IsComplete()) {
+				throw BinderException("ENUM type is incomplete");
+			}
 			auto enum_size = EnumType::GetSize(type);
 			for (idx_t i = 0; i < enum_size; i++) {
 				auto enum_value = EnumType::GetValue(Value::ENUM(i, type));
@@ -448,7 +484,8 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	// we switch dynamically based on the number of pivots to compute
 	if (pivot_values.size() <= client_config.pivot_filter_threshold) {
 		// use a set of filtered aggregates
-		pivot_node = PivotFilteredAggregate(ref, std::move(all_columns), handled_columns, std::move(pivot_values));
+		pivot_node =
+		    PivotFilteredAggregate(context, ref, std::move(all_columns), handled_columns, std::move(pivot_values));
 	} else {
 		// executing a pivot statement happens in three stages
 		// 1) execute the query "SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
@@ -503,8 +540,8 @@ void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry
 	for (auto &expr : star_columns) {
 		// create one pivot entry per result column
 		UnpivotEntry unpivot_entry;
-		if (!expr->alias.empty()) {
-			unpivot_entry.alias = std::move(expr->alias);
+		if (!expr->GetAlias().empty()) {
+			unpivot_entry.alias = expr->GetAlias();
 		}
 		unpivot_entry.expressions.push_back(std::move(expr));
 		unpivot_entries.push_back(std::move(unpivot_entry));
@@ -512,12 +549,12 @@ void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry
 }
 
 void Binder::ExtractUnpivotColumnName(ParsedExpression &expr, vector<string> &result) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
 		auto &colref = expr.Cast<ColumnRefExpression>();
 		result.push_back(colref.GetColumnName());
 		return;
 	}
-	if (expr.type == ExpressionType::SUBQUERY) {
+	if (expr.GetExpressionType() == ExpressionType::SUBQUERY) {
 		throw BinderException(expr, "UNPIVOT list cannot contain subqueries");
 	}
 	ParsedExpressionIterator::EnumerateChildren(
@@ -570,7 +607,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	}
 
 	for (auto &col_expr : all_columns) {
-		if (col_expr->type != ExpressionType::COLUMN_REF) {
+		if (col_expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
 			throw InternalException("Unexpected child of pivot source - not a ColumnRef");
 		}
 		auto &columnref = col_expr->Cast<ColumnRefExpression>();
@@ -631,7 +668,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	vector<unique_ptr<ParsedExpression>> unnest_name_children;
 	unnest_name_children.push_back(std::move(unpivot_name_expr));
 	auto unnest_name_expr = make_uniq<FunctionExpression>("unnest", std::move(unnest_name_children));
-	unnest_name_expr->alias = unpivot.unpivot_names[0];
+	unnest_name_expr->SetAlias(unpivot.unpivot_names[0]);
 	select_node->select_list.push_back(std::move(unnest_name_expr));
 
 	// construct the UNNEST expression for the set of unpivoted columns
@@ -645,7 +682,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		unnest_val_children.push_back(std::move(list_expr));
 		auto unnest_val_expr = make_uniq<FunctionExpression>("unnest", std::move(unnest_val_children));
 		auto unnest_name = i < ref.column_name_alias.size() ? ref.column_name_alias[i] : ref.unpivot_names[i];
-		unnest_val_expr->alias = unnest_name;
+		unnest_val_expr->SetAlias(unnest_name);
 		select_node->select_list.push_back(std::move(unnest_val_expr));
 		if (!ref.include_nulls) {
 			// if we are running with EXCLUDE NULLS we need to add an IS NOT NULL filter

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

@@ -1,13 +1,86 @@
-#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/function/table/system_functions.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/tableref/showref.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_column_data_get.hpp"
+#include "duckdb/planner/tableref/bound_table_function.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
+struct BaseTableColumnInfo {
+	optional_ptr<TableCatalogEntry> table;
+	optional_ptr<const ColumnDefinition> column;
+};
+
+BaseTableColumnInfo FindBaseTableColumn(LogicalOperator &op, ColumnBinding binding) {
+	BaseTableColumnInfo result;
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_GET: {
+		auto &get = op.Cast<LogicalGet>();
+		if (get.table_index != binding.table_index) {
+			return result;
+		}
+		auto table = get.GetTable();
+		if (!table) {
+			break;
+		}
+		if (!get.projection_ids.empty()) {
+			throw InternalException("Projection ids should not exist here");
+		}
+		result.table = table;
+		auto base_column_id = get.GetColumnIds()[binding.column_index];
+		result.column = &table->GetColumn(LogicalIndex(base_column_id.GetPrimaryIndex()));
+		return result;
+	}
+	case LogicalOperatorType::LOGICAL_PROJECTION: {
+		auto &projection = op.Cast<LogicalProjection>();
+		if (binding.table_index != projection.table_index) {
+			break;
+		}
+		auto &expr = projection.expressions[binding.column_index];
+		if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
+			// if the projection at this index only has a column reference we can directly trace it to the base table
+			auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
+			return FindBaseTableColumn(*projection.children[0], bound_colref.binding);
+		}
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_LIMIT:
+	case LogicalOperatorType::LOGICAL_ORDER_BY:
+	case LogicalOperatorType::LOGICAL_TOP_N:
+	case LogicalOperatorType::LOGICAL_SAMPLE:
+	case LogicalOperatorType::LOGICAL_DISTINCT:
+	case LogicalOperatorType::LOGICAL_FILTER:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
+	case LogicalOperatorType::LOGICAL_JOIN:
+	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
+		// for any "pass-through" operators - search in children directly
+		for (auto &child : op.children) {
+			result = FindBaseTableColumn(*child, binding);
+			if (result.table) {
+				return result;
+			}
+		}
+		break;
+	default:
+		// unsupported operator
+		break;
+	}
+	return result;
+}
+
+BaseTableColumnInfo FindBaseTableColumn(LogicalOperator &op, idx_t column_index) {
+	auto bindings = op.GetColumnBindings();
+	return FindBaseTableColumn(op, bindings[column_index]);
+}
+
 unique_ptr<BoundTableRef> Binder::BindShowQuery(ShowRef &ref) {
 	// bind the child plan of the DESCRIBE statement
 	auto child_binder = Binder::CreateBinder(context, this);
@@ -24,21 +97,29 @@ unique_ptr<BoundTableRef> Binder::BindShowQuery(ShowRef &ref) {
 	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];
+		// check if we can trace the column to a base table so that we can figure out constraint information
+		auto result = FindBaseTableColumn(*plan.plan, column_idx);
+		if (result.table) {
+			// we can! emit the information from the base table directly
+			PragmaTableInfo::GetColumnInfo(*result.table, *result.column, output, output.size());
+		} else {
+			// we cannot - read the type/name from the plan instead
+			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());
+			// "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) {