duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,176 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/planner/expression_binder/table_function_binder.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "re2/re2.h"
+
+namespace duckdb {
+
+bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root,
+                                bool in_columns) {
+	bool has_star = false;
+	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
+		auto current_star = (StarExpression *)expr.get();
+		if (!current_star->columns) {
+			if (is_root) {
+				*star = current_star;
+				return true;
+			}
+			if (!in_columns) {
+				throw BinderException(
+				    "STAR expression is only allowed as the root element of an expression. Use COLUMNS(*) instead.");
+			}
+			// star expression inside a COLUMNS - convert to a constant list
+			if (!current_star->replace_list.empty()) {
+				throw BinderException(
+				    "STAR expression with REPLACE list is only allowed as the root element of COLUMNS");
+			}
+			vector<unique_ptr<ParsedExpression>> star_list;
+			bind_context.GenerateAllColumnExpressions(*current_star, star_list);
+
+			vector<Value> values;
+			values.reserve(star_list.size());
+			for (auto &expr : star_list) {
+				values.emplace_back(expr->ToString());
+			}
+			D_ASSERT(!values.empty());
+
+			expr = make_unique<ConstantExpression>(Value::LIST(LogicalType::VARCHAR, values));
+			return true;
+		}
+		if (in_columns) {
+			throw BinderException("COLUMNS expression is not allowed inside another COLUMNS expression");
+		}
+		in_columns = true;
+		if (*star) {
+			// we can have multiple
+			if (!StarExpression::Equal(*star, current_star)) {
+				throw BinderException(
+				    FormatError(*expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
+			}
+			return true;
+		}
+		*star = current_star;
+		has_star = true;
+	}
+	ParsedExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<ParsedExpression> &child_expr) {
+		if (FindStarExpression(child_expr, star, false, in_columns)) {
+			has_star = true;
+		}
+	});
+	return has_star;
+}
+
+void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement) {
+	D_ASSERT(expr);
+	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
+		D_ASSERT(replacement);
+		expr = replacement->Copy();
+		return;
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceStarExpression(child_expr, replacement); });
+}
+
+void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
+                                  vector<unique_ptr<ParsedExpression>> &new_select_list) {
+	StarExpression *star = nullptr;
+	if (!FindStarExpression(expr, &star, true, false)) {
+		// no star expression: add it as-is
+		D_ASSERT(!star);
+		new_select_list.push_back(std::move(expr));
+		return;
+	}
+	D_ASSERT(star);
+	vector<unique_ptr<ParsedExpression>> star_list;
+	// we have star expressions! expand the list of star expressions
+	bind_context.GenerateAllColumnExpressions(*star, star_list);
+
+	if (star->expr) {
+		// COLUMNS with an expression
+		// two options:
+		// VARCHAR parameter <- this is a regular expression
+		// LIST of VARCHAR parameters <- this is a set of columns
+		TableFunctionBinder binder(*this, context);
+		auto child = star->expr->Copy();
+		auto result = binder.Bind(child);
+		if (!result->IsFoldable()) {
+			// cannot resolve parameters here
+			if (star->expr->HasParameter()) {
+				throw ParameterNotResolvedException();
+			} else {
+				throw BinderException("Unsupported expression in COLUMNS");
+			}
+		}
+		auto val = ExpressionExecutor::EvaluateScalar(context, *result);
+		if (val.type().id() == LogicalTypeId::VARCHAR) {
+			// regex
+			if (val.IsNull()) {
+				throw BinderException("COLUMNS does not support NULL as regex argument");
+			}
+			auto &regex_str = StringValue::Get(val);
+			duckdb_re2::RE2 regex(regex_str);
+			if (!regex.error().empty()) {
+				auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex.error());
+				throw BinderException(FormatError(*star, err));
+			}
+			vector<unique_ptr<ParsedExpression>> new_list;
+			for (idx_t i = 0; i < star_list.size(); i++) {
+				auto &colref = (ColumnRefExpression &)*star_list[i];
+				if (!RE2::PartialMatch(colref.GetColumnName(), regex)) {
+					continue;
+				}
+				new_list.push_back(std::move(star_list[i]));
+			}
+			if (new_list.empty()) {
+				auto err = StringUtil::Format("No matching columns found that match regex \"%s\"", regex_str);
+				throw BinderException(FormatError(*star, err));
+			}
+			star_list = std::move(new_list);
+		} else if (val.type().id() == LogicalTypeId::LIST &&
+		           ListType::GetChildType(val.type()).id() == LogicalTypeId::VARCHAR) {
+			// list of varchar columns
+			if (val.IsNull() || ListValue::GetChildren(val).empty()) {
+				auto err =
+				    StringUtil::Format("Star expression \"%s\" resulted in an empty set of columns", star->ToString());
+				throw BinderException(FormatError(*star, err));
+			}
+			auto &children = ListValue::GetChildren(val);
+			vector<unique_ptr<ParsedExpression>> new_list;
+			for (auto &child : children) {
+				auto qname = QualifiedName::Parse(StringValue::Get(child));
+				vector<string> names;
+				if (!qname.catalog.empty()) {
+					names.push_back(qname.catalog);
+				}
+				if (!qname.schema.empty()) {
+					names.push_back(qname.schema);
+				}
+				names.push_back(qname.name);
+				new_list.push_back(make_unique<ColumnRefExpression>(std::move(names)));
+			}
+			star_list = std::move(new_list);
+		} else {
+			throw BinderException(FormatError(
+			    *star, "COLUMNS expects either a VARCHAR argument (regex) or a LIST of VARCHAR (list of columns)"));
+		}
+	}
+
+	// now perform the replacement
+	for (idx_t i = 0; i < star_list.size(); i++) {
+		auto new_expr = expr->Copy();
+		ReplaceStarExpression(new_expr, star_list[i]);
+		new_select_list.push_back(std::move(new_expr));
+	}
+}
+
+void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
+                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
+	for (auto &select_element : select_list) {
+		ExpandStarExpression(std::move(select_element), new_select_list);
+	}
+}
+
+} // namespace duckdb

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

@@ -32,6 +32,10 @@ public:
 	void Serialize(FieldWriter &writer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override {
+		throw InternalException("Cannot serialize bound subquery node");
+	}
 };
 
 BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {