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

package/src/duckdb/src/planner/operator/logical_expression_get.cpp

@@ -23,7 +23,7 @@ unique_ptr<LogicalOperator> LogicalExpressionGet::Deserialize(LogicalDeserializa
 		expressions.push_back(reader.ReadRequiredSerializableList<Expression>(state.gstate));
 	}
 
-	return make_unique<LogicalExpressionGet>(table_index, expr_types, move(expressions));
+	return make_unique<LogicalExpressionGet>(table_index, expr_types, std::move(expressions));
 }
 
 vector<idx_t> LogicalExpressionGet::GetTableIndex() const {

package/src/duckdb/src/planner/operator/logical_filter.cpp

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 LogicalFilter::LogicalFilter(unique_ptr<Expression> expression) : LogicalOperator(LogicalOperatorType::LOGICAL_FILTER) {
-	expressions.push_back(move(expression));
+	expressions.push_back(std::move(expression));
 	SplitPredicates(expressions);
 }
 
@@ -31,10 +31,10 @@ bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions)
 			found_conjunction = true;
 			// AND expression, append the other children
 			for (idx_t k = 1; k < conjunction.children.size(); k++) {
-				expressions.push_back(move(conjunction.children[k]));
+				expressions.push_back(std::move(conjunction.children[k]));
 			}
 			// replace this expression with the first child of the conjunction
-			expressions[i] = move(conjunction.children[0]);
+			expressions[i] = std::move(conjunction.children[0]);
 			// we move back by one so the right child is checked again
 			// in case it is an AND expression as well
 			i--;
@@ -52,9 +52,9 @@ unique_ptr<LogicalOperator> LogicalFilter::Deserialize(LogicalDeserializationSta
 	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	auto projection_map = reader.ReadRequiredList<idx_t>();
 	auto result = make_unique<LogicalFilter>();
-	result->expressions = move(expressions);
-	result->projection_map = move(projection_map);
-	return move(result);
+	result->expressions = std::move(expressions);
+	result->projection_map = std::move(projection_map);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -12,8 +12,8 @@ namespace duckdb {
 
 LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
                        vector<LogicalType> returned_types, vector<string> returned_names)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(move(function)),
-      bind_data(move(bind_data)), returned_types(move(returned_types)), names(move(returned_names)) {
+    : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(std::move(function)),
+      bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)) {
 }
 
 string LogicalGet::GetName() const {
@@ -185,16 +185,16 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
 	vector<column_t> projected_input;
 	reader.ReadList<column_t>(projected_input);
 
-	auto result = make_unique<LogicalGet>(table_index, function, move(bind_data), returned_types, returned_names);
-	result->column_ids = move(column_ids);
-	result->projection_ids = move(projection_ids);
-	result->table_filters = move(*table_filters);
-	result->parameters = move(parameters);
-	result->named_parameters = move(named_parameters);
+	auto result = make_unique<LogicalGet>(table_index, function, std::move(bind_data), returned_types, returned_names);
+	result->column_ids = std::move(column_ids);
+	result->projection_ids = std::move(projection_ids);
+	result->table_filters = std::move(*table_filters);
+	result->parameters = std::move(parameters);
+	result->named_parameters = std::move(named_parameters);
 	result->input_table_types = input_table_types;
 	result->input_table_names = input_table_names;
-	result->projected_input = move(projected_input);
-	return move(result);
+	result->projected_input = std::move(projected_input);
+	return std::move(result);
 }
 
 vector<idx_t> LogicalGet::GetTableIndex() const {

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -5,6 +5,11 @@
 
 namespace duckdb {
 
+LogicalInsert::LogicalInsert(TableCatalogEntry *table, idx_t table_index)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT), table(table), table_index(table_index), return_chunk(false),
+      action_type(OnConflictAction::THROW) {
+}
+
 void LogicalInsert::Serialize(FieldWriter &writer) const {
 	writer.WriteField<idx_t>(insert_values.size());
 	for (auto &entry : insert_values) {
@@ -17,6 +22,7 @@ void LogicalInsert::Serialize(FieldWriter &writer) const {
 	writer.WriteField(table_index);
 	writer.WriteField(return_chunk);
 	writer.WriteSerializableList(bound_defaults);
+	writer.WriteField(action_type);
 }
 
 unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
@@ -33,6 +39,7 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto return_chunk = reader.ReadRequired<bool>();
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
+	auto action_type = reader.ReadRequired<OnConflictAction>();
 
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
@@ -46,11 +53,12 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	result->type = state.type;
 	result->table = table_catalog_entry;
 	result->return_chunk = return_chunk;
-	result->insert_values = move(insert_values);
+	result->insert_values = std::move(insert_values);
 	result->column_index_map = column_index_map;
 	result->expected_types = expected_types;
-	result->bound_defaults = move(bound_defaults);
-	return move(result);
+	result->bound_defaults = std::move(bound_defaults);
+	result->action_type = action_type;
+	return std::move(result);
 }
 
 idx_t LogicalInsert::EstimateCardinality(ClientContext &context) {
@@ -61,4 +69,19 @@ vector<idx_t> LogicalInsert::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+vector<ColumnBinding> LogicalInsert::GetColumnBindings() {
+	if (return_chunk) {
+		return GenerateColumnBindings(table_index, table->GetTypes().size());
+	}
+	return {ColumnBinding(0, 0)};
+}
+
+void LogicalInsert::ResolveTypes() {
+	if (return_chunk) {
+		types = table->GetTypes();
+	} else {
+		types.emplace_back(LogicalType::BIGINT);
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_limit.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 LogicalLimit::LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit,
                            unique_ptr<Expression> offset)
     : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val),
-      limit(move(limit)), offset(move(offset)) {
+      limit(std::move(limit)), offset(std::move(offset)) {
 }
 
 vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
@@ -37,7 +37,7 @@ unique_ptr<LogicalOperator> LogicalLimit::Deserialize(LogicalDeserializationStat
 	auto offset_val = reader.ReadRequired<int64_t>();
 	auto limit = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	auto offset = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_unique<LogicalLimit>(limit_val, offset_val, move(limit), move(offset));
+	return make_unique<LogicalLimit>(limit_val, offset_val, std::move(limit), std::move(offset));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_limit_percent.cpp

@@ -16,7 +16,7 @@ unique_ptr<LogicalOperator> LogicalLimitPercent::Deserialize(LogicalDeserializat
 	auto offset_val = reader.ReadRequired<int64_t>();
 	auto limit = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	auto offset = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_unique<LogicalLimitPercent>(limit_percent, offset_val, move(limit), move(offset));
+	return make_unique<LogicalLimitPercent>(limit_percent, offset_val, std::move(limit), std::move(offset));
 }
 
 idx_t LogicalLimitPercent::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_order.cpp

@@ -12,9 +12,9 @@ void LogicalOrder::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalOrder::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
 	auto projections = reader.ReadRequiredList<idx_t>();
-	auto result = make_unique<LogicalOrder>(move(orders));
-	result->projections = move(projections);
-	return move(result);
+	auto result = make_unique<LogicalOrder>(std::move(orders));
+	result->projections = std::move(projections);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_positional_join.cpp

@@ -0,0 +1,30 @@
+#include "duckdb/planner/operator/logical_positional_join.hpp"
+
+namespace duckdb {
+
+LogicalPositionalJoin::LogicalPositionalJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right)
+    : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN, std::move(left), std::move(right)) {
+}
+
+unique_ptr<LogicalOperator> LogicalPositionalJoin::Create(unique_ptr<LogicalOperator> left,
+                                                          unique_ptr<LogicalOperator> right) {
+	if (left->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
+		return right;
+	}
+	if (right->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
+		return left;
+	}
+	return make_unique<LogicalPositionalJoin>(std::move(left), std::move(right));
+}
+
+void LogicalPositionalJoin::Serialize(FieldWriter &writer) const {
+}
+
+unique_ptr<LogicalOperator> LogicalPositionalJoin::Deserialize(LogicalDeserializationState &state,
+                                                               FieldReader &reader) {
+	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
+	auto result = unique_ptr<LogicalPositionalJoin>(new LogicalPositionalJoin());
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_projection.cpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 LogicalProjection::LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_PROJECTION, move(select_list)), table_index(table_index) {
+    : LogicalOperator(LogicalOperatorType::LOGICAL_PROJECTION, std::move(select_list)), table_index(table_index) {
 }
 
 vector<ColumnBinding> LogicalProjection::GetColumnBindings() {
@@ -25,7 +25,7 @@ void LogicalProjection::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalProjection::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_unique<LogicalProjection>(table_index, move(expressions));
+	return make_unique<LogicalProjection>(table_index, std::move(expressions));
 }
 
 vector<idx_t> LogicalProjection::GetTableIndex() const {

package/src/duckdb/src/planner/operator/logical_sample.cpp

@@ -4,8 +4,8 @@
 namespace duckdb {
 
 LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(move(sample_options_p)) {
-	children.push_back(move(child));
+    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(std::move(sample_options_p)) {
+	children.push_back(std::move(child));
 }
 
 vector<ColumnBinding> LogicalSample::GetColumnBindings() {
@@ -41,7 +41,7 @@ void LogicalSample::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalSample::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto sample_options = SampleOptions::Deserialize(reader.GetSource());
 	// TODO(stephwang): review how to pass child LogicalOperator
-	auto result = make_unique<LogicalSample>(move(sample_options), nullptr);
-	return move(result);
+	auto result = make_unique<LogicalSample>(std::move(sample_options), nullptr);
+	return std::move(result);
 }
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_show.cpp

@@ -16,6 +16,6 @@ unique_ptr<LogicalOperator> LogicalShow::Deserialize(LogicalDeserializationState
 	auto result = unique_ptr<LogicalShow>(new LogicalShow());
 	result->types_select = types_select;
 	result->aliases = aliases;
-	return move(result);
+	return std::move(result);
 }
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_simple.cpp

@@ -1,13 +1,44 @@
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/parser/parsed_data/load_info.hpp"
 
 namespace duckdb {
 
 void LogicalSimple::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
+	writer.WriteField<LogicalOperatorType>(type);
+	switch (type) {
+	case LogicalOperatorType::LOGICAL_ALTER:
+		static_cast<const AlterInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_DROP:
+		static_cast<const DropInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	case LogicalOperatorType::LOGICAL_LOAD:
+		static_cast<const LoadInfo &>(*info).Serialize(writer.GetSerializer());
+		break;
+	default:
+		throw NotImplementedException(LogicalOperatorToString(type));
+	}
 }
 
 unique_ptr<LogicalOperator> LogicalSimple::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
+	auto type = reader.ReadRequired<LogicalOperatorType>();
+	unique_ptr<ParseInfo> parse_info;
+	switch (type) {
+	case LogicalOperatorType::LOGICAL_ALTER:
+		parse_info = AlterInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_DROP:
+		parse_info = DropInfo::Deserialize(reader.GetSource());
+		break;
+	case LogicalOperatorType::LOGICAL_LOAD:
+		parse_info = LoadInfo::Deserialize(reader.GetSource());
+		break;
+	default:
+		throw NotImplementedException(LogicalOperatorToString(state.type));
+	}
+	return make_unique<LogicalSimple>(type, std::move(parse_info));
 }
 
 idx_t LogicalSimple::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_top_n.cpp

@@ -13,7 +13,7 @@ unique_ptr<LogicalOperator> LogicalTopN::Deserialize(LogicalDeserializationState
 	auto orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
 	auto offset = reader.ReadRequired<idx_t>();
 	auto limit = reader.ReadRequired<idx_t>();
-	return make_unique<LogicalTopN>(move(orders), limit, offset);
+	return make_unique<LogicalTopN>(std::move(orders), limit, offset);
 }
 
 idx_t LogicalTopN::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_unconditional_join.cpp

@@ -0,0 +1,26 @@
+#include "duckdb/planner/operator/logical_unconditional_join.hpp"
+
+namespace duckdb {
+
+LogicalUnconditionalJoin::LogicalUnconditionalJoin(LogicalOperatorType logical_type, unique_ptr<LogicalOperator> left,
+                                                   unique_ptr<LogicalOperator> right)
+    : LogicalOperator(logical_type) {
+	D_ASSERT(left);
+	D_ASSERT(right);
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
+}
+
+vector<ColumnBinding> LogicalUnconditionalJoin::GetColumnBindings() {
+	auto left_bindings = children[0]->GetColumnBindings();
+	auto right_bindings = children[1]->GetColumnBindings();
+	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
+	return left_bindings;
+}
+
+void LogicalUnconditionalJoin::ResolveTypes() {
+	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
+	types.insert(types.end(), children[1]->types.begin(), children[1]->types.end());
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_unnest.cpp

@@ -27,8 +27,8 @@ unique_ptr<LogicalOperator> LogicalUnnest::Deserialize(LogicalDeserializationSta
 	auto unnest_index = reader.ReadRequired<idx_t>();
 	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	auto result = make_unique<LogicalUnnest>(unnest_index);
-	result->expressions = move(expressions);
-	return move(result);
+	result->expressions = std::move(expressions);
+	return std::move(result);
 }
 
 vector<idx_t> LogicalUnnest::GetTableIndex() const {

package/src/duckdb/src/planner/operator/logical_update.cpp

@@ -5,6 +5,10 @@
 
 namespace duckdb {
 
+LogicalUpdate::LogicalUpdate(TableCatalogEntry *table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
+}
+
 void LogicalUpdate::Serialize(FieldWriter &writer) const {
 	table->Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -31,11 +35,26 @@ unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationSta
 	result->columns = reader.ReadRequiredIndexList<PhysicalIndex>();
 	result->bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	result->update_is_del_and_insert = reader.ReadRequired<bool>();
-	return move(result);
+	return std::move(result);
 }
 
 idx_t LogicalUpdate::EstimateCardinality(ClientContext &context) {
 	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
 }
 
+vector<ColumnBinding> LogicalUpdate::GetColumnBindings() {
+	if (return_chunk) {
+		return GenerateColumnBindings(table_index, table->GetTypes().size());
+	}
+	return {ColumnBinding(0, 0)};
+}
+
+void LogicalUpdate::ResolveTypes() {
+	if (return_chunk) {
+		types = table->GetTypes();
+	} else {
+		types.emplace_back(LogicalType::BIGINT);
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_window.cpp

@@ -27,7 +27,7 @@ unique_ptr<LogicalOperator> LogicalWindow::Deserialize(LogicalDeserializationSta
 	auto window_index = reader.ReadRequired<idx_t>();
 	auto result = make_unique<LogicalWindow>(window_index);
 	result->expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return move(result);
+	return std::move(result);
 }
 
 vector<idx_t> LogicalWindow::GetTableIndex() const {

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -37,7 +37,7 @@ unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer
                                                                    PlanDeserializationState &state) {
 	auto create_info = SchemaCatalogEntry::Deserialize(source);
 	auto schema_name = create_info->schema;
-	auto result = make_unique<BoundCreateTableInfo>(move(create_info));
+	auto result = make_unique<BoundCreateTableInfo>(std::move(create_info));
 	auto &context = state.context;
 	result->schema = Catalog::GetSchema(context, INVALID_CATALOG, schema_name);
 	result->base = source.ReadOptional<CreateInfo>();

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

@@ -41,7 +41,7 @@ void Planner::CreatePlan(SQLStatement &statement) {
 
 		this->names = bound_statement.names;
 		this->types = bound_statement.types;
-		this->plan = move(bound_statement.plan);
+		this->plan = std::move(bound_statement.plan);
 
 		auto max_tree_depth = ClientConfig::GetConfig(context).max_expression_depth;
 		CheckTreeDepth(*plan, max_tree_depth);
@@ -61,7 +61,7 @@ void Planner::CreatePlan(SQLStatement &statement) {
 			if (bound_statement.plan != nullptr) {
 				this->names = bound_statement.names;
 				this->types = bound_statement.types;
-				this->plan = move(bound_statement.plan);
+				this->plan = std::move(bound_statement.plan);
 				break;
 			}
 		}
@@ -95,13 +95,13 @@ void Planner::CreatePlan(SQLStatement &statement) {
 shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLStatement> statement) {
 	auto copied_statement = statement->Copy();
 	// create a plan of the underlying statement
-	CreatePlan(move(statement));
+	CreatePlan(std::move(statement));
 	// now create the logical prepare
 	auto prepared_data = make_shared<PreparedStatementData>(copied_statement->type);
-	prepared_data->unbound_statement = move(copied_statement);
+	prepared_data->unbound_statement = std::move(copied_statement);
 	prepared_data->names = names;
 	prepared_data->types = types;
-	prepared_data->value_map = move(value_map);
+	prepared_data->value_map = std::move(value_map);
 	prepared_data->properties = properties;
 	prepared_data->catalog_version = MetaTransaction::Get(context).catalog_version;
 	return prepared_data;
@@ -154,13 +154,11 @@ static bool OperatorSupportsSerialization(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-	case LogicalOperatorType::LOGICAL_DROP:
 	case LogicalOperatorType::LOGICAL_PRAGMA:
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-	case LogicalOperatorType::LOGICAL_LOAD:
 	case LogicalOperatorType::LOGICAL_VACUUM:
 		// unsupported (for now)
 		return false;
@@ -197,9 +195,9 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 	PlanDeserializationState state(context);
 	auto new_plan = LogicalOperator::Deserialize(deserializer, state);
 	if (map) {
-		*map = move(state.parameter_data);
+		*map = std::move(state.parameter_data);
 	}
-	op = move(new_plan);
+	op = std::move(new_plan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -33,14 +33,14 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 				parser.ParseQuery(new_query);
 				// insert the new statements and remove the old statement
 				for (idx_t j = 0; j < parser.statements.size(); j++) {
-					new_statements.push_back(move(parser.statements[j]));
+					new_statements.push_back(std::move(parser.statements[j]));
 				}
 				continue;
 			}
 		}
-		new_statements.push_back(move(statements[i]));
+		new_statements.push_back(std::move(statements[i]));
 	}
-	statements = move(new_statements);
+	statements = std::move(new_statements);
 }
 
 void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<unique_ptr<SQLStatement>> &statements) {