duckdb 0.7.2-dev333.0 → 0.7.2-dev457.0

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

@@ -19,8 +19,7 @@
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 
 namespace duckdb {
 
@@ -136,31 +135,39 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			auto bound_order = make_unique<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
-			if (order.orders[0].expression->type == ExpressionType::STAR) {
-				// ORDER BY ALL
-				// replace the order list with the maximum order by count
-				D_ASSERT(order.orders.size() == 1);
-				auto order_type = order.orders[0].type;
-				auto null_order = order.orders[0].null_order;
-
-				vector<OrderByNode> new_orders;
-				for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-					new_orders.emplace_back(order_type, null_order,
-					                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+			auto &order_binders = order_binder.GetBinders();
+			if (order.orders.size() == 1 && order.orders[0].expression->type == ExpressionType::STAR) {
+				auto star = (StarExpression *)order.orders[0].expression.get();
+				if (star->exclude_list.empty() && star->replace_list.empty() && !star->expr) {
+					// ORDER BY ALL
+					// replace the order list with the all elements in the SELECT list
+					auto order_type = order.orders[0].type;
+					auto null_order = order.orders[0].null_order;
+
+					vector<OrderByNode> new_orders;
+					for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
+						new_orders.emplace_back(order_type, null_order,
+						                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+					}
+					order.orders = std::move(new_orders);
 				}
-				order.orders = std::move(new_orders);
 			}
 			for (auto &order_node : order.orders) {
-				auto order_expression = BindOrderExpression(order_binder, std::move(order_node.expression));
-				if (!order_expression) {
-					continue;
-				}
+				vector<unique_ptr<ParsedExpression>> order_list;
+				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
+
 				auto type =
 				    order_node.type == OrderType::ORDER_DEFAULT ? config.options.default_order_type : order_node.type;
 				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT
 				                      ? config.options.default_null_order
 				                      : order_node.null_order;
-				bound_order->orders.emplace_back(type, null_order, std::move(order_expression));
+				for (auto &order_expr : order_list) {
+					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
+					if (!bound_expr) {
+						continue;
+					}
+					bound_order->orders.emplace_back(type, null_order, std::move(bound_expr));
+				}
 			}
 			if (!bound_order->orders.empty()) {
 				bound_modifier = std::move(bound_order);
@@ -264,69 +271,6 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 	}
 }
 
-bool Binder::FindStarExpression(ParsedExpression &expr, StarExpression **star) {
-	if (expr.GetExpressionClass() == ExpressionClass::STAR) {
-		auto current_star = (StarExpression *)&expr;
-		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;
-		return true;
-	}
-	bool has_star = false;
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](ParsedExpression &child_expr) {
-		if (FindStarExpression(child_expr, star)) {
-			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)) {
-		// 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);
-
-	// 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);
-	}
-}
-
 unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	D_ASSERT(statement.from_table);
 	// first bind the FROM table statement
@@ -335,6 +279,34 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	return BindSelectNode(statement, std::move(from_table));
 }
 
+void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
+	// expand any expressions in the upper AND recursively
+	if (expr->type == ExpressionType::CONJUNCTION_AND) {
+		auto &conj = (ConjunctionExpression &)*expr;
+		for (auto &child : conj.children) {
+			BindWhereStarExpression(child);
+		}
+		return;
+	}
+	if (expr->type == ExpressionType::STAR) {
+		auto &star = (StarExpression &)*expr;
+		if (!star.columns) {
+			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
+		}
+	}
+	// expand the stars for this expression
+	vector<unique_ptr<ParsedExpression>> new_conditions;
+	ExpandStarExpression(std::move(expr), new_conditions);
+
+	// set up an AND conjunction between the expanded conditions
+	expr = std::move(new_conditions[0]);
+	for (idx_t i = 1; i < new_conditions.size(); i++) {
+		auto and_conj = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+		                                                   std::move(new_conditions[i]));
+		expr = std::move(and_conj);
+	}
+}
+
 unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
 	D_ASSERT(from_table);
 	D_ASSERT(!statement.from_table);
@@ -381,6 +353,9 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// first visit the WHERE clause
 	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
 	if (statement.where_clause) {
+		// bind any star expressions in the WHERE clause
+		BindWhereStarExpression(statement.where_clause);
+
 		ColumnAliasBinder alias_binder(*result, alias_map);
 		WhereBinder where_binder(*this, context, &alias_binder);
 		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);

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

@@ -4,6 +4,7 @@
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
@@ -20,6 +21,16 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
+			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
+				auto &distinct = (LogicalDistinct &)*root;
+				if (!distinct.distinct_targets.empty()) {
+					auto order_by = make_unique<BoundOrderModifier>();
+					for (auto &order_node : bound.orders) {
+						order_by->orders.push_back(order_node.Copy());
+					}
+					distinct.order_by = std::move(order_by);
+				}
+			}
 			auto order = make_unique<LogicalOrder>(std::move(bound.orders));
 			order->AddChild(std::move(root));
 			root = std::move(order);

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

@@ -83,7 +83,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		del->table_index = update_table_index;
 
 		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(del_as_logicaloperator), std::move(result));
 	}
 	result.plan = std::move(del);

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

@@ -505,8 +505,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		insert->table_index = insert_table_index;
 		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
-		return BindReturning(std::move(stmt.returning_list), table, insert_table_index,
-		                     std::move(index_as_logicaloperator), std::move(result));
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
+		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());

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

@@ -251,7 +251,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	if (!stmt.returning_list.empty()) {
 		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
 
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(update_as_logicaloperator), std::move(result));
 	}
 

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

@@ -438,8 +438,8 @@ void VerifyNotExcluded(ParsedExpression &expr) {
 }
 
 BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-                                     BoundStatement result) {
+                                     const string &alias, idx_t update_table_index,
+                                     unique_ptr<LogicalOperator> child_operator, BoundStatement result) {
 
 	vector<LogicalType> types;
 	vector<std::string> names;
@@ -457,31 +457,20 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table, false);
+	binder->bind_context.AddBaseTable(update_table_index, alias.empty() ? table->name : alias, names, types,
+	                                  bound_columns, table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;
 	LogicalType result_type;
-	for (auto &returning_expr : returning_list) {
-		auto expr_type = returning_expr->GetExpressionType();
-		if (expr_type == ExpressionType::STAR) {
-			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
-
-			for (auto &star_column : generated_star_list) {
-				auto star_expr = returning_binder.Bind(star_column, &result_type);
-				result.types.push_back(result_type);
-				result.names.push_back(star_expr->GetName());
-				projection_expressions.push_back(std::move(star_expr));
-			}
-		} else {
-			// TODO: accept 'excluded' in the RETURNING clause
-			VerifyNotExcluded(*returning_expr);
-			auto expr = returning_binder.Bind(returning_expr, &result_type);
-			result.names.push_back(expr->GetName());
-			result.types.push_back(result_type);
-			projection_expressions.push_back(std::move(expr));
-		}
+	vector<unique_ptr<ParsedExpression>> new_returning_list;
+	binder->ExpandStarExpressions(returning_list, new_returning_list);
+	for (auto &returning_expr : new_returning_list) {
+		VerifyNotExcluded(*returning_expr);
+		auto expr = returning_binder.Bind(returning_expr, &result_type);
+		result.names.push_back(expr->GetName());
+		result.types.push_back(result_type);
+		projection_expressions.push_back(std::move(expr));
 	}
 
 	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));

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

@@ -80,6 +80,32 @@ BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &source, PlanDeseria
 	return BoundOrderByNode(type, null_order, std::move(expression));
 }
 
+unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
+	auto result = make_unique<BoundOrderModifier>();
+	for (auto &order : orders) {
+		result->orders.push_back(order.Copy());
+	}
+	return result;
+}
+
+bool BoundOrderModifier::Equals(const BoundOrderModifier *left, const BoundOrderModifier *right) {
+	if (left == right) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	if (left->orders.size() != right->orders.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < left->orders.size(); i++) {
+		if (!left->orders[i].Equals(right->orders[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 

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

@@ -19,8 +19,8 @@ BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, v
 }
 
 string BoundAggregateExpression::ToString() const {
-	return FunctionExpression::ToString<BoundAggregateExpression, Expression>(*this, string(), function.name, false,
-	                                                                          IsDistinct(), filter.get());
+	return FunctionExpression::ToString<BoundAggregateExpression, Expression, BoundOrderModifier>(
+	    *this, string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
 }
 
 hash_t BoundAggregateExpression::Hash() const {
@@ -55,6 +55,9 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
 		return false;
 	}
+	if (!BoundOrderModifier::Equals(order_bys.get(), other->order_bys.get())) {
+		return false;
+	}
 	return true;
 }
 
@@ -74,12 +77,16 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	auto copy = make_unique<BoundAggregateExpression>(function, std::move(new_children), std::move(new_filter),
 	                                                  std::move(new_bind_info), aggr_type);
 	copy->CopyProperties(*this);
+	copy->order_bys = order_bys ? order_bys->Copy() : nullptr;
 	return std::move(copy);
 }
 
 void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteField(IsDistinct());
 	writer.WriteOptional(filter);
+	if (order_bys) {
+		throw NotImplementedException("Serialization of ORDER BY aggregate not yet supported");
+	}
 	FunctionSerializer::Serialize<AggregateFunction>(writer, function, return_type, children, bind_info.get());
 }
 

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

@@ -29,6 +29,11 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		if (aggr_expr.filter) {
 			callback(aggr_expr.filter);
 		}
+		if (aggr_expr.order_bys) {
+			for (auto &order : aggr_expr.order_bys->orders) {
+				callback(order.expression);
+			}
+		}
 		break;
 	}
 	case ExpressionClass::BOUND_BETWEEN: {

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -48,6 +48,11 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		for (auto &target : distinct.distinct_targets) {
 			callback(&target);
 		}
+		if (distinct.order_by) {
+			for (auto &order : distinct.order_by->orders) {
+				callback(&order.expression);
+			}
+		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_INSERT: {

package/src/duckdb/src/planner/operator/logical_distinct.cpp

@@ -15,6 +15,9 @@ string LogicalDistinct::ParamsToString() const {
 }
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializableList(distinct_targets);
+	if (order_by) {
+		throw NotImplementedException("Serializing ORDER BY not yet supported");
+	}
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 45;
+const uint64_t VERSION_NUMBER = 46;
 
 struct StorageVersionInfo {
 	const char *version_name;

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

@@ -307,7 +307,7 @@ typedef struct PGFuncCall {
 typedef struct PGAStar {
 	PGNodeTag type;
 	char *relation;       /* relation name (optional) */
-	char *regex;          /* optional: REGEX to select columns */
+	PGNode *expr;         /* optional: the expression (regex or list) to select columns */
 	PGList *except_list;  /* optional: EXCLUDE list */
 	PGList *replace_list; /* optional: REPLACE list */
 	bool columns;         /* whether or not this is a columns list */