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

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

@@ -10,8 +10,8 @@ namespace duckdb {
 
 BoundCastExpression::BoundCastExpression(unique_ptr<Expression> child_p, LogicalType target_type_p,
                                          BoundCastInfo bound_cast_p, bool try_cast_p)
-    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, move(target_type_p)), child(move(child_p)),
-      try_cast(try_cast_p), bound_cast(move(bound_cast_p)) {
+    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
+      child(std::move(child_p)), try_cast(try_cast_p), bound_cast(std::move(bound_cast_p)) {
 }
 
 unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
@@ -27,7 +27,7 @@ unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, co
 			return expr;
 		}
 	}
-	return make_unique<BoundCastExpression>(move(expr), target_type, move(bound_cast), try_cast);
+	return make_unique<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
 }
 
 static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
@@ -79,21 +79,21 @@ unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const
 	}
 
 	auto cast_function = cast_functions.GetCastFunction(expr->return_type, target_type, get_input);
-	return AddCastExpressionInternal(move(expr), target_type, move(cast_function), try_cast);
+	return AddCastExpressionInternal(std::move(expr), target_type, std::move(cast_function), try_cast);
 }
 
 unique_ptr<Expression> BoundCastExpression::AddDefaultCastToType(unique_ptr<Expression> expr,
                                                                  const LogicalType &target_type, bool try_cast) {
 	CastFunctionSet default_set;
 	GetCastFunctionInput get_input;
-	return AddCastToTypeInternal(move(expr), target_type, default_set, get_input, try_cast);
+	return AddCastToTypeInternal(std::move(expr), target_type, default_set, get_input, try_cast);
 }
 
 unique_ptr<Expression> BoundCastExpression::AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
                                                           const LogicalType &target_type, bool try_cast) {
 	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
 	GetCastFunctionInput get_input(context);
-	return AddCastToTypeInternal(move(expr), target_type, cast_functions, get_input, try_cast);
+	return AddCastToTypeInternal(std::move(expr), target_type, cast_functions, get_input, try_cast);
 }
 
 bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type) {
@@ -186,7 +186,7 @@ bool BoundCastExpression::Equals(const BaseExpression *other_p) const {
 unique_ptr<Expression> BoundCastExpression::Copy() {
 	auto copy = make_unique<BoundCastExpression>(child->Copy(), return_type, bound_cast.Copy(), try_cast);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundCastExpression::Serialize(FieldWriter &writer) const {
@@ -200,7 +200,8 @@ unique_ptr<Expression> BoundCastExpression::Deserialize(ExpressionDeserializatio
 	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto try_cast = reader.ReadRequired<bool>();
 	auto cast_function = BindCastFunction(state.gstate.context, child->return_type, target_type);
-	return make_unique<BoundCastExpression>(move(child), move(target_type), move(cast_function), try_cast);
+	return make_unique<BoundCastExpression>(std::move(child), std::move(target_type), std::move(cast_function),
+	                                        try_cast);
 }
 
 } // namespace duckdb

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

@@ -7,13 +7,13 @@
 namespace duckdb {
 
 BoundColumnRefExpression::BoundColumnRefExpression(string alias_p, LogicalType type, ColumnBinding binding, idx_t depth)
-    : Expression(ExpressionType::BOUND_COLUMN_REF, ExpressionClass::BOUND_COLUMN_REF, move(type)), binding(binding),
-      depth(depth) {
-	this->alias = move(alias_p);
+    : Expression(ExpressionType::BOUND_COLUMN_REF, ExpressionClass::BOUND_COLUMN_REF, std::move(type)),
+      binding(binding), depth(depth) {
+	this->alias = std::move(alias_p);
 }
 
 BoundColumnRefExpression::BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth)
-    : BoundColumnRefExpression(string(), move(type), binding, depth) {
+    : BoundColumnRefExpression(string(), std::move(type), binding, depth) {
 }
 
 unique_ptr<Expression> BoundColumnRefExpression::Copy() {

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

@@ -6,7 +6,8 @@ namespace duckdb {
 
 BoundComparisonExpression::BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left,
                                                      unique_ptr<Expression> right)
-    : Expression(type, ExpressionClass::BOUND_COMPARISON, LogicalType::BOOLEAN), left(move(left)), right(move(right)) {
+    : Expression(type, ExpressionClass::BOUND_COMPARISON, LogicalType::BOOLEAN), left(std::move(left)),
+      right(std::move(right)) {
 }
 
 string BoundComparisonExpression::ToString() const {
@@ -31,7 +32,7 @@ bool BoundComparisonExpression::Equals(const BaseExpression *other_p) const {
 unique_ptr<Expression> BoundComparisonExpression::Copy() {
 	auto copy = make_unique<BoundComparisonExpression>(type, left->Copy(), right->Copy());
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundComparisonExpression::Serialize(FieldWriter &writer) const {
@@ -43,7 +44,7 @@ unique_ptr<Expression> BoundComparisonExpression::Deserialize(ExpressionDeserial
                                                               FieldReader &reader) {
 	auto left = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	auto right = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_unique<BoundComparisonExpression>(state.type, move(left), move(right));
+	return make_unique<BoundComparisonExpression>(state.type, std::move(left), std::move(right));
 }
 
 } // namespace duckdb

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

@@ -12,8 +12,8 @@ BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type)
 BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left,
                                                        unique_ptr<Expression> right)
     : BoundConjunctionExpression(type) {
-	children.push_back(move(left));
-	children.push_back(move(right));
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 }
 
 string BoundConjunctionExpression::ToString() const {
@@ -38,7 +38,7 @@ unique_ptr<Expression> BoundConjunctionExpression::Copy() {
 		copy->children.push_back(expr->Copy());
 	}
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundConjunctionExpression::Serialize(FieldWriter &writer) const {
@@ -49,8 +49,8 @@ unique_ptr<Expression> BoundConjunctionExpression::Deserialize(ExpressionDeseria
                                                                FieldReader &reader) {
 	auto children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	auto res = make_unique<BoundConjunctionExpression>(state.type);
-	res->children = move(children);
-	return move(res);
+	res->children = std::move(children);
+	return std::move(res);
 }
 
 } // namespace duckdb

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

@@ -7,7 +7,7 @@ namespace duckdb {
 
 BoundConstantExpression::BoundConstantExpression(Value value_p)
     : Expression(ExpressionType::VALUE_CONSTANT, ExpressionClass::BOUND_CONSTANT, value_p.type()),
-      value(move(value_p)) {
+      value(std::move(value_p)) {
 }
 
 string BoundConstantExpression::ToString() const {
@@ -30,7 +30,7 @@ hash_t BoundConstantExpression::Hash() const {
 unique_ptr<Expression> BoundConstantExpression::Copy() {
 	auto copy = make_unique<BoundConstantExpression>(value);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundConstantExpression::Serialize(FieldWriter &writer) const {

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 BoundExpression::BoundExpression(unique_ptr<Expression> expr)
-    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(move(expr)) {
+    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr)) {
 }
 
 string BoundExpression::ToString() const {

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

@@ -10,8 +10,9 @@ namespace duckdb {
 BoundFunctionExpression::BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
                                                  vector<unique_ptr<Expression>> arguments,
                                                  unique_ptr<FunctionData> bind_info, bool is_operator)
-    : Expression(ExpressionType::BOUND_FUNCTION, ExpressionClass::BOUND_FUNCTION, move(return_type)),
-      function(move(bound_function)), children(move(arguments)), bind_info(move(bind_info)), is_operator(is_operator) {
+    : Expression(ExpressionType::BOUND_FUNCTION, ExpressionClass::BOUND_FUNCTION, std::move(return_type)),
+      function(std::move(bound_function)), children(std::move(arguments)), bind_info(std::move(bind_info)),
+      is_operator(is_operator) {
 	D_ASSERT(!function.name.empty());
 }
 
@@ -63,10 +64,10 @@ unique_ptr<Expression> BoundFunctionExpression::Copy() {
 	}
 	unique_ptr<FunctionData> new_bind_info = bind_info ? bind_info->Copy() : nullptr;
 
-	auto copy = make_unique<BoundFunctionExpression>(return_type, function, move(new_children), move(new_bind_info),
-	                                                 is_operator);
+	auto copy = make_unique<BoundFunctionExpression>(return_type, function, std::move(new_children),
+	                                                 std::move(new_bind_info), is_operator);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundFunctionExpression::Verify() const {
@@ -89,7 +90,7 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(ExpressionDeserializ
 	    reader, state, CatalogType::SCALAR_FUNCTION_ENTRY, children, bind_info);
 
 	auto return_type = function.return_type;
-	return make_unique<BoundFunctionExpression>(move(return_type), move(function), move(children), move(bind_info),
-	                                            is_operator);
+	return make_unique<BoundFunctionExpression>(std::move(return_type), std::move(function), std::move(children),
+	                                            std::move(bind_info), is_operator);
 }
 } // namespace duckdb

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

@@ -6,8 +6,8 @@ namespace duckdb {
 
 BoundLambdaExpression::BoundLambdaExpression(ExpressionType type_p, LogicalType return_type_p,
                                              unique_ptr<Expression> lambda_expr_p, idx_t parameter_count_p)
-    : Expression(type_p, ExpressionClass::BOUND_LAMBDA, move(return_type_p)), lambda_expr(move(lambda_expr_p)),
-      parameter_count(parameter_count_p) {
+    : Expression(type_p, ExpressionClass::BOUND_LAMBDA, std::move(return_type_p)),
+      lambda_expr(std::move(lambda_expr_p)), parameter_count(parameter_count_p) {
 }
 
 string BoundLambdaExpression::ToString() const {
@@ -36,7 +36,7 @@ unique_ptr<Expression> BoundLambdaExpression::Copy() {
 	for (auto &capture : captures) {
 		copy->captures.push_back(capture->Copy());
 	}
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundLambdaExpression::Serialize(FieldWriter &writer) const {

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

@@ -0,0 +1,71 @@
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
+
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/common/to_string.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+BoundLambdaRefExpression::BoundLambdaRefExpression(string alias_p, LogicalType type, ColumnBinding binding,
+                                                   idx_t lambda_index, idx_t depth)
+    : Expression(ExpressionType::BOUND_LAMBDA_REF, ExpressionClass::BOUND_LAMBDA_REF, std::move(type)),
+      binding(binding), lambda_index(lambda_index), depth(depth) {
+	this->alias = std::move(alias_p);
+}
+
+BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index,
+                                                   idx_t depth)
+    : BoundLambdaRefExpression(string(), std::move(type), binding, lambda_index, depth) {
+}
+
+unique_ptr<Expression> BoundLambdaRefExpression::Copy() {
+	return make_unique<BoundLambdaRefExpression>(alias, return_type, binding, lambda_index, depth);
+}
+
+hash_t BoundLambdaRefExpression::Hash() const {
+	auto result = Expression::Hash();
+	result = CombineHash(result, duckdb::Hash<uint64_t>(lambda_index));
+	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
+	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
+	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
+}
+
+bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
+	if (!Expression::Equals(other_p)) {
+		return false;
+	}
+	auto other = (BoundLambdaRefExpression *)other_p;
+	return other->binding == binding && other->lambda_index == lambda_index && other->depth == depth;
+}
+
+string BoundLambdaRefExpression::ToString() const {
+	if (!alias.empty()) {
+		return alias;
+	}
+	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "." +
+	       to_string(lambda_index) + "]";
+}
+
+void BoundLambdaRefExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteString(alias);
+	writer.WriteSerializable(return_type);
+	writer.WriteField(lambda_index);
+	writer.WriteField(binding.table_index);
+	writer.WriteField(binding.column_index);
+	writer.WriteField(depth);
+}
+
+unique_ptr<Expression> BoundLambdaRefExpression::Deserialize(ExpressionDeserializationState &state,
+                                                             FieldReader &reader) {
+	auto alias = reader.ReadRequired<string>();
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto lambda_index = reader.ReadRequired<idx_t>();
+	auto table_index = reader.ReadRequired<idx_t>();
+	auto column_index = reader.ReadRequired<idx_t>();
+	auto depth = reader.ReadRequired<idx_t>();
+
+	return make_unique<BoundLambdaRefExpression>(alias, return_type, ColumnBinding(table_index, column_index),
+	                                             lambda_index, depth);
+}
+
+} // namespace duckdb

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

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 BoundOperatorExpression::BoundOperatorExpression(ExpressionType type, LogicalType return_type)
-    : Expression(type, ExpressionClass::BOUND_OPERATOR, move(return_type)) {
+    : Expression(type, ExpressionClass::BOUND_OPERATOR, std::move(return_type)) {
 }
 
 string BoundOperatorExpression::ToString() const {
@@ -31,7 +31,7 @@ unique_ptr<Expression> BoundOperatorExpression::Copy() {
 	for (auto &child : children) {
 		copy->children.push_back(child->Copy());
 	}
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundOperatorExpression::Serialize(FieldWriter &writer) const {
@@ -45,8 +45,8 @@ unique_ptr<Expression> BoundOperatorExpression::Deserialize(ExpressionDeserializ
 	auto children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
 	auto result = make_unique<BoundOperatorExpression>(state.type, return_type);
-	result->children = move(children);
-	return move(result);
+	result->children = std::move(children);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -62,7 +62,7 @@ unique_ptr<Expression> BoundParameterExpression::Copy() {
 	result->parameter_data = parameter_data;
 	result->return_type = return_type;
 	result->CopyProperties(*this);
-	return move(result);
+	return std::move(result);
 }
 
 void BoundParameterExpression::Serialize(FieldWriter &writer) const {
@@ -87,8 +87,8 @@ unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeseriali
 		// we have! use the previously deserialized entry
 		parameter_data = entry->second;
 	}
-	result->parameter_data = move(parameter_data);
-	return move(result);
+	result->parameter_data = std::move(parameter_data);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -8,11 +8,11 @@
 namespace duckdb {
 
 BoundReferenceExpression::BoundReferenceExpression(string alias, LogicalType type, idx_t index)
-    : Expression(ExpressionType::BOUND_REF, ExpressionClass::BOUND_REF, move(type)), index(index) {
-	this->alias = move(alias);
+    : Expression(ExpressionType::BOUND_REF, ExpressionClass::BOUND_REF, std::move(type)), index(index) {
+	this->alias = std::move(alias);
 }
 BoundReferenceExpression::BoundReferenceExpression(LogicalType type, idx_t index)
-    : BoundReferenceExpression(string(), move(type), index) {
+    : BoundReferenceExpression(string(), std::move(type), index) {
 }
 
 string BoundReferenceExpression::ToString() const {

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

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 BoundSubqueryExpression::BoundSubqueryExpression(LogicalType return_type)
-    : Expression(ExpressionType::SUBQUERY, ExpressionClass::BOUND_SUBQUERY, move(return_type)) {
+    : Expression(ExpressionType::SUBQUERY, ExpressionClass::BOUND_SUBQUERY, std::move(return_type)) {
 }
 
 string BoundSubqueryExpression::ToString() const {

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

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 BoundUnnestExpression::BoundUnnestExpression(LogicalType return_type)
-    : Expression(ExpressionType::BOUND_UNNEST, ExpressionClass::BOUND_UNNEST, move(return_type)) {
+    : Expression(ExpressionType::BOUND_UNNEST, ExpressionClass::BOUND_UNNEST, std::move(return_type)) {
 }
 
 bool BoundUnnestExpression::IsFoldable() const {
@@ -37,7 +37,7 @@ bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
 unique_ptr<Expression> BoundUnnestExpression::Copy() {
 	auto copy = make_unique<BoundUnnestExpression>(return_type);
 	copy->child = child->Copy();
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundUnnestExpression::Serialize(FieldWriter &writer) const {
@@ -50,8 +50,8 @@ unique_ptr<Expression> BoundUnnestExpression::Deserialize(ExpressionDeserializat
 	auto child = reader.ReadRequiredSerializable<Expression>(state.gstate);
 
 	auto result = make_unique<BoundUnnestExpression>(return_type);
-	result->child = move(child);
-	return move(result);
+	result->child = std::move(child);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -11,8 +11,8 @@ namespace duckdb {
 BoundWindowExpression::BoundWindowExpression(ExpressionType type, LogicalType return_type,
                                              unique_ptr<AggregateFunction> aggregate,
                                              unique_ptr<FunctionData> bind_info)
-    : Expression(type, ExpressionClass::BOUND_WINDOW, move(return_type)), aggregate(move(aggregate)),
-      bind_info(move(bind_info)), ignore_nulls(false) {
+    : Expression(type, ExpressionClass::BOUND_WINDOW, std::move(return_type)), aggregate(std::move(aggregate)),
+      bind_info(std::move(bind_info)), ignore_nulls(false) {
 }
 
 string BoundWindowExpression::ToString() const {
@@ -121,7 +121,7 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
 	new_window->ignore_nulls = ignore_nulls;
 
-	return move(new_window);
+	return std::move(new_window);
 }
 
 void BoundWindowExpression::Serialize(FieldWriter &writer) const {
@@ -156,13 +156,14 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 	if (has_aggregate) {
 		auto aggr_function = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
 		    reader, state, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, bind_info);
-		aggregate = make_unique<AggregateFunction>(move(aggr_function));
+		aggregate = make_unique<AggregateFunction>(std::move(aggr_function));
 		return_type = aggregate->return_type;
 	} else {
 		children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 		return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	}
-	auto result = make_unique<BoundWindowExpression>(state.type, return_type, move(aggregate), move(bind_info));
+	auto result =
+	    make_unique<BoundWindowExpression>(state.type, return_type, std::move(aggregate), std::move(bind_info));
 
 	result->partitions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	result->orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
@@ -174,8 +175,8 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 	result->end_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	result->offset_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	result->default_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->children = move(children);
-	return move(result);
+	result->children = std::move(children);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -10,7 +10,7 @@
 namespace duckdb {
 
 Expression::Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type)
-    : BaseExpression(type, expression_class), return_type(move(return_type)) {
+    : BaseExpression(type, expression_class), return_type(std::move(return_type)) {
 }
 
 Expression::~Expression() {

package/src/duckdb/src/planner/expression_binder/alter_binder.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table,
                          vector<LogicalIndex> &bound_columns, LogicalType target_type)
     : ExpressionBinder(binder, context), table(table), bound_columns(bound_columns) {
-	this->target_type = move(target_type);
+	this->target_type = std::move(target_type);
 }
 
 BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
@@ -39,12 +39,11 @@ BindResult AlterBinder::BindColumn(ColumnRefExpression &colref) {
 		throw BinderException("Table does not contain column %s referenced in alter statement!",
 		                      colref.column_names[0]);
 	}
-	if (table.columns.GetColumn(LogicalIndex(idx)).Generated()) {
+	if (table.GetColumn(idx).Generated()) {
 		throw BinderException("Using generated columns in alter statement not supported");
 	}
 	bound_columns.push_back(idx);
-	return BindResult(
-	    make_unique<BoundReferenceExpression>(table.columns.GetColumn(idx).Type(), bound_columns.size() - 1));
+	return BindResult(make_unique<BoundReferenceExpression>(table.GetColumn(idx).Type(), bound_columns.size() - 1));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/check_binder.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/planner/expression_binder/check_binder.hpp"
 
+#include "duckdb/planner/table_binding.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 
@@ -7,7 +8,7 @@ namespace duckdb {
 
 CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p, const ColumnList &columns,
                          physical_index_set_t &bound_columns)
-    : ExpressionBinder(binder, context), table(move(table_p)), columns(columns), bound_columns(bound_columns) {
+    : ExpressionBinder(binder, context), table(std::move(table_p)), columns(columns), bound_columns(bound_columns) {
 	target_type = LogicalType::INTEGER;
 }
 
@@ -36,12 +37,25 @@ BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref
 	}
 	auto result = make_unique_base<ParsedExpression, ColumnRefExpression>(colref.column_names.back());
 	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
-		result = CreateStructExtract(move(result), colref.column_names[i]);
+		result = CreateStructExtract(std::move(result), colref.column_names[i]);
 	}
 	return BindExpression(&result, 0);
 }
 
 BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
+
+	// if this is a lambda parameters, then we temporarily add a BoundLambdaRef,
+	// which we capture and remove later
+	if (lambda_bindings) {
+		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
+			if (colref.GetColumnName() == (*lambda_bindings)[i].dummy_name) {
+				// FIXME: support lambdas in CHECK constraints
+				// FIXME: like so: return (*lambda_bindings)[i].Bind(colref, i, depth);
+				throw NotImplementedException("Lambda functions are currently not supported in CHECK constraints.");
+			}
+		}
+	}
+
 	if (colref.column_names.size() > 1) {
 		return BindQualifiedColumnName(colref, table);
 	}

package/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp

@@ -3,11 +3,13 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
 ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map)
-    : node(node), alias_map(alias_map), in_alias(false) {
+    : node(node), alias_map(alias_map), visited_select_indexes() {
 }
 
 BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
@@ -21,18 +23,18 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
 	}
 
-	if (in_alias) {
+	if (visited_select_indexes.find(alias_entry->second) != visited_select_indexes.end()) {
 		return BindResult("Cannot resolve self-referential alias");
 	}
 
 	// found an alias: bind the alias expression
 	auto expression = node.original_expressions[alias_entry->second]->Copy();
-	in_alias = true;
+	visited_select_indexes.insert(alias_entry->second);
 
 	// since the alias has been found, pass a depth of 0. See Issue 4978 (#16)
 	// ColumnAliasBinders are only in Having, Qualify and Where Binders
 	auto result = enclosing_binder.BindExpression(&expression, 0, root_expression);
-	in_alias = false;
+	visited_select_indexes.erase(alias_entry->second);
 	return result;
 }
 

package/src/duckdb/src/planner/expression_binder/constant_binder.cpp

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
-    : ExpressionBinder(binder, context), clause(move(clause)) {
+    : ExpressionBinder(binder, context), clause(std::move(clause)) {
 }
 
 BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {

package/src/duckdb/src/planner/expression_binder/group_binder.cpp

@@ -57,14 +57,14 @@ BindResult GroupBinder::BindSelectRef(idx_t entry) {
 	// we replace the root expression, also replace the unbound expression
 	unbound_expression = node.select_list[entry]->Copy();
 	// move the expression that this refers to here and bind it
-	auto select_entry = move(node.select_list[entry]);
+	auto select_entry = std::move(node.select_list[entry]);
 	auto binding = Bind(select_entry, nullptr, false);
 	// now replace the original expression in the select list with a reference to this group
 	group_alias_map[to_string(entry)] = bind_index;
 	node.select_list[entry] = make_unique<ColumnRefExpression>(to_string(entry));
 	// insert into the set of used aliases
 	used_aliases.insert(entry);
-	return BindResult(move(binding));
+	return BindResult(std::move(binding));
 }
 
 BindResult GroupBinder::BindConstant(ConstantExpression &constant) {

package/src/duckdb/src/planner/expression_binder/having_binder.cpp

@@ -22,14 +22,17 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 		return alias_result;
 	}
 	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+		if (depth > 0) {
+			throw BinderException("Having clause cannot reference column in correlated subquery and group by all");
+		}
 		auto expr = duckdb::SelectBinder::BindExpression(expr_ptr, depth);
 		if (expr.HasError()) {
 			return expr;
 		}
 		auto group_ref = make_unique<BoundColumnRefExpression>(
 		    expr.expression->return_type, ColumnBinding(node.group_index, node.groups.group_expressions.size()));
-		node.groups.group_expressions.push_back(move(expr.expression));
-		return BindResult(move(group_ref));
+		node.groups.group_expressions.push_back(std::move(expr.expression));
+		return BindResult(std::move(group_ref));
 	}
 	return BindResult(StringUtil::Format(
 	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -16,7 +16,7 @@ void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
 			// add the correlated column info
 			CorrelatedColumnInfo info(bound_colref);
 			if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-				correlated_columns.push_back(move(info));
+				correlated_columns.push_back(std::move(info));
 			}
 		}
 	}