duckdb 0.7.2-dev0.0 → 0.7.2-dev1034.0

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

@@ -0,0 +1,366 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/expression/case_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/common/types/value_map.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/planner/tableref/bound_subqueryref.hpp"
+
+namespace duckdb {
+
+static void ConstructPivots(PivotRef &ref, idx_t pivot_idx, vector<unique_ptr<ParsedExpression>> &pivot_expressions,
+                            unique_ptr<ParsedExpression> current_expr = nullptr,
+                            const string &current_name = string()) {
+	auto &pivot = ref.pivots[pivot_idx];
+	bool last_pivot = pivot_idx + 1 == ref.pivots.size();
+	for (auto &entry : pivot.entries) {
+		unique_ptr<ParsedExpression> expr = current_expr ? current_expr->Copy() : nullptr;
+		string name = entry.alias;
+		D_ASSERT(entry.values.size() == pivot.pivot_expressions.size());
+		for (idx_t v = 0; v < entry.values.size(); v++) {
+			auto &value = entry.values[v];
+			auto column_ref = pivot.pivot_expressions[v]->Copy();
+			auto constant_value = make_unique<ConstantExpression>(value);
+			auto comp_expr = make_unique<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
+			                                                   std::move(column_ref), std::move(constant_value));
+			if (expr) {
+				expr = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+				                                          std::move(comp_expr));
+			} else {
+				expr = std::move(comp_expr);
+			}
+			if (entry.alias.empty()) {
+				if (name.empty()) {
+					name = value.ToString();
+				} else {
+					name += "_" + value.ToString();
+				}
+			}
+		}
+		if (!current_name.empty()) {
+			name = current_name + "_" + name;
+		}
+		if (last_pivot) {
+			// construct the aggregates
+			for (auto &aggr : ref.aggregates) {
+				auto copy = aggr->Copy();
+				auto &function = (FunctionExpression &)*copy;
+				// add the filter and alias to the aggregate function
+				function.filter = expr->Copy();
+				if (ref.aggregates.size() > 1 || !function.alias.empty()) {
+					// if there are multiple aggregates specified we add the name of the aggregate as well
+					function.alias = name + "_" + function.GetName();
+				} else {
+					function.alias = name;
+				}
+				pivot_expressions.push_back(std::move(copy));
+			}
+		} else {
+			// need to recurse
+			ConstructPivots(ref, pivot_idx + 1, pivot_expressions, std::move(expr), name);
+		}
+	}
+}
+
+static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &child_colref = (ColumnRefExpression &)expr;
+		if (child_colref.IsQualified()) {
+			throw BinderException("PIVOT expression cannot contain qualified columns");
+		}
+		handled_columns.insert(child_colref.GetColumnName());
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
+}
+
+unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns) {
+	const static idx_t PIVOT_EXPRESSION_LIMIT = 10000;
+	// 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;
+	// parse the aggregate, and extract the referenced columns from the aggregate
+	for (auto &aggr : ref.aggregates) {
+		if (aggr->type != ExpressionType::FUNCTION) {
+			throw BinderException(FormatError(*aggr, "Pivot expression must be an aggregate"));
+		}
+		if (aggr->HasSubquery()) {
+			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain subqueries"));
+		}
+		if (aggr->IsWindow()) {
+			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain window functions"));
+		}
+		ExtractPivotExpressions(*aggr, handled_columns);
+	}
+	value_set_t pivots;
+
+	// now handle the pivots
+	auto select_node = make_unique<SelectNode>();
+	// first add all pivots to the set of handled columns, and check for duplicates
+	idx_t total_pivots = 1;
+	for (auto &pivot : ref.pivots) {
+		if (!pivot.pivot_enum.empty()) {
+			auto type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
+			if (type.id() != LogicalTypeId::ENUM) {
+				throw BinderException(
+				    FormatError(ref, StringUtil::Format("Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
+				                                        pivot.pivot_enum, type.ToString())));
+			}
+			auto enum_size = EnumType::GetSize(type);
+			for (idx_t i = 0; i < enum_size; i++) {
+				auto enum_value = EnumType::GetValue(Value::ENUM(i, type));
+				PivotColumnEntry entry;
+				entry.values.emplace_back(enum_value);
+				entry.alias = std::move(enum_value);
+				pivot.entries.push_back(std::move(entry));
+			}
+		}
+		total_pivots *= pivot.entries.size();
+		// add the pivoted column to the columns that have been handled
+		for (auto &pivot_name : pivot.pivot_expressions) {
+			ExtractPivotExpressions(*pivot_name, handled_columns);
+		}
+		value_set_t pivots;
+		for (auto &entry : pivot.entries) {
+			D_ASSERT(!entry.star_expr);
+			Value val;
+			if (entry.values.size() == 1) {
+				val = entry.values[0];
+			} else {
+				val = Value::LIST(LogicalType::VARCHAR, entry.values);
+			}
+			if (pivots.find(val) != pivots.end()) {
+				throw BinderException(FormatError(
+				    ref, StringUtil::Format("The value \"%s\" was specified multiple times in the IN clause",
+				                            val.ToString())));
+			}
+			if (entry.values.size() != pivot.pivot_expressions.size()) {
+				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				                      pivot.pivot_expressions.size(), entry.values.size());
+			}
+			pivots.insert(val);
+		}
+	}
+	if (total_pivots >= PIVOT_EXPRESSION_LIMIT) {
+		throw BinderException("Pivot column limit of %llu exceeded", PIVOT_EXPRESSION_LIMIT);
+	}
+	// now construct the actual aggregates
+	// note that we construct a cross-product of all pivots
+	// we do this recursively
+	vector<unique_ptr<ParsedExpression>> pivot_expressions;
+	ConstructPivots(ref, 0, pivot_expressions);
+
+	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) {
+				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
+			}
+			auto &columnref = (ColumnRefExpression &)*entry;
+			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
+				// not handled - add to grouping set
+				select_node->groups.group_expressions.push_back(
+				    make_unique<ConstantExpression>(Value::INTEGER(select_node->select_list.size() + 1)));
+				select_node->select_list.push_back(std::move(entry));
+			}
+		}
+	} else {
+		// if rows are specified only the columns mentioned in rows are added as groups
+		for (auto &row : ref.groups) {
+			select_node->groups.group_expressions.push_back(
+			    make_unique<ConstantExpression>(Value::INTEGER(select_node->select_list.size() + 1)));
+			select_node->select_list.push_back(make_unique<ColumnRefExpression>(row));
+		}
+	}
+	// add the pivot expressions to the select list
+	for (auto &pivot_expr : pivot_expressions) {
+		select_node->select_list.push_back(std::move(pivot_expr));
+	}
+	return select_node;
+}
+
+unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
+                                           vector<unique_ptr<ParsedExpression>> all_columns,
+                                           unique_ptr<ParsedExpression> &where_clause) {
+	D_ASSERT(ref.groups.empty());
+	D_ASSERT(ref.pivots.size() == 1);
+
+	unique_ptr<ParsedExpression> expr;
+	auto select_node = make_unique<SelectNode>();
+
+	// handle the pivot
+	auto &unpivot = ref.pivots[0];
+
+	// handle star expressions in any entries
+	vector<PivotColumnEntry> new_entries;
+	for (auto &entry : unpivot.entries) {
+		if (entry.star_expr) {
+			D_ASSERT(entry.values.empty());
+			vector<unique_ptr<ParsedExpression>> star_columns;
+			child_binder.ExpandStarExpression(std::move(entry.star_expr), star_columns);
+
+			for (auto &col : star_columns) {
+				if (col->type != ExpressionType::COLUMN_REF) {
+					throw InternalException("Unexpected child of unpivot star - not a ColumnRef");
+				}
+				auto &columnref = (ColumnRefExpression &)*col;
+				PivotColumnEntry new_entry;
+				new_entry.values.emplace_back(columnref.GetColumnName());
+				new_entry.alias = columnref.GetColumnName();
+				new_entries.push_back(std::move(new_entry));
+			}
+		} else {
+			new_entries.push_back(std::move(entry));
+		}
+	}
+	unpivot.entries = std::move(new_entries);
+
+	case_insensitive_set_t handled_columns;
+	case_insensitive_map_t<string> name_map;
+	for (auto &entry : unpivot.entries) {
+		for (auto &value : entry.values) {
+			handled_columns.insert(value.ToString());
+		}
+	}
+
+	for (auto &col_expr : all_columns) {
+		if (col_expr->type != ExpressionType::COLUMN_REF) {
+			throw InternalException("Unexpected child of pivot source - not a ColumnRef");
+		}
+		auto &columnref = (ColumnRefExpression &)*col_expr;
+		auto &column_name = columnref.GetColumnName();
+		auto entry = handled_columns.find(column_name);
+		if (entry == handled_columns.end()) {
+			// not handled - add to the set of regularly selected columns
+			select_node->select_list.push_back(std::move(col_expr));
+		} else {
+			name_map[column_name] = column_name;
+			handled_columns.erase(entry);
+		}
+	}
+	if (!handled_columns.empty()) {
+		for (auto &entry : handled_columns) {
+			throw BinderException("Column \"%s\" referenced in UNPIVOT but no matching entry was found in the table",
+			                      entry);
+		}
+	}
+	vector<Value> unpivot_names;
+	for (auto &entry : unpivot.entries) {
+		string generated_name;
+		for (auto &val : entry.values) {
+			auto name_entry = name_map.find(val.ToString());
+			if (name_entry == name_map.end()) {
+				throw InternalException("Unpivot - could not find column name in name map");
+			}
+			if (!generated_name.empty()) {
+				generated_name += "_";
+			}
+			generated_name += name_entry->second;
+		}
+		unpivot_names.emplace_back(!entry.alias.empty() ? entry.alias : generated_name);
+	}
+	vector<vector<unique_ptr<ParsedExpression>>> unpivot_expressions;
+	for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) {
+		vector<unique_ptr<ParsedExpression>> expressions;
+		expressions.reserve(unpivot.entries.size());
+		for (auto &entry : unpivot.entries) {
+			expressions.push_back(make_unique<ColumnRefExpression>(entry.values[v_idx].ToString()));
+		}
+		unpivot_expressions.push_back(std::move(expressions));
+	}
+
+	// construct the UNNEST expression for the set of names (constant)
+	auto unpivot_list = Value::LIST(LogicalType::VARCHAR, std::move(unpivot_names));
+	auto unpivot_name_expr = make_unique<ConstantExpression>(std::move(unpivot_list));
+	vector<unique_ptr<ParsedExpression>> unnest_name_children;
+	unnest_name_children.push_back(std::move(unpivot_name_expr));
+	auto unnest_name_expr = make_unique<FunctionExpression>("unnest", std::move(unnest_name_children));
+	unnest_name_expr->alias = 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
+	if (ref.unpivot_names.size() != unpivot_expressions.size()) {
+		throw BinderException("UNPIVOT name count mismatch - got %d names but %d expressions", ref.unpivot_names.size(),
+		                      unpivot_expressions.size());
+	}
+	for (idx_t i = 0; i < unpivot_expressions.size(); i++) {
+		auto list_expr = make_unique<FunctionExpression>("list_value", std::move(unpivot_expressions[i]));
+		vector<unique_ptr<ParsedExpression>> unnest_val_children;
+		unnest_val_children.push_back(std::move(list_expr));
+		auto unnest_val_expr = make_unique<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;
+		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
+			auto colref = make_unique<ColumnRefExpression>(unnest_name);
+			auto filter = make_unique<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(colref));
+			if (where_clause) {
+				where_clause = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+				                                                  std::move(where_clause), std::move(filter));
+			} else {
+				where_clause = std::move(filter);
+			}
+		}
+	}
+	return select_node;
+}
+
+unique_ptr<BoundTableRef> Binder::Bind(PivotRef &ref) {
+	if (!ref.source) {
+		throw InternalException("Pivot without a source!?");
+	}
+
+	// bind the source of the pivot
+	auto child_binder = Binder::CreateBinder(context, this);
+	auto from_table = child_binder->Bind(*ref.source);
+
+	// figure out the set of column names that are in the source of the pivot
+	vector<unique_ptr<ParsedExpression>> all_columns;
+	child_binder->ExpandStarExpression(make_unique<StarExpression>(), all_columns);
+
+	unique_ptr<SelectNode> select_node;
+	unique_ptr<ParsedExpression> where_clause;
+	if (!ref.aggregates.empty()) {
+		select_node = BindPivot(ref, std::move(all_columns));
+	} else {
+		select_node = BindUnpivot(*child_binder, ref, std::move(all_columns), where_clause);
+	}
+	// bind the generated select node
+	auto bound_select_node = child_binder->BindSelectNode(*select_node, std::move(from_table));
+	auto root_index = bound_select_node->GetRootIndex();
+	BoundQueryNode *bound_select_ptr = bound_select_node.get();
+
+	unique_ptr<BoundTableRef> result;
+	MoveCorrelatedExpressions(*child_binder);
+	result = make_unique<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
+	auto alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
+	SubqueryRef subquery_ref(nullptr, alias);
+	subquery_ref.column_name_alias = std::move(ref.column_name_alias);
+	if (where_clause) {
+		// if a WHERE clause was provided - bind a subquery holding the WHERE clause
+		// we need to bind a new subquery here because the WHERE clause has to be applied AFTER the unnest
+		child_binder = Binder::CreateBinder(context, this);
+		child_binder->bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
+		auto where_query = make_unique<SelectNode>();
+		where_query->select_list.push_back(make_unique<StarExpression>());
+		where_query->where_clause = std::move(where_clause);
+		bound_select_node = child_binder->BindSelectNode(*where_query, std::move(result));
+		bound_select_ptr = bound_select_node.get();
+		root_index = bound_select_node->GetRootIndex();
+		result = make_unique<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
+	}
+	bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
+	return result;
+}
+
+} // namespace duckdb

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

@@ -126,9 +126,18 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	unique_ptr<FunctionData> bind_data;
 	vector<LogicalType> return_types;
 	vector<string> return_names;
-	if (table_function.bind) {
+	if (table_function.bind || table_function.bind_replace) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
 		                                  table_function.function_info.get());
+		if (table_function.bind_replace) {
+			auto new_plan = table_function.bind_replace(context, bind_input);
+			if (new_plan != nullptr) {
+				return CreatePlan(*Bind(*new_plan));
+			} else if (!table_function.bind) {
+				throw BinderException("Failed to bind \"%s\": nullptr returned from bind_replace without bind function",
+				                      table_function.name);
+			}
+		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
 		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
 			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
@@ -153,6 +162,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			return_names[i] = "C" + to_string(i);
 		}
 	}
+
 	auto get = make_unique<LogicalGet>(bind_index, table_function, std::move(bind_data), return_types, return_names);
 	get->parameters = parameters;
 	get->named_parameters = named_parameters;

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

@@ -8,6 +8,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
 	auto index = ref.bind_index;
 
 	vector<LogicalType> types;
+	types.reserve(ref.types.size());
 	for (auto &type : ref.types) {
 		types.push_back(type);
 	}

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

@@ -7,6 +7,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
@@ -33,7 +34,7 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
+			condition.comparison = FlipComparisonExpression(expr.type);
 		}
 		condition.left = std::move(left);
 		condition.right = std::move(right);
@@ -104,12 +105,43 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 	return ExtractJoinConditions(type, left_child, right_child, expressions, conditions, arbitrary_expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               vector<JoinCondition> conditions,
                                                               vector<unique_ptr<Expression>> arbitrary_expressions) {
+	// Validate the conditions
 	bool need_to_consider_arbitrary_expressions = true;
-	if (type == JoinType::INNER) {
+	switch (reftype) {
+	case JoinRefType::ASOF: {
+		need_to_consider_arbitrary_expressions = false;
+		auto asof_idx = conditions.size();
+		for (size_t c = 0; c < conditions.size(); ++c) {
+			auto &cond = conditions[c];
+			switch (cond.comparison) {
+			case ExpressionType::COMPARE_EQUAL:
+			case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+				break;
+			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+				if (asof_idx < conditions.size()) {
+					throw BinderException("Multiple ASOF JOIN inequalities");
+				}
+				asof_idx = c;
+				break;
+			default:
+				throw BinderException("Invalid ASOF JOIN comparison");
+			}
+		}
+		if (asof_idx == conditions.size()) {
+			throw BinderException("Missing ASOF JOIN inequality");
+		}
+		break;
+	}
+	default:
+		break;
+	}
+
+	if (type == JoinType::INNER && reftype == JoinRefType::REGULAR) {
 		// for inner joins we can push arbitrary expressions as a filter
 		// here we prefer to create a comparison join if possible
 		// that way we can use the much faster hash join to process the main join
@@ -144,7 +176,12 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, uni
 	} else {
 		// we successfully converted expressions into JoinConditions
 		// create a LogicalComparisonJoin
-		auto comp_join = make_unique<LogicalComparisonJoin>(type);
+		unique_ptr<LogicalComparisonJoin> comp_join;
+		if (reftype == JoinRefType::ASOF) {
+			comp_join = make_unique<LogicalAsOfJoin>(type);
+		} else {
+			comp_join = make_unique<LogicalComparisonJoin>(type);
+		}
 		comp_join->conditions = std::move(conditions);
 		comp_join->children.push_back(std::move(left_child));
 		comp_join->children.push_back(std::move(right_child));
@@ -179,15 +216,16 @@ static bool HasCorrelatedColumns(Expression &expression) {
 	return has_correlated_columns;
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               unique_ptr<Expression> condition) {
 	vector<JoinCondition> conditions;
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	LogicalComparisonJoin::ExtractJoinConditions(type, left_child, right_child, std::move(condition), conditions,
 	                                             arbitrary_expressions);
-	return LogicalComparisonJoin::CreateJoin(type, std::move(left_child), std::move(right_child), std::move(conditions),
-	                                         std::move(arbitrary_expressions));
+	return LogicalComparisonJoin::CreateJoin(type, reftype, std::move(left_child), std::move(right_child),
+	                                         std::move(conditions), std::move(arbitrary_expressions));
 }
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
@@ -201,7 +239,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// we reduce expression depth of all columns in the "ref.correlated_columns" set by 1
 		LateralBinder::ReduceExpressionDepth(*right, ref.correlated_columns);
 	}
-	if (ref.type == JoinType::RIGHT && ClientConfig::GetConfig(context).enable_optimizer) {
+	if (ref.type == JoinType::RIGHT && ref.ref_type != JoinRefType::ASOF &&
+	    ClientConfig::GetConfig(context).enable_optimizer) {
 		// we turn any right outer joins into left outer joins for optimization purposes
 		// they are the same but with sides flipped, so treating them the same simplifies life
 		ref.type = JoinType::LEFT;
@@ -220,7 +259,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	default:
 		break;
 	}
-	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition))) {
+	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition)) &&
+	    ref.ref_type == JoinRefType::REGULAR) {
 		// inner join, generate a cross product + filter
 		// this will be later turned into a proper join by the join order optimizer
 		auto root = LogicalCrossProduct::Create(std::move(left), std::move(right));
@@ -235,8 +275,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// now create the join operator from the join condition
-	auto result =
-	    LogicalComparisonJoin::CreateJoin(ref.type, std::move(left), std::move(right), std::move(ref.condition));
+	auto result = LogicalComparisonJoin::CreateJoin(ref.type, ref.ref_type, std::move(left), std::move(right),
+	                                                std::move(ref.condition));
 
 	LogicalOperator *join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
@@ -254,7 +294,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// we visit the expressions depending on the type of join
-	if (join->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+	switch (join->type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		// comparison join
 		// in this join we visit the expressions on the LHS with the LHS as root node
 		// and the expressions on the RHS with the RHS as root node
@@ -263,12 +305,18 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
 			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
 		}
-	} else if (join->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
 		auto &any_join = (LogicalAnyJoin &)*join;
 		// for the any join we just visit the condition
 		if (any_join.condition->HasSubquery()) {
 			throw NotImplementedException("Cannot perform non-inner join on subquery!");
 		}
+		break;
+	}
+	default:
+		break;
 	}
 	return result;
 }

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

@@ -3,8 +3,10 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/list.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/bound_tableref.hpp"
@@ -13,7 +15,6 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 #include <algorithm>
 
@@ -170,8 +171,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = Bind((ExpressionListRef &)ref);
 		break;
+	case TableReferenceType::PIVOT:
+		result = Bind((PivotRef &)ref);
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unknown table ref type");
 	}
 	result->sample = std::move(ref.sample);
@@ -203,6 +208,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 		root = CreatePlan((BoundCTERef &)ref);
 		break;
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unsupported bound table ref type");
 	}
 	// plan the sample clause
@@ -432,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;
@@ -451,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));