duckdb 0.7.1 → 0.7.2-dev1034.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,82 +271,54 @@ 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); });
+unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
+	D_ASSERT(statement.from_table);
+	// first bind the FROM table statement
+	auto from = std::move(statement.from_table);
+	auto from_table = Bind(*from);
+	return BindSelectNode(statement, std::move(from_table));
 }
 
-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));
+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;
 	}
-	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));
+	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.");
+		}
 	}
-}
-
-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);
+	// 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::BindNode(SelectNode &statement) {
+unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
+	D_ASSERT(from_table);
+	D_ASSERT(!statement.from_table);
 	auto result = make_unique<BoundSelectNode>();
 	result->projection_index = GenerateTableIndex();
 	result->group_index = GenerateTableIndex();
 	result->aggregate_index = GenerateTableIndex();
 	result->groupings_index = GenerateTableIndex();
 	result->window_index = GenerateTableIndex();
-	result->unnest_index = GenerateTableIndex();
 	result->prune_index = GenerateTableIndex();
 
-	// first bind the FROM table statement
-	result->from_table = Bind(*statement.from_table);
-
+	result->from_table = std::move(from_table);
 	// bind the sample clause
 	if (statement.sample) {
 		result->sample_options = std::move(statement.sample);
@@ -373,6 +352,9 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// 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);
@@ -443,12 +425,34 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// after that, we bind to the SELECT list
 	SelectBinder select_binder(*this, context, *result, info, alias_map);
 	vector<LogicalType> internal_sql_types;
+	vector<idx_t> group_by_all_indexes;
+	vector<string> new_names;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
 		idx_t unnest_count = result->unnests.size();
 		LogicalType result_type;
-		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
+		auto expr = select_binder.Bind(statement.select_list[i], &result_type, true);
+		bool is_original_column = i < result->column_count;
+		bool can_group_by_all =
+		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
+		if (select_binder.HasExpandedExpressions()) {
+			if (!is_original_column) {
+				throw InternalException("Only original columns can have expanded expressions");
+			}
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				throw BinderException("UNNEST of struct cannot be combined with GROUP BY ALL");
+			}
+			auto &struct_expressions = select_binder.ExpandedExpressions();
+			D_ASSERT(!struct_expressions.empty());
+			for (auto &struct_expr : struct_expressions) {
+				new_names.push_back(struct_expr->GetName());
+				result->types.push_back(struct_expr->return_type);
+				result->select_list.push_back(std::move(struct_expr));
+			}
+			struct_expressions.clear();
+			continue;
+		}
+		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
 			}
@@ -460,20 +464,28 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 			}
 			// we are forcing aggregates, and the node has columns bound
 			// this entry becomes a group
-			auto group_ref = make_unique<BoundColumnRefExpression>(
-			    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-			result->groups.group_expressions.push_back(std::move(expr));
-			expr = std::move(group_ref);
+			group_by_all_indexes.push_back(i);
 		}
 		result->select_list.push_back(std::move(expr));
-		if (i < result->column_count) {
+		if (is_original_column) {
+			new_names.push_back(std::move(result->names[i]));
 			result->types.push_back(result_type);
 		}
 		internal_sql_types.push_back(result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+		if (can_group_by_all) {
 			select_binder.ResetBindings();
 		}
 	}
+	// push the GROUP BY ALL expressions into the group set
+	for (auto &group_by_all_index : group_by_all_indexes) {
+		auto &expr = result->select_list[group_by_all_index];
+		auto group_ref = make_unique<BoundColumnRefExpression>(
+		    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
+		result->groups.group_expressions.push_back(std::move(expr));
+		expr = std::move(group_ref);
+	}
+	result->column_count = new_names.size();
+	result->names = std::move(new_names);
 	result->need_prune = result->select_list.size() > result->column_count;
 
 	// in the normal select binder, we bind columns as if there is no aggregation
@@ -484,16 +496,19 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	    !result->groups.grouping_sets.empty()) {
 		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
 			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else if (statement.aggregate_handling == AggregateHandling::STANDARD_HANDLING) {
-			if (select_binder.HasBoundColumns()) {
-				auto &bound_columns = select_binder.GetBoundColumns();
-				string error;
-				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+		} else if (select_binder.HasBoundColumns()) {
+			auto &bound_columns = select_binder.GetBoundColumns();
+			string error;
+			error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
+				         "GROUP BY this entry explicitly.";
+			} else {
 				error += "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
 				         "is not important.";
-				throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
-				                                  bound_columns[0].name, bound_columns[0].name));
 			}
+			throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
+			                                  bound_columns[0].name, bound_columns[0].name));
 		}
 	}
 

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/query_node/plan_select_node.cpp

@@ -88,9 +88,15 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		root = std::move(qualify);
 	}
 
-	if (!statement.unnests.empty()) {
-		auto unnest = make_unique<LogicalUnnest>(statement.unnest_index);
-		unnest->expressions = std::move(statement.unnests);
+	for (idx_t i = statement.unnests.size(); i > 0; i--) {
+		auto unnest_level = i - 1;
+		auto entry = statement.unnests.find(unnest_level);
+		if (entry == statement.unnests.end()) {
+			throw InternalException("unnests specified at level %d but none were found", unnest_level);
+		}
+		auto &unnest_node = entry->second;
+		auto unnest = make_unique<LogicalUnnest>(unnest_node.index);
+		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
 			PlanSubqueries(&expr, &root);
@@ -104,7 +110,6 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		PlanSubqueries(&expr, &root);
 	}
 
-	// create the projection
 	auto proj = make_unique<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
 	auto &projection = *proj;
 	proj->AddChild(std::move(root));

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

@@ -158,7 +158,9 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
 
-	D_ASSERT(!stmt.info->table.empty());
+	if (stmt.info->table.empty()) {
+		throw ParserException("COPY FROM requires a table name to be specified");
+	}
 	// COPY FROM a file
 	// generate an insert statement for the the to-be-inserted table
 	InsertStatement insert;
@@ -185,7 +187,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -193,7 +195,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}

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

@@ -441,8 +441,9 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 
 	auto &get = (LogicalGet &)*plan;
 	// bind the index expressions
-	vector<unique_ptr<Expression>> expressions;
 	IndexBinder index_binder(binder, binder.context);
+	vector<unique_ptr<Expression>> expressions;
+	expressions.reserve(base.expressions.size());
 	for (auto &expr : base.expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}
@@ -467,7 +468,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
-	properties.return_type = StatementReturnType::NOTHING;
 
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
@@ -675,6 +675,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	default:
 		throw Exception("Unrecognized type!");
 	}
+	properties.return_type = StatementReturnType::NOTHING;
 	properties.allow_stream_result = false;
 	return result;
 }

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

@@ -119,9 +119,15 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
 			physical_index_set_t fk_key_set, pk_key_set;
 			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
+				if (pk_key_set.find(fk.info.pk_keys[i]) != pk_key_set.end()) {
+					throw BinderException("Duplicate primary key referenced in FOREIGN KEY constraint");
+				}
 				pk_key_set.insert(fk.info.pk_keys[i]);
 			}
 			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
+				if (fk_key_set.find(fk.info.fk_keys[i]) != fk_key_set.end()) {
+					throw BinderException("Duplicate key specified in FOREIGN KEY constraint");
+				}
 				fk_key_set.insert(fk.info.fk_keys[i]);
 			}
 			info.bound_constraints.push_back(
@@ -292,6 +298,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			result->dependencies.AddDependency(type_dependency);
 		}
 	}
+	result->dependencies.VerifyDependencies(schema->catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }
@@ -303,9 +310,10 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 }
 
 vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
-	vector<unique_ptr<Expression>> expressions;
 
 	auto index_binder = IndexBinder(*this, this->context, table, info);
+	vector<unique_ptr<Expression>> expressions;
+	expressions.reserve(info->expressions.size());
 	for (auto &expr : info->expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}

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

@@ -335,6 +335,16 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
 	}
 
+	if (insert.action_type == OnConflictAction::REPLACE) {
+		D_ASSERT(on_conflict.set_info == nullptr);
+		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
+		insert.action_type = OnConflictAction::UPDATE;
+	}
+	if (on_conflict.set_info && on_conflict.set_info->columns.empty()) {
+		// if we are doing INSERT OR REPLACE on a table with no columns outside of the primary key column
+		// convert to INSERT OR IGNORE
+		insert.action_type = OnConflictAction::NOTHING;
+	}
 	if (insert.action_type == OnConflictAction::NOTHING) {
 		if (!insert.on_conflict_condition) {
 			return;
@@ -346,15 +356,9 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		insert.columns_to_fetch = table_binding->GetBoundColumnIds();
 		return;
 	}
-	if (insert.action_type == OnConflictAction::REPLACE) {
-		D_ASSERT(on_conflict.set_info == nullptr);
-		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
-		insert.action_type = OnConflictAction::UPDATE;
-	}
 
 	D_ASSERT(on_conflict.set_info);
 	auto &set_info = *on_conflict.set_info;
-	D_ASSERT(!set_info.columns.empty());
 	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
 
 	if (set_info.condition) {
@@ -505,8 +509,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_logical_plan.cpp

@@ -4,6 +4,19 @@
 
 namespace duckdb {
 
+idx_t GetMaxTableIndex(LogicalOperator &op) {
+	idx_t result = 0;
+	for (auto &child : op.children) {
+		auto max_child_index = GetMaxTableIndex(*child);
+		result = MaxValue<idx_t>(result, max_child_index);
+	}
+	auto indexes = op.GetTableIndex();
+	for (auto &index : indexes) {
+		result = MaxValue<idx_t>(result, index);
+	}
+	return result;
+}
+
 BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 	BoundStatement result;
 	result.types = stmt.plan->types;
@@ -14,6 +27,10 @@ BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT; // TODO could also be something else
 
+	if (parent) {
+		throw InternalException("LogicalPlanStatement should be bound in root binder");
+	}
+	bound_tables = GetMaxTableIndex(*result.plan) + 1;
 	return result;
 }
 

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

@@ -195,11 +195,13 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	if (stmt.from_table) {
+		auto from_binder = Binder::CreateBinder(context, this);
 		BoundJoinRef bound_crossproduct(JoinRefType::CROSS);
 		bound_crossproduct.left = std::move(bound_table);
-		bound_crossproduct.right = Bind(*stmt.from_table);
+		bound_crossproduct.right = from_binder->Bind(*stmt.from_table);
 		root = CreatePlan(bound_crossproduct);
 		get = (LogicalGet *)root->children[0].get();
+		bind_context.AddContext(std::move(from_binder->bind_context));
 	} else {
 		root = CreatePlan(*bound_table);
 		get = (LogicalGet *)root.get();
@@ -251,7 +253,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/tableref/bind_joinref.cpp

@@ -7,9 +7,11 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/planner/expression_binder/lateral_binder.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
 
 namespace duckdb {
 
@@ -23,11 +25,11 @@ 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 string &column_name) {
+                                                 const string &column_name, ExpressionType type) {
 	ExpressionBinder expr_binder(left_binder, context);
 	auto left = BindColumn(left_binder, context, left_alias, column_name);
 	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left), std::move(right));
+	return make_unique<ComparisonExpression>(type, std::move(left), std::move(right));
 }
 
 bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
@@ -196,12 +198,14 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		break;
 	}
 	case JoinRefType::REGULAR:
+	case JoinRefType::ASOF:
 		if (!ref.using_columns.empty()) {
 			// USING columns
 			D_ASSERT(!result->condition);
 			extra_using_columns = ref.using_columns;
 		}
 		break;
+
 	case JoinRefType::CROSS:
 	case JoinRefType::POSITIONAL:
 		break;
@@ -239,8 +243,13 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left", set.get());
 			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right", set.get());
 
+			// Last column of ASOF JOIN ... USING is >=
+			const auto type = (ref.ref_type == JoinRefType::ASOF && i == extra_using_columns.size() - 1)
+			                      ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
+			                      : ExpressionType::COMPARE_EQUAL;
+
 			extra_conditions.push_back(
-			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column));
+			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column, type));
 
 			AddUsingBindings(*set, left_using_binding, left_binding);
 			AddUsingBindings(*set, right_using_binding, right_binding);
@@ -253,6 +262,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		}
 	}
 
+	auto right_bindings_list_copy = right_binder.bind_context.GetBindingsList();
+
 	bind_context.AddContext(std::move(left_binder.bind_context));
 	bind_context.AddContext(std::move(right_binder.bind_context));
 	MoveCorrelatedExpressions(left_binder);
@@ -269,6 +280,11 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		WhereBinder binder(*this, context);
 		result->condition = binder.Bind(ref.condition);
 	}
+
+	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI) {
+		bind_context.RemoveContext(right_bindings_list_copy);
+	}
+
 	return std::move(result);
 }