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

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -8,14 +8,14 @@ namespace duckdb {
 
 ComparisonExpression::ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
                                            unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::COMPARISON), left(move(left)), right(move(right)) {
+    : ParsedExpression(type, ExpressionClass::COMPARISON), left(std::move(left)), right(std::move(right)) {
 }
 
 string ComparisonExpression::ToString() const {
 	return ToString<ComparisonExpression, ParsedExpression>(*this);
 }
 
-bool ComparisonExpression::Equals(const ComparisonExpression *a, const ComparisonExpression *b) {
+bool ComparisonExpression::Equal(const ComparisonExpression *a, const ComparisonExpression *b) {
 	if (!a->left->Equals(b->left.get())) {
 		return false;
 	}
@@ -28,7 +28,7 @@ bool ComparisonExpression::Equals(const ComparisonExpression *a, const Compariso
 unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
 	auto copy = make_unique<ComparisonExpression>(type, left->Copy(), right->Copy());
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void ComparisonExpression::Serialize(FieldWriter &writer) const {
@@ -39,7 +39,7 @@ void ComparisonExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto left_child = reader.ReadRequiredSerializable<ParsedExpression>();
 	auto right_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<ComparisonExpression>(type, move(left_child), move(right_child));
+	return make_unique<ComparisonExpression>(type, std::move(left_child), std::move(right_child));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -12,15 +12,15 @@ ConjunctionExpression::ConjunctionExpression(ExpressionType type)
 ConjunctionExpression::ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
     : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
 	for (auto &child : children) {
-		AddExpression(move(child));
+		AddExpression(std::move(child));
 	}
 }
 
 ConjunctionExpression::ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
                                              unique_ptr<ParsedExpression> right)
     : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-	AddExpression(move(left));
-	AddExpression(move(right));
+	AddExpression(std::move(left));
+	AddExpression(std::move(right));
 }
 
 void ConjunctionExpression::AddExpression(unique_ptr<ParsedExpression> expr) {
@@ -28,10 +28,10 @@ void ConjunctionExpression::AddExpression(unique_ptr<ParsedExpression> expr) {
 		// expr is a conjunction of the same type: merge the expression lists together
 		auto &other = (ConjunctionExpression &)*expr;
 		for (auto &child : other.children) {
-			children.push_back(move(child));
+			children.push_back(std::move(child));
 		}
 	} else {
-		children.push_back(move(expr));
+		children.push_back(std::move(expr));
 	}
 }
 
@@ -39,7 +39,7 @@ string ConjunctionExpression::ToString() const {
 	return ToString<ConjunctionExpression, ParsedExpression>(*this);
 }
 
-bool ConjunctionExpression::Equals(const ConjunctionExpression *a, const ConjunctionExpression *b) {
+bool ConjunctionExpression::Equal(const ConjunctionExpression *a, const ConjunctionExpression *b) {
 	return ExpressionUtil::SetEquals(a->children, b->children);
 }
 
@@ -48,9 +48,9 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
 	for (auto &expr : children) {
 		copy_children.push_back(expr->Copy());
 	}
-	auto copy = make_unique<ConjunctionExpression>(type, move(copy_children));
+	auto copy = make_unique<ConjunctionExpression>(type, std::move(copy_children));
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void ConjunctionExpression::Serialize(FieldWriter &writer) const {
@@ -60,7 +60,7 @@ void ConjunctionExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto result = make_unique<ConjunctionExpression>(type);
 	result->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -8,14 +8,14 @@
 namespace duckdb {
 
 ConstantExpression::ConstantExpression(Value val)
-    : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT), value(move(val)) {
+    : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT), value(std::move(val)) {
 }
 
 string ConstantExpression::ToString() const {
 	return value.ToSQLString();
 }
 
-bool ConstantExpression::Equals(const ConstantExpression *a, const ConstantExpression *b) {
+bool ConstantExpression::Equal(const ConstantExpression *a, const ConstantExpression *b) {
 	return a->value.type() == b->value.type() && !ValueOperations::DistinctFrom(a->value, b->value);
 }
 
@@ -26,7 +26,7 @@ hash_t ConstantExpression::Hash() const {
 unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
 	auto copy = make_unique<ConstantExpression>(value);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void ConstantExpression::Serialize(FieldWriter &writer) const {
@@ -35,7 +35,7 @@ void ConstantExpression::Serialize(FieldWriter &writer) const {
 
 unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	Value value = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique<ConstantExpression>(move(value));
+	return make_unique<ConstantExpression>(std::move(value));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/default_expression.cpp

@@ -14,7 +14,7 @@ string DefaultExpression::ToString() const {
 unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
 	auto copy = make_unique<DefaultExpression>();
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void DefaultExpression::Serialize(FieldWriter &writer) const {

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -12,9 +12,9 @@ FunctionExpression::FunctionExpression(string catalog, string schema, const stri
                                        vector<unique_ptr<ParsedExpression>> children_p,
                                        unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys_p,
                                        bool distinct, bool is_operator, bool export_state_p)
-    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), catalog(move(catalog)),
+    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), catalog(std::move(catalog)),
       schema(std::move(schema)), function_name(StringUtil::Lower(function_name)), is_operator(is_operator),
-      children(move(children_p)), distinct(distinct), filter(move(filter)), order_bys(move(order_bys_p)),
+      children(std::move(children_p)), distinct(distinct), filter(std::move(filter)), order_bys(std::move(order_bys_p)),
       export_state(export_state_p) {
 	D_ASSERT(!function_name.empty());
 	if (!order_bys) {
@@ -25,8 +25,8 @@ FunctionExpression::FunctionExpression(string catalog, string schema, const stri
 FunctionExpression::FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children_p,
                                        unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys,
                                        bool distinct, bool is_operator, bool export_state_p)
-    : FunctionExpression(INVALID_CATALOG, INVALID_SCHEMA, function_name, move(children_p), move(filter),
-                         move(order_bys), distinct, is_operator, export_state_p) {
+    : FunctionExpression(INVALID_CATALOG, INVALID_SCHEMA, function_name, std::move(children_p), std::move(filter),
+                         std::move(order_bys), distinct, is_operator, export_state_p) {
 }
 
 string FunctionExpression::ToString() const {
@@ -34,7 +34,7 @@ string FunctionExpression::ToString() const {
 	                                                      filter.get(), order_bys.get(), export_state, true);
 }
 
-bool FunctionExpression::Equals(const FunctionExpression *a, const FunctionExpression *b) {
+bool FunctionExpression::Equal(const FunctionExpression *a, const FunctionExpression *b) {
 	if (a->catalog != b->catalog || a->schema != b->schema || a->function_name != b->function_name ||
 	    b->distinct != a->distinct) {
 		return false;
@@ -82,10 +82,11 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 		order_copy.reset(static_cast<OrderModifier *>(order_bys->Copy().release()));
 	}
 
-	auto copy = make_unique<FunctionExpression>(catalog, schema, function_name, move(copy_children), move(filter_copy),
-	                                            move(order_copy), distinct, is_operator, export_state);
+	auto copy = make_unique<FunctionExpression>(catalog, schema, function_name, std::move(copy_children),
+	                                            std::move(filter_copy), std::move(order_copy), distinct, is_operator,
+	                                            export_state);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void FunctionExpression::Serialize(FieldWriter &writer) const {
@@ -112,9 +113,9 @@ unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type
 	auto catalog = reader.ReadField<string>(INVALID_CATALOG);
 
 	unique_ptr<FunctionExpression> function;
-	function = make_unique<FunctionExpression>(catalog, schema, function_name, move(children), move(filter),
-	                                           move(order_bys), distinct, is_operator, export_state);
-	return move(function);
+	function = make_unique<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
+	                                           std::move(order_bys), distinct, is_operator, export_state);
+	return std::move(function);
 }
 
 void FunctionExpression::Verify() const {

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -6,14 +6,14 @@
 namespace duckdb {
 
 LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr)
-    : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(move(lhs)), expr(move(expr)) {
+    : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(std::move(lhs)), expr(std::move(expr)) {
 }
 
 string LambdaExpression::ToString() const {
 	return lhs->ToString() + " -> " + expr->ToString();
 }
 
-bool LambdaExpression::Equals(const LambdaExpression *a, const LambdaExpression *b) {
+bool LambdaExpression::Equal(const LambdaExpression *a, const LambdaExpression *b) {
 	return a->lhs->Equals(b->lhs.get()) && a->expr->Equals(b->expr.get());
 }
 
@@ -27,7 +27,7 @@ hash_t LambdaExpression::Hash() const {
 unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
 	auto copy = make_unique<LambdaExpression>(lhs->Copy(), expr->Copy());
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void LambdaExpression::Serialize(FieldWriter &writer) const {
@@ -38,7 +38,7 @@ void LambdaExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto lhs = reader.ReadRequiredSerializable<ParsedExpression>();
 	auto expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<LambdaExpression>(move(lhs), move(expr));
+	return make_unique<LambdaExpression>(std::move(lhs), std::move(expr));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -9,22 +9,22 @@ OperatorExpression::OperatorExpression(ExpressionType type, unique_ptr<ParsedExp
                                        unique_ptr<ParsedExpression> right)
     : ParsedExpression(type, ExpressionClass::OPERATOR) {
 	if (left) {
-		children.push_back(move(left));
+		children.push_back(std::move(left));
 	}
 	if (right) {
-		children.push_back(move(right));
+		children.push_back(std::move(right));
 	}
 }
 
 OperatorExpression::OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
-    : ParsedExpression(type, ExpressionClass::OPERATOR), children(move(children)) {
+    : ParsedExpression(type, ExpressionClass::OPERATOR), children(std::move(children)) {
 }
 
 string OperatorExpression::ToString() const {
 	return ToString<OperatorExpression, ParsedExpression>(*this);
 }
 
-bool OperatorExpression::Equals(const OperatorExpression *a, const OperatorExpression *b) {
+bool OperatorExpression::Equal(const OperatorExpression *a, const OperatorExpression *b) {
 	if (a->children.size() != b->children.size()) {
 		return false;
 	}
@@ -42,7 +42,7 @@ unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
 	for (auto &it : children) {
 		copy->children.push_back(it->Copy());
 	}
-	return move(copy);
+	return std::move(copy);
 }
 
 void OperatorExpression::Serialize(FieldWriter &writer) const {
@@ -52,7 +52,7 @@ void OperatorExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_unique<OperatorExpression>(type);
 	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return move(expression);
+	return std::move(expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -19,10 +19,10 @@ unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
 	auto copy = make_unique<ParameterExpression>();
 	copy->parameter_nr = parameter_nr;
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
-bool ParameterExpression::Equals(const ParameterExpression *a, const ParameterExpression *b) {
+bool ParameterExpression::Equal(const ParameterExpression *a, const ParameterExpression *b) {
 	return a->parameter_nr == b->parameter_nr;
 }
 
@@ -38,7 +38,7 @@ void ParameterExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_unique<ParameterExpression>();
 	expression->parameter_nr = reader.ReadRequired<idx_t>();
-	return move(expression);
+	return std::move(expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -15,15 +15,15 @@ string PositionalReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool PositionalReferenceExpression::Equals(const PositionalReferenceExpression *a,
-                                           const PositionalReferenceExpression *b) {
+bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression *a,
+                                          const PositionalReferenceExpression *b) {
 	return a->index == b->index;
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {
 	auto copy = make_unique<PositionalReferenceExpression>(index);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 hash_t PositionalReferenceExpression::Hash() const {
@@ -37,7 +37,7 @@ void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_unique<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
-	return move(expression);
+	return std::move(expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -6,7 +6,7 @@
 namespace duckdb {
 
 StarExpression::StarExpression(string relation_name_p)
-    : ParsedExpression(ExpressionType::STAR, ExpressionClass::STAR), relation_name(move(relation_name_p)) {
+    : ParsedExpression(ExpressionType::STAR, ExpressionClass::STAR), relation_name(std::move(relation_name_p)) {
 }
 
 string StarExpression::ToString() const {
@@ -51,7 +51,7 @@ string StarExpression::ToString() const {
 	return result;
 }
 
-bool StarExpression::Equals(const StarExpression *a, const StarExpression *b) {
+bool StarExpression::Equal(const StarExpression *a, const StarExpression *b) {
 	if (a->relation_name != b->relation_name || a->exclude_list != b->exclude_list) {
 		return false;
 	}
@@ -109,11 +109,11 @@ unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, Fi
 	for (idx_t i = 0; i < replace_count; i++) {
 		auto name = source.Read<string>();
 		auto expr = ParsedExpression::Deserialize(source);
-		result->replace_list.insert(make_pair(name, move(expr)));
+		result->replace_list.insert(make_pair(name, std::move(expr)));
 	}
 	result->columns = reader.ReadField<bool>(false);
 	result->regex = reader.ReadField<string>(string());
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<ParsedExpression> StarExpression::Copy() const {
@@ -125,7 +125,7 @@ unique_ptr<ParsedExpression> StarExpression::Copy() const {
 	copy->columns = columns;
 	copy->regex = regex;
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -26,7 +26,7 @@ string SubqueryExpression::ToString() const {
 	}
 }
 
-bool SubqueryExpression::Equals(const SubqueryExpression *a, const SubqueryExpression *b) {
+bool SubqueryExpression::Equal(const SubqueryExpression *a, const SubqueryExpression *b) {
 	if (!a->subquery || !b->subquery) {
 		return false;
 	}
@@ -44,7 +44,7 @@ unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
 	copy->subquery_type = subquery_type;
 	copy->child = child ? child->Copy() : nullptr;
 	copy->comparison_type = comparison_type;
-	return move(copy);
+	return std::move(copy);
 }
 
 void SubqueryExpression::Serialize(FieldWriter &writer) const {
@@ -66,10 +66,10 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
 
 	auto expression = make_unique<SubqueryExpression>();
 	expression->subquery_type = subquery_type;
-	expression->subquery = move(subquery);
+	expression->subquery = std::move(subquery);
 	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
 	expression->comparison_type = reader.ReadRequired<ExpressionType>();
-	return move(expression);
+	return std::move(expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
-    : ParsedExpression(type, ExpressionClass::WINDOW), catalog(move(catalog_name)), schema(move(schema)),
+    : ParsedExpression(type, ExpressionClass::WINDOW), catalog(std::move(catalog_name)), schema(std::move(schema)),
       function_name(StringUtil::Lower(function_name)), ignore_nulls(false) {
 	switch (type) {
 	case ExpressionType::WINDOW_AGGREGATE:
@@ -32,7 +32,7 @@ string WindowExpression::ToString() const {
 	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
 }
 
-bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression *b) {
+bool WindowExpression::Equal(const WindowExpression *a, const WindowExpression *b) {
 	// check if the child expressions are equivalent
 	if (b->children.size() != a->children.size()) {
 		return false;
@@ -48,7 +48,7 @@ bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression
 	if (a->start != b->start || a->end != b->end) {
 		return false;
 	}
-	// check if the framing expressions are equivalent
+	// check if the framing expressions are equivalentbind_
 	if (!BaseExpression::Equals(a->start_expr.get(), b->start_expr.get()) ||
 	    !BaseExpression::Equals(a->end_expr.get(), b->end_expr.get()) ||
 	    !BaseExpression::Equals(a->offset_expr.get(), b->offset_expr.get()) ||
@@ -111,7 +111,7 @@ unique_ptr<ParsedExpression> WindowExpression::Copy() const {
 	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 WindowExpression::Serialize(FieldWriter &writer) const {
@@ -142,7 +142,7 @@ void WindowExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto function_name = reader.ReadRequired<string>();
 	auto schema = reader.ReadRequired<string>();
-	auto expr = make_unique<WindowExpression>(type, INVALID_CATALOG, move(schema), function_name);
+	auto expr = make_unique<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
 	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
 
@@ -161,7 +161,7 @@ unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type,
 	expr->ignore_nulls = reader.ReadRequired<bool>();
 	expr->filter_expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	expr->catalog = reader.ReadField<string>(INVALID_CATALOG);
-	return move(expr);
+	return std::move(expr);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_function_info.cpp

@@ -9,7 +9,8 @@ namespace duckdb {
 // AlterFunctionInfo
 //===--------------------------------------------------------------------===//
 AlterFunctionInfo::AlterFunctionInfo(AlterFunctionType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_FUNCTION, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+    : AlterInfo(AlterType::ALTER_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
+                data.if_exists),
       alter_function_type(type) {
 }
 AlterFunctionInfo::~AlterFunctionInfo() {
@@ -40,7 +41,8 @@ unique_ptr<AlterInfo> AlterFunctionInfo::Deserialize(FieldReader &reader) {
 // AddFunctionOverloadInfo
 //===--------------------------------------------------------------------===//
 AddFunctionOverloadInfo::AddFunctionOverloadInfo(AlterEntryData data, ScalarFunctionSet new_overloads_p)
-    : AlterFunctionInfo(AlterFunctionType::ADD_FUNCTION_OVERLOADS, move(data)), new_overloads(move(new_overloads_p)) {
+    : AlterFunctionInfo(AlterFunctionType::ADD_FUNCTION_OVERLOADS, std::move(data)),
+      new_overloads(std::move(new_overloads_p)) {
 	this->allow_internal = true;
 }
 AddFunctionOverloadInfo::~AddFunctionOverloadInfo() {

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -7,8 +7,8 @@
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, bool if_exists)
-    : type(type), if_exists(if_exists), catalog(move(catalog_p)), schema(move(schema_p)), name(move(name_p)),
-      allow_internal(false) {
+    : type(type), if_exists(if_exists), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
+      name(std::move(name_p)), allow_internal(false) {
 }
 
 AlterInfo::~AlterInfo() {