duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp

@@ -46,7 +46,7 @@ bool FlattenDependentJoins::DetectCorrelatedExpressions(LogicalOperator *op, boo
 
 unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_ptr<LogicalOperator> plan) {
 	bool propagate_null_values = true;
-	auto result = PushDownDependentJoinInternal(move(plan), propagate_null_values);
+	auto result = PushDownDependentJoinInternal(std::move(plan), propagate_null_values);
 	if (!replacement_map.empty()) {
 		// check if we have to replace any COUNT aggregates into "CASE WHEN X IS NULL THEN 0 ELSE COUNT END"
 		RewriteCountAggregates aggr(replacement_map);
@@ -85,7 +85,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		this->delim_offset = left_columns;
 		this->data_offset = 0;
 		auto delim_scan = make_unique<LogicalDelimGet>(delim_index, delim_types);
-		return LogicalCrossProduct::Create(move(plan), move(delim_scan));
+		return LogicalCrossProduct::Create(std::move(plan), std::move(delim_scan));
 	}
 	switch (plan->type) {
 	case LogicalOperatorType::LOGICAL_UNNEST:
@@ -95,7 +95,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		for (auto &expr : plan->expressions) {
 			any_join |= SubqueryDependentFilter(expr.get());
 		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
@@ -108,7 +108,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		for (auto &expr : plan->expressions) {
 			parent_propagate_null_values &= expr->PropagatesNullValues();
 		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
@@ -119,7 +119,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			auto &col = correlated_columns[i];
 			auto colref = make_unique<BoundColumnRefExpression>(
 			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			plan->expressions.push_back(move(colref));
+			plan->expressions.push_back(std::move(colref));
 		}
 
 		base_binding.table_index = proj->table_index;
@@ -134,7 +134,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		for (auto &expr : plan->expressions) {
 			parent_propagate_null_values &= expr->PropagatesNullValues();
 		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
@@ -150,7 +150,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			for (auto &set : aggr.grouping_sets) {
 				set.insert(aggr.groups.size());
 			}
-			aggr.groups.push_back(move(colref));
+			aggr.groups.push_back(std::move(colref));
 		}
 		if (!perform_delim) {
 			// if we are not performing the duplicate elimination, we have only added the row_id column to the grouping
@@ -164,10 +164,11 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				auto colref = make_unique<BoundColumnRefExpression>(
 				    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
 				vector<unique_ptr<Expression>> aggr_children;
-				aggr_children.push_back(move(colref));
-				auto first_fun = make_unique<BoundAggregateExpression>(move(first_aggregate), move(aggr_children),
-				                                                       nullptr, nullptr, AggregateType::NON_DISTINCT);
-				aggr.expressions.push_back(move(first_fun));
+				aggr_children.push_back(std::move(colref));
+				auto first_fun =
+				    make_unique<BoundAggregateExpression>(std::move(first_aggregate), std::move(aggr_children), nullptr,
+				                                          nullptr, AggregateType::NON_DISTINCT);
+				aggr.expressions.push_back(std::move(first_fun));
 			}
 		} else {
 			delim_table_index = aggr.group_index;
@@ -188,8 +189,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			}
 			auto left_index = binder.GenerateTableIndex();
 			auto delim_scan = make_unique<LogicalDelimGet>(left_index, delim_types);
-			join->children.push_back(move(delim_scan));
-			join->children.push_back(move(plan));
+			join->children.push_back(std::move(delim_scan));
+			join->children.push_back(std::move(plan));
 			for (idx_t i = 0; i < new_group_count; i++) {
 				auto &col = correlated_columns[i];
 				JoinCondition cond;
@@ -197,7 +198,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				cond.right = make_unique<BoundColumnRefExpression>(
 				    correlated_columns[i].type, ColumnBinding(delim_table_index, delim_column_offset + i));
 				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-				join->conditions.push_back(move(cond));
+				join->conditions.push_back(std::move(cond));
 			}
 			// for any COUNT aggregate we replace references to the column with: CASE WHEN COUNT(*) IS NULL THEN 0
 			// ELSE COUNT(*) END
@@ -214,7 +215,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			base_binding.table_index = left_index;
 			this->delim_offset = base_binding.column_index = 0;
 			this->data_offset = 0;
-			return move(join);
+			return std::move(join);
 		} else {
 			// update the delim_index
 			base_binding.table_index = delim_table_index;
@@ -230,20 +231,22 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		bool right_has_correlation = has_correlated_expressions.find(plan->children[1].get())->second;
 		if (!right_has_correlation) {
 			// only left has correlation: push into left
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+			plan->children[0] =
+			    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 			return plan;
 		}
 		if (!left_has_correlation) {
 			// only right has correlation: push into right
-			plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
+			plan->children[1] =
+			    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values);
 			return plan;
 		}
 		// both sides have correlation
 		// turn into an inner join
 		auto join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
+		plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values);
 		// add the correlated columns to the join conditions
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
 			JoinCondition cond;
@@ -252,11 +255,11 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			cond.right = make_unique<BoundColumnRefExpression>(
 			    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
 			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			join->conditions.push_back(move(cond));
+			join->conditions.push_back(std::move(cond));
 		}
-		join->children.push_back(move(plan->children[0]));
-		join->children.push_back(move(plan->children[1]));
-		return move(join);
+		join->children.push_back(std::move(plan->children[0]));
+		join->children.push_back(std::move(plan->children[1]));
+		return std::move(join);
 	}
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
@@ -271,13 +274,13 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			if (!right_has_correlation) {
 				// only left has correlation: push into left
 				plan->children[0] =
-				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+				    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 				return plan;
 			}
 			if (!left_has_correlation) {
 				// only right has correlation: push into right
 				plan->children[1] =
-				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
+				    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::LEFT) {
@@ -285,7 +288,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			if (!right_has_correlation) {
 				// only left has correlation: push into left
 				plan->children[0] =
-				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+				    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::RIGHT) {
@@ -293,7 +296,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			if (!left_has_correlation) {
 				// only right has correlation: push into right
 				plan->children[1] =
-				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
+				    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::MARK) {
@@ -301,7 +304,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				throw Exception("MARK join with correlation in RHS not supported");
 			}
 			// push the child into the LHS
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+			plan->children[0] =
+			    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 			// rewrite expressions in the join conditions
 			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 			rewriter.VisitOperator(*plan);
@@ -311,9 +315,9 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		}
 		// both sides have correlation
 		// push into both sides
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
+		plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values);
 		auto right_binding = this->base_binding;
 		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
 		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
@@ -332,19 +336,19 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 
 			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
 				JoinCondition cond;
-				cond.left = move(left);
-				cond.right = move(right);
+				cond.left = std::move(left);
+				cond.right = std::move(right);
 				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 
 				auto &comparison_join = (LogicalComparisonJoin &)join;
-				comparison_join.conditions.push_back(move(cond));
+				comparison_join.conditions.push_back(std::move(cond));
 			} else {
 				auto &any_join = (LogicalAnyJoin &)join;
 				auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-				                                                         move(left), move(right));
-				auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-				                                                           move(comparison), move(any_join.condition));
-				any_join.condition = move(conjunction);
+				                                                         std::move(left), std::move(right));
+				auto conjunction = make_unique<BoundConjunctionExpression>(
+				    ExpressionType::CONJUNCTION_AND, std::move(comparison), std::move(any_join.condition));
+				any_join.condition = std::move(conjunction);
 			}
 		}
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
@@ -364,10 +368,10 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		// check if the direct child of this LIMIT node is an ORDER BY node, if so, keep it separate
 		// this is done for an optimization to avoid having to compute the total order
 		if (plan->children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
-			order_by = unique_ptr_cast<LogicalOperator, LogicalOrder>(move(plan->children[0]));
-			child = PushDownDependentJoinInternal(move(order_by->children[0]), parent_propagate_null_values);
+			order_by = unique_ptr_cast<LogicalOperator, LogicalOrder>(std::move(plan->children[0]));
+			child = PushDownDependentJoinInternal(std::move(order_by->children[0]), parent_propagate_null_values);
 		} else {
-			child = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+			child = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		}
 		auto child_column_count = child->GetColumnBindings().size();
 		// we push a row_number() OVER (PARTITION BY [correlated columns])
@@ -380,18 +384,18 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			auto &col = correlated_columns[i];
 			auto colref = make_unique<BoundColumnRefExpression>(
 			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			row_number->partitions.push_back(move(colref));
+			row_number->partitions.push_back(std::move(colref));
 		}
 		if (order_by) {
 			// optimization: if there is an ORDER BY node followed by a LIMIT
 			// rather than computing the entire order, we push the ORDER BY expressions into the row_num computation
 			// this way, the order only needs to be computed per partition
-			row_number->orders = move(order_by->orders);
+			row_number->orders = std::move(order_by->orders);
 		}
 		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
 		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
-		window->expressions.push_back(move(row_number));
-		window->children.push_back(move(child));
+		window->expressions.push_back(std::move(row_number));
+		window->children.push_back(std::move(child));
 
 		// add a filter based on the row_number
 		// the filter we add is "row_number > offset AND row_number <= offset + limit"
@@ -404,23 +408,23 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		TryAddOperator::Operation(limit.offset_val, limit.limit_val, upper_bound_limit);
 		auto upper_bound = make_unique<BoundConstantExpression>(Value::BIGINT(upper_bound_limit));
 		condition = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                   row_num_ref->Copy(), move(upper_bound));
+		                                                   row_num_ref->Copy(), std::move(upper_bound));
 		// we only need to add "row_number >= offset + 1" if offset is bigger than 0
 		if (limit.offset_val > 0) {
 			auto lower_bound = make_unique<BoundConstantExpression>(Value::BIGINT(limit.offset_val));
 			auto lower_comp = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN,
-			                                                         row_num_ref->Copy(), move(lower_bound));
-			auto conj = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(lower_comp),
-			                                                    move(condition));
-			condition = move(conj);
+			                                                         row_num_ref->Copy(), std::move(lower_bound));
+			auto conj = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(lower_comp),
+			                                                    std::move(condition));
+			condition = std::move(conj);
 		}
-		filter->expressions.push_back(move(condition));
-		filter->children.push_back(move(window));
+		filter->expressions.push_back(std::move(condition));
+		filter->children.push_back(std::move(window));
 		// we prune away the row_number after the filter clause using the projection map
 		for (idx_t i = 0; i < child_column_count; i++) {
 			filter->projection_map.push_back(i);
 		}
-		return move(filter);
+		return std::move(filter);
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
 		// NOTE: limit percent could be supported in a manner similar to the LIMIT above
@@ -431,7 +435,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_WINDOW: {
 		auto &window = (LogicalWindow &)*plan;
 		// push into children
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		// add the correlated columns to the PARTITION BY clauses in the Window
 		for (auto &expr : window.expressions) {
 			D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
@@ -454,8 +458,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		plan->children[1]->ResolveOperatorTypes();
 		D_ASSERT(plan->children[0]->types == plan->children[1]->types);
 #endif
-		plan->children[0] = PushDownDependentJoin(move(plan->children[0]));
-		plan->children[1] = PushDownDependentJoin(move(plan->children[1]));
+		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
+		plan->children[1] = PushDownDependentJoin(std::move(plan->children[1]));
 #ifdef DEBUG
 		D_ASSERT(plan->children[0]->GetColumnBindings().size() == plan->children[1]->GetColumnBindings().size());
 		plan->children[0]->ResolveOperatorTypes();
@@ -471,7 +475,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_DISTINCT: {
 		auto &distinct = (LogicalDistinct &)*plan;
 		// push down into child
-		distinct.children[0] = PushDownDependentJoin(move(distinct.children[0]));
+		distinct.children[0] = PushDownDependentJoin(std::move(distinct.children[0]));
 		// add all correlated columns to the distinct targets
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
 			distinct.distinct_targets.push_back(make_unique<BoundColumnRefExpression>(
@@ -482,7 +486,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		// expression get
 		// first we flatten the dependent join in the child
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
@@ -492,7 +496,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			for (auto &expr_list : expr_get->expressions) {
 				auto colref = make_unique<BoundColumnRefExpression>(
 				    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-				expr_list.push_back(move(colref));
+				expr_list.push_back(std::move(colref));
 			}
 			expr_get->expr_types.push_back(correlated_columns[i].type);
 		}
@@ -503,14 +507,14 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		return plan;
 	}
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		plan->children[0] = PushDownDependentJoin(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
 		return plan;
 	case LogicalOperatorType::LOGICAL_GET: {
 		auto &get = (LogicalGet &)*plan;
 		if (get.children.size() != 1) {
 			throw InternalException("Flatten dependent joins - logical get encountered without children");
 		}
-		plan->children[0] = PushDownDependentJoin(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
 		for (idx_t i = 0; i < (perform_delim ? correlated_columns.size() : 1); i++) {
 			get.projected_input.push_back(this->delim_offset + i);
 		}
@@ -524,6 +528,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		throw BinderException("Nested lateral joins or lateral joins in correlated subqueries are not (yet) supported");
 	}
+	case LogicalOperatorType::LOGICAL_SAMPLE:
+		throw BinderException("Sampling in correlated subqueries is not (yet) supported");
 	default:
 		throw InternalException("Logical operator type \"%s\" for dependent join", LogicalOperatorToString(plan->type));
 	}

package/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp

@@ -105,10 +105,11 @@ unique_ptr<Expression> RewriteCountAggregates::VisitReplace(BoundColumnRefExpres
 		// replace this with CASE WHEN COUNT(*) IS NULL THEN 0 ELSE COUNT(*) END
 		auto is_null = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
 		is_null->children.push_back(expr.Copy());
-		auto check = move(is_null);
+		auto check = std::move(is_null);
 		auto result_if_true = make_unique<BoundConstantExpression>(Value::Numeric(expr.return_type, 0));
-		auto result_if_false = move(*expr_ptr);
-		return make_unique<BoundCaseExpression>(move(check), move(result_if_true), move(result_if_false));
+		auto result_if_false = std::move(*expr_ptr);
+		return make_unique<BoundCaseExpression>(std::move(check), std::move(result_if_true),
+		                                        std::move(result_if_false));
 	}
 	return nullptr;
 }

package/src/duckdb/src/planner/table_binding.cpp

@@ -8,13 +8,16 @@
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 
+#include <algorithm>
+
 namespace duckdb {
 
 Binding::Binding(BindingType binding_type, const string &alias, vector<LogicalType> coltypes, vector<string> colnames,
                  idx_t index)
-    : binding_type(binding_type), alias(alias), index(index), types(move(coltypes)), names(move(colnames)) {
+    : binding_type(binding_type), alias(alias), index(index), types(std::move(coltypes)), names(std::move(colnames)) {
 	D_ASSERT(types.size() == names.size());
 	for (idx_t i = 0; i < names.size(); i++) {
 		auto &name = names[i];
@@ -76,7 +79,7 @@ StandardEntry *Binding::GetStandardEntry() {
 
 EntryBinding::EntryBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p, idx_t index,
                            StandardEntry &entry)
-    : Binding(BindingType::CATALOG_ENTRY, alias, move(types_p), move(names_p), index), entry(entry) {
+    : Binding(BindingType::CATALOG_ENTRY, alias, std::move(types_p), std::move(names_p), index), entry(entry) {
 }
 
 StandardEntry *EntryBinding::GetStandardEntry() {
@@ -85,8 +88,8 @@ StandardEntry *EntryBinding::GetStandardEntry() {
 
 TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p,
                            vector<column_t> &bound_column_ids, StandardEntry *entry, idx_t index, bool add_row_id)
-    : Binding(BindingType::TABLE, alias, move(types_p), move(names_p), index), bound_column_ids(bound_column_ids),
-      entry(entry) {
+    : Binding(BindingType::TABLE, alias, std::move(types_p), std::move(names_p), index),
+      bound_column_ids(bound_column_ids), entry(entry) {
 	if (add_row_id) {
 		if (name_map.find("rowid") == name_map.end()) {
 			name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
@@ -129,18 +132,53 @@ unique_ptr<ParsedExpression> TableBinding::ExpandGeneratedColumn(const string &c
 
 	// Get the index of the generated column
 	auto column_index = GetBindingIndex(column_name);
-	D_ASSERT(table_entry->columns.GetColumn(LogicalIndex(column_index)).Generated());
+	D_ASSERT(table_entry->GetColumn(LogicalIndex(column_index)).Generated());
 	// Get a copy of the generated column
-	auto expression = table_entry->columns.GetColumn(LogicalIndex(column_index)).GeneratedExpression().Copy();
+	auto expression = table_entry->GetColumn(LogicalIndex(column_index)).GeneratedExpression().Copy();
 	unordered_map<idx_t, string> alias_map;
 	for (auto &entry : name_map) {
 		alias_map[entry.second] = entry.first;
 	}
-	ReplaceAliases(*expression, table_entry->columns, alias_map);
+	ReplaceAliases(*expression, table_entry->GetColumns(), alias_map);
 	BakeTableName(*expression, alias);
 	return (expression);
 }
 
+const vector<column_t> &TableBinding::GetBoundColumnIds() const {
+#ifdef DEBUG
+	unordered_set<column_t> column_ids;
+	for (auto &id : bound_column_ids) {
+		auto result = column_ids.insert(id);
+		// assert that all entries in the bound_column_ids are unique
+		D_ASSERT(result.second);
+		auto it = std::find_if(name_map.begin(), name_map.end(),
+		                       [&](const std::pair<const string, column_t> &it) { return it.second == id; });
+		// assert that every id appears in the name_map
+		D_ASSERT(it != name_map.end());
+		// the order that they appear in is not guaranteed to be sequential
+	}
+#endif
+	return bound_column_ids;
+}
+
+ColumnBinding TableBinding::GetColumnBinding(column_t column_index) {
+	auto &column_ids = bound_column_ids;
+	ColumnBinding binding;
+
+	// Locate the column_id that matches the 'column_index'
+	auto it = std::find_if(column_ids.begin(), column_ids.end(),
+	                       [&](const column_t &id) -> bool { return id == column_index; });
+	// Get the index of it
+	binding.column_index = std::distance(column_ids.begin(), it);
+	// If it wasn't found, add it
+	if (it == column_ids.end()) {
+		column_ids.push_back(column_index);
+	}
+
+	binding.table_index = index;
+	return binding;
+}
+
 BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	auto &column_name = colref.GetColumnName();
 	column_t column_index;
@@ -154,7 +192,7 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
 		// Either there is no table, or the columns category has to be standard
 		auto table_entry = (TableCatalogEntry *)entry;
-		auto &column_entry = table_entry->columns.GetColumn(LogicalIndex(column_index));
+		auto &column_entry = table_entry->GetColumn(LogicalIndex(column_index));
 		(void)table_entry;
 		(void)column_entry;
 		D_ASSERT(column_entry.Category() == TableColumnType::STANDARD);
@@ -171,23 +209,7 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 			colref.alias = names[column_index];
 		}
 	}
-
-	auto &column_ids = bound_column_ids;
-	// check if the entry already exists in the column list for the table
-	ColumnBinding binding;
-
-	binding.column_index = column_ids.size();
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		if (column_ids[i] == column_index) {
-			binding.column_index = i;
-			break;
-		}
-	}
-	if (binding.column_index == column_ids.size()) {
-		// column binding not found: add it to the list of bindings
-		column_ids.push_back(column_index);
-	}
-	binding.table_index = index;
+	ColumnBinding binding = GetColumnBinding(column_index);
 	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), col_type, binding, depth));
 }
 
@@ -200,8 +222,9 @@ string TableBinding::ColumnNotFoundError(const string &column_name) const {
 }
 
 DummyBinding::DummyBinding(vector<LogicalType> types_p, vector<string> names_p, string dummy_name_p)
-    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name_p, move(types_p), move(names_p), -1),
-      dummy_name(move(dummy_name_p)) {
+    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name_p, std::move(types_p), std::move(names_p),
+              DConstants::INVALID_INDEX),
+      dummy_name(std::move(dummy_name_p)) {
 }
 
 BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
@@ -209,14 +232,22 @@ BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
 		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
 	}
-	ColumnBinding binding;
-	binding.table_index = index;
-	binding.column_index = column_index;
+	ColumnBinding binding(index, column_index);
 
 	// we are binding a parameter to create the dummy binding, no arguments are supplied
 	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), types[column_index], binding, depth));
 }
 
+BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t lambda_index, idx_t depth) {
+	column_t column_index;
+	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
+		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
+	}
+	ColumnBinding binding(index, column_index);
+	return BindResult(
+	    make_unique<BoundLambdaRefExpression>(colref.GetName(), types[column_index], binding, lambda_index, depth));
+}
+
 unique_ptr<ParsedExpression> DummyBinding::ParamToArg(ColumnRefExpression &colref) {
 	column_t column_index;
 	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {

package/src/duckdb/src/planner/table_filter.cpp

@@ -10,17 +10,17 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	auto entry = filters.find(column_index);
 	if (entry == filters.end()) {
 		// no filter yet: push the filter directly
-		filters[column_index] = move(filter);
+		filters[column_index] = std::move(filter);
 	} else {
 		// there is already a filter: AND it together
 		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
 			auto &and_filter = (ConjunctionAndFilter &)*entry->second;
-			and_filter.child_filters.push_back(move(filter));
+			and_filter.child_filters.push_back(std::move(filter));
 		} else {
 			auto and_filter = make_unique<ConjunctionAndFilter>();
-			and_filter->child_filters.push_back(move(entry->second));
-			and_filter->child_filters.push_back(move(filter));
-			filters[column_index] = move(and_filter);
+			and_filter->child_filters.push_back(std::move(entry->second));
+			and_filter->child_filters.push_back(std::move(filter));
+			filters[column_index] = std::move(and_filter);
 		}
 	}
 }
@@ -41,7 +41,7 @@ unique_ptr<TableFilterSet> TableFilterSet::Deserialize(Deserializer &source) {
 	for (idx_t i = 0; i < len; i++) {
 		auto key = source.Read<idx_t>();
 		auto value = TableFilter::Deserialize(source);
-		res->filters[key] = move(value);
+		res->filters[key] = std::move(value);
 	}
 	return res;
 }