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

package/src/duckdb/src/parallel/executor.cpp

@@ -34,7 +34,7 @@ void Executor::AddEvent(shared_ptr<Event> event) {
 	if (cancelled) {
 		return;
 	}
-	events.push_back(move(event));
+	events.push_back(std::move(event));
 }
 
 struct PipelineEventStack {
@@ -71,10 +71,10 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 	auto base_complete_event = make_shared<PipelineCompleteEvent>(base_pipeline->executor, event_data.initial_schedule);
 	PipelineEventStack base_stack {base_initialize_event.get(), base_event.get(), base_finish_event.get(),
 	                               base_complete_event.get()};
-	events.push_back(move(base_initialize_event));
-	events.push_back(move(base_event));
-	events.push_back(move(base_finish_event));
-	events.push_back(move(base_complete_event));
+	events.push_back(std::move(base_initialize_event));
+	events.push_back(std::move(base_event));
+	events.push_back(std::move(base_finish_event));
+	events.push_back(std::move(base_complete_event));
 
 	// dependencies: initialize -> event -> finish -> complete
 	base_stack.pipeline_event->AddDependency(*base_stack.pipeline_initialize_event);
@@ -95,14 +95,14 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
 			auto pipeline_finish_event = make_unique<PipelineFinishEvent>(pipeline);
 			pipeline_finish_event_ptr = pipeline_finish_event.get();
-			events.push_back(move(pipeline_finish_event));
+			events.push_back(std::move(pipeline_finish_event));
 			base_stack.pipeline_complete_event->AddDependency(*pipeline_finish_event_ptr);
 		} else {
 			pipeline_finish_event_ptr = base_stack.pipeline_finish_event;
 		}
 		PipelineEventStack pipeline_stack {base_stack.pipeline_initialize_event, pipeline_event.get(),
 		                                   pipeline_finish_event_ptr, base_stack.pipeline_complete_event};
-		events.push_back(move(pipeline_event));
+		events.push_back(std::move(pipeline_event));
 
 		// dependencies: base_initialize -> pipeline_event -> base_finish
 		pipeline_stack.pipeline_event->AddDependency(*base_stack.pipeline_initialize_event);
@@ -280,7 +280,7 @@ void Executor::VerifyPipelines() {
 
 void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan) {
 	Reset();
-	owned_plan = move(physical_plan);
+	owned_plan = std::move(physical_plan);
 	InitializeInternal(owned_plan.get());
 }
 
@@ -376,6 +376,10 @@ void Executor::WorkOnTasks() {
 	}
 }
 
+bool Executor::ExecutionIsFinished() {
+	return completed_pipelines >= total_pipelines || HasError();
+}
+
 PendingExecutionResult Executor::ExecuteTask() {
 	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
 		return execution_result;
@@ -467,7 +471,7 @@ void Executor::PushError(PreservedError exception) {
 	// interrupt execution of any other pipelines that belong to this executor
 	context.interrupted = true;
 	// push the exception onto the stack
-	exceptions.push_back(move(exception));
+	exceptions.push_back(std::move(exception));
 }
 
 bool Executor::HasError() {

package/src/duckdb/src/parallel/pipeline.cpp

@@ -21,7 +21,7 @@ class PipelineTask : public ExecutorTask {
 
 public:
 	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(move(event_p)) {
+	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
 	}
 
 	Pipeline &pipeline;
@@ -70,7 +70,7 @@ bool Pipeline::GetProgress(double &current_percentage, idx_t &source_cardinality
 void Pipeline::ScheduleSequentialTask(shared_ptr<Event> &event) {
 	vector<unique_ptr<Task>> tasks;
 	tasks.push_back(make_unique<PipelineTask>(*this, event));
-	event->SetTasks(move(tasks));
+	event->SetTasks(std::move(tasks));
 }
 
 bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
@@ -142,7 +142,7 @@ bool Pipeline::LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads) {
 	for (idx_t i = 0; i < max_threads; i++) {
 		tasks.push_back(make_unique<PipelineTask>(*this, event));
 	}
-	event->SetTasks(move(tasks));
+	event->SetTasks(std::move(tasks));
 	return true;
 }
 
@@ -260,7 +260,7 @@ PhysicalOperator *PipelineBuildState::GetPipelineSink(Pipeline &pipeline) {
 }
 
 void PipelineBuildState::SetPipelineOperators(Pipeline &pipeline, vector<PhysicalOperator *> operators) {
-	pipeline.operators = move(operators);
+	pipeline.operators = std::move(operators);
 }
 
 shared_ptr<Pipeline> PipelineBuildState::CreateChildPipeline(Executor &executor, Pipeline &pipeline,

package/src/duckdb/src/parallel/pipeline_event.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-PipelineEvent::PipelineEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(move(pipeline_p)) {
+PipelineEvent::PipelineEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
 }
 
 void PipelineEvent::Schedule() {

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -21,7 +21,7 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 
 		auto chunk = make_unique<DataChunk>();
 		chunk->Initialize(Allocator::Get(context.client), prev_operator->GetTypes());
-		intermediate_chunks.push_back(move(chunk));
+		intermediate_chunks.push_back(std::move(chunk));
 
 		auto op_state = current_operator->GetOperatorState(context);
 		intermediate_states.push_back(std::move(op_state));

package/src/duckdb/src/parallel/pipeline_finish_event.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(move(pipeline_p)) {
+PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
 }
 
 void PipelineFinishEvent::Schedule() {

package/src/duckdb/src/parallel/pipeline_initialize_event.cpp

@@ -5,13 +5,13 @@
 namespace duckdb {
 
 PipelineInitializeEvent::PipelineInitializeEvent(shared_ptr<Pipeline> pipeline_p)
-    : BasePipelineEvent(move(pipeline_p)) {
+    : BasePipelineEvent(std::move(pipeline_p)) {
 }
 
 class PipelineInitializeTask : public ExecutorTask {
 public:
 	explicit PipelineInitializeTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(move(event_p)) {
+	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
 	}
 
 	Pipeline &pipeline;
@@ -29,7 +29,7 @@ void PipelineInitializeEvent::Schedule() {
 	// needs to spawn a task to get the chain of tasks for the query plan going
 	vector<unique_ptr<Task>> tasks;
 	tasks.push_back(make_unique<PipelineInitializeTask>(*pipeline, shared_from_this()));
-	SetTasks(move(tasks));
+	SetTasks(std::move(tasks));
 }
 
 void PipelineInitializeEvent::FinishEvent() {

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -16,7 +16,7 @@ namespace duckdb {
 
 struct SchedulerThread {
 #ifndef DUCKDB_NO_THREADS
-	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(move(thread_p)) {
+	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(std::move(thread_p)) {
 	}
 
 	unique_ptr<thread> internal_thread;
@@ -44,7 +44,7 @@ struct QueueProducerToken {
 
 void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
 	lock_guard<mutex> producer_lock(token.producer_lock);
-	if (q.enqueue(token.token->queue_token, move(task))) {
+	if (q.enqueue(token.token->queue_token, std::move(task))) {
 		semaphore.signal();
 	} else {
 		throw InternalException("Could not schedule task!");
@@ -67,7 +67,7 @@ struct ConcurrentQueue {
 
 void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
 	lock_guard<mutex> lock(qlock);
-	q.push(move(task));
+	q.push(std::move(task));
 }
 
 bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
@@ -75,7 +75,7 @@ bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task>
 	if (q.empty()) {
 		return false;
 	}
-	task = move(q.front());
+	task = std::move(q.front());
 	q.pop();
 	return true;
 }
@@ -87,7 +87,7 @@ struct QueueProducerToken {
 #endif
 
 ProducerToken::ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerToken> token)
-    : scheduler(scheduler), token(move(token)) {
+    : scheduler(scheduler), token(std::move(token)) {
 }
 
 ProducerToken::~ProducerToken() {
@@ -112,12 +112,12 @@ TaskScheduler &TaskScheduler::GetScheduler(DatabaseInstance &db) {
 
 unique_ptr<ProducerToken> TaskScheduler::CreateProducer() {
 	auto token = make_unique<QueueProducerToken>(*queue);
-	return make_unique<ProducerToken>(*this, move(token));
+	return make_unique<ProducerToken>(*this, std::move(token));
 }
 
 void TaskScheduler::ScheduleTask(ProducerToken &token, unique_ptr<Task> task) {
 	// Enqueue a task for the given producer token and signal any sleeping threads
-	queue->Enqueue(token, move(task));
+	queue->Enqueue(token, std::move(task));
 }
 
 bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
@@ -239,10 +239,10 @@ void TaskScheduler::SetThreadsInternal(int32_t n) {
 			// launch a thread and assign it a cancellation marker
 			auto marker = unique_ptr<atomic<bool>>(new atomic<bool>(true));
 			auto worker_thread = make_unique<thread>(ThreadExecuteTasks, this, marker.get());
-			auto thread_wrapper = make_unique<SchedulerThread>(move(worker_thread));
+			auto thread_wrapper = make_unique<SchedulerThread>(std::move(worker_thread));
 
-			threads.push_back(move(thread_wrapper));
-			markers.push_back(move(marker));
+			threads.push_back(std::move(thread_wrapper));
+			markers.push_back(std::move(marker));
 		}
 	}
 #endif

package/src/duckdb/src/parser/column_definition.cpp

@@ -7,19 +7,20 @@
 
 namespace duckdb {
 
-ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p) : name(move(name_p)), type(move(type_p)) {
+ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p)
+    : name(std::move(name_p)), type(std::move(type_p)) {
 }
 
 ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
                                    TableColumnType category)
-    : name(move(name_p)), type(move(type_p)), category(category) {
+    : name(std::move(name_p)), type(std::move(type_p)), category(category) {
 	switch (category) {
 	case TableColumnType::STANDARD: {
-		default_value = move(expression);
+		default_value = std::move(expression);
 		break;
 	}
 	case TableColumnType::GENERATED: {
-		generated_expression = move(expression);
+		generated_expression = std::move(expression);
 		break;
 	}
 	default: {
@@ -62,9 +63,9 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 
 	switch (category) {
 	case TableColumnType::STANDARD:
-		return ColumnDefinition(column_name, column_type, move(expression), TableColumnType::STANDARD);
+		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::STANDARD);
 	case TableColumnType::GENERATED:
-		return ColumnDefinition(column_name, column_type, move(expression), TableColumnType::GENERATED);
+		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::GENERATED);
 	default:
 		throw NotImplementedException("Type not implemented for TableColumnType");
 	}
@@ -75,7 +76,7 @@ const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
 }
 
 void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	this->default_value = move(default_value);
+	this->default_value = std::move(default_value);
 }
 
 const LogicalType &ColumnDefinition::Type() const {
@@ -161,6 +162,9 @@ static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &d
 		dependencies.push_back(name);
 	}
 	ParsedExpressionIterator::EnumerateChildren(expr, [&](const ParsedExpression &child) {
+		if (expr.type == ExpressionType::LAMBDA) {
+			throw NotImplementedException("Lambda functions are currently not supported in generated columns.");
+		}
 		InnerGetListOfDependencies((ParsedExpression &)child, dependencies);
 	});
 }
@@ -187,24 +191,24 @@ void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> expre
 
 	VerifyColumnRefs(*expression);
 	if (type.id() == LogicalTypeId::ANY) {
-		generated_expression = move(expression);
+		generated_expression = std::move(expression);
 		return;
 	}
 	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
 	// Except if the type is LogicalType::ANY (no type specified)
-	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(expression));
+	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, std::move(expression));
 }
 
 void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 	D_ASSERT(Generated());
 	// First time the type is set, add a cast around the expression
 	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(generated_expression));
+	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, std::move(generated_expression));
 	// Every generated expression should be wrapped in a cast on creation
 	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
 	// auto &cast_expr = (CastExpression &)*generated_expression;
-	// auto base_expr = move(cast_expr.child);
-	// generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(base_expr));
+	// auto base_expr = std::move(cast_expr.child);
+	// generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, std::move(base_expr));
 }
 
 const ParsedExpression &ColumnDefinition::GeneratedExpression() const {

package/src/duckdb/src/parser/column_list.cpp

@@ -16,7 +16,7 @@ void ColumnList::AddColumn(ColumnDefinition column) {
 	}
 	column.SetOid(columns.size());
 	AddToNameMap(column);
-	columns.push_back(move(column));
+	columns.push_back(std::move(column));
 }
 
 void ColumnList::Finalize() {
@@ -93,6 +93,24 @@ const ColumnDefinition &ColumnList::GetColumn(const string &name) const {
 	return columns[logical_index];
 }
 
+vector<string> ColumnList::GetColumnNames() const {
+	vector<string> names;
+	names.reserve(columns.size());
+	for (auto &column : columns) {
+		names.push_back(column.Name());
+	}
+	return names;
+}
+
+vector<LogicalType> ColumnList::GetColumnTypes() const {
+	vector<LogicalType> types;
+	types.reserve(columns.size());
+	for (auto &column : columns) {
+		types.push_back(column.Type());
+	}
+	return types;
+}
+
 bool ColumnList::ColumnExists(const string &name) const {
 	auto entry = name_map.find(name);
 	return entry != name_map.end();
@@ -140,7 +158,7 @@ ColumnList ColumnList::Deserialize(FieldReader &reader) {
 	ColumnList result;
 	auto columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
 	for (auto &col : columns) {
-		result.AddColumn(move(col));
+		result.AddColumn(std::move(col));
 	}
 	return result;
 }

package/src/duckdb/src/parser/constraints/check_constraint.cpp

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
-    : Constraint(ConstraintType::CHECK), expression(move(expression)) {
+    : Constraint(ConstraintType::CHECK), expression(std::move(expression)) {
 }
 
 string CheckConstraint::ToString() const {
@@ -22,7 +22,7 @@ void CheckConstraint::Serialize(FieldWriter &writer) const {
 
 unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
 	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<CheckConstraint>(move(expression));
+	return make_unique<CheckConstraint>(std::move(expression));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -7,8 +7,8 @@
 namespace duckdb {
 
 ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
-    : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(move(pk_columns)), fk_columns(move(fk_columns)),
-      info(move(info)) {
+    : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)),
+      info(std::move(info)) {
 }
 
 string ForeignKeyConstraint::ToString() const {
@@ -70,7 +70,7 @@ unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
 	read_info.fk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
 
 	// column list parsed constraint
-	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(read_info));
+	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(read_info));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -10,7 +10,7 @@ UniqueConstraint::UniqueConstraint(LogicalIndex index, bool is_primary_key)
     : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
 }
 UniqueConstraint::UniqueConstraint(vector<string> columns, bool is_primary_key)
-    : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX), columns(move(columns)),
+    : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX), columns(std::move(columns)),
       is_primary_key(is_primary_key) {
 }
 
@@ -31,7 +31,7 @@ unique_ptr<Constraint> UniqueConstraint::Copy() const {
 	} else {
 		auto result = make_unique<UniqueConstraint>(index, is_primary_key);
 		result->columns = columns;
-		return move(result);
+		return std::move(result);
 	}
 }
 
@@ -50,11 +50,11 @@ unique_ptr<Constraint> UniqueConstraint::Deserialize(FieldReader &source) {
 	if (index != DConstants::INVALID_INDEX) {
 		// single column parsed constraint
 		auto result = make_unique<UniqueConstraint>(LogicalIndex(index), is_primary_key);
-		result->columns = move(columns);
-		return move(result);
+		result->columns = std::move(columns);
+		return std::move(result);
 	} else {
 		// column list parsed constraint
-		return make_unique<UniqueConstraint>(move(columns), is_primary_key);
+		return make_unique<UniqueConstraint>(std::move(columns), is_primary_key);
 	}
 }
 

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

@@ -5,15 +5,15 @@ namespace duckdb {
 
 BetweenExpression::BetweenExpression(unique_ptr<ParsedExpression> input_p, unique_ptr<ParsedExpression> lower_p,
                                      unique_ptr<ParsedExpression> upper_p)
-    : ParsedExpression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BETWEEN), input(move(input_p)),
-      lower(move(lower_p)), upper(move(upper_p)) {
+    : ParsedExpression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BETWEEN), input(std::move(input_p)),
+      lower(std::move(lower_p)), upper(std::move(upper_p)) {
 }
 
 string BetweenExpression::ToString() const {
 	return ToString<BetweenExpression, ParsedExpression>(*this);
 }
 
-bool BetweenExpression::Equals(const BetweenExpression *a, const BetweenExpression *b) {
+bool BetweenExpression::Equal(const BetweenExpression *a, const BetweenExpression *b) {
 	if (!a->input->Equals(b->input.get())) {
 		return false;
 	}
@@ -29,7 +29,7 @@ bool BetweenExpression::Equals(const BetweenExpression *a, const BetweenExpressi
 unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
 	auto copy = make_unique<BetweenExpression>(input->Copy(), lower->Copy(), upper->Copy());
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BetweenExpression::Serialize(FieldWriter &writer) const {
@@ -42,7 +42,7 @@ unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type,
 	auto input = source.ReadRequiredSerializable<ParsedExpression>();
 	auto lower = source.ReadRequiredSerializable<ParsedExpression>();
 	auto upper = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<BetweenExpression>(move(input), move(lower), move(upper));
+	return make_unique<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
 }
 
 } // namespace duckdb

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

@@ -12,7 +12,7 @@ string CaseExpression::ToString() const {
 	return ToString<CaseExpression, ParsedExpression>(*this);
 }
 
-bool CaseExpression::Equals(const CaseExpression *a, const CaseExpression *b) {
+bool CaseExpression::Equal(const CaseExpression *a, const CaseExpression *b) {
 	if (a->case_checks.size() != b->case_checks.size()) {
 		return false;
 	}
@@ -37,10 +37,10 @@ unique_ptr<ParsedExpression> CaseExpression::Copy() const {
 		CaseCheck new_check;
 		new_check.when_expr = check.when_expr->Copy();
 		new_check.then_expr = check.then_expr->Copy();
-		copy->case_checks.push_back(move(new_check));
+		copy->case_checks.push_back(std::move(new_check));
 	}
 	copy->else_expr = else_expr->Copy();
-	return move(copy);
+	return std::move(copy);
 }
 
 void CaseExpression::Serialize(FieldWriter &writer) const {
@@ -63,10 +63,10 @@ unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, Fi
 		CaseCheck new_check;
 		new_check.when_expr = ParsedExpression::Deserialize(source);
 		new_check.then_expr = ParsedExpression::Deserialize(source);
-		result->case_checks.push_back(move(new_check));
+		result->case_checks.push_back(std::move(new_check));
 	}
 	result->else_expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -6,17 +6,17 @@
 namespace duckdb {
 
 CastExpression::CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast_p)
-    : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST), cast_type(move(target)),
+    : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST), cast_type(std::move(target)),
       try_cast(try_cast_p) {
 	D_ASSERT(child);
-	this->child = move(child);
+	this->child = std::move(child);
 }
 
 string CastExpression::ToString() const {
 	return ToString<CastExpression, ParsedExpression>(*this);
 }
 
-bool CastExpression::Equals(const CastExpression *a, const CastExpression *b) {
+bool CastExpression::Equal(const CastExpression *a, const CastExpression *b) {
 	if (!a->child->Equals(b->child.get())) {
 		return false;
 	}
@@ -32,7 +32,7 @@ bool CastExpression::Equals(const CastExpression *a, const CastExpression *b) {
 unique_ptr<ParsedExpression> CastExpression::Copy() const {
 	auto copy = make_unique<CastExpression>(cast_type, child->Copy(), try_cast);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void CastExpression::Serialize(FieldWriter &writer) const {
@@ -45,7 +45,7 @@ unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, Fi
 	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
 	auto cast_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto try_cast = reader.ReadRequired<bool>();
-	return make_unique_base<ParsedExpression, CastExpression>(cast_type, move(child), try_cast);
+	return make_unique_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
 }
 
 } // namespace duckdb

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

@@ -6,16 +6,16 @@
 namespace duckdb {
 
 CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpression> child)
-    : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE), collation(move(collation_p)) {
+    : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE), collation(std::move(collation_p)) {
 	D_ASSERT(child);
-	this->child = move(child);
+	this->child = std::move(child);
 }
 
 string CollateExpression::ToString() const {
 	return child->ToString() + " COLLATE " + KeywordHelper::WriteOptionallyQuoted(collation);
 }
 
-bool CollateExpression::Equals(const CollateExpression *a, const CollateExpression *b) {
+bool CollateExpression::Equal(const CollateExpression *a, const CollateExpression *b) {
 	if (!a->child->Equals(b->child.get())) {
 		return false;
 	}
@@ -28,7 +28,7 @@ bool CollateExpression::Equals(const CollateExpression *a, const CollateExpressi
 unique_ptr<ParsedExpression> CollateExpression::Copy() const {
 	auto copy = make_unique<CollateExpression>(collation, child->Copy());
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void CollateExpression::Serialize(FieldWriter &writer) const {
@@ -39,7 +39,7 @@ void CollateExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
 	auto collation = reader.ReadRequired<string>();
-	return make_unique_base<ParsedExpression, CollateExpression>(collation, move(child));
+	return make_unique_base<ParsedExpression, CollateExpression>(collation, std::move(child));
 }
 
 } // namespace duckdb

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

@@ -8,15 +8,17 @@
 namespace duckdb {
 
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
-    : ColumnRefExpression(table_name.empty() ? vector<string> {move(column_name)}
-                                             : vector<string> {move(table_name), move(column_name)}) {
+    : ColumnRefExpression(table_name.empty() ? vector<string> {std::move(column_name)}
+                                             : vector<string> {std::move(table_name), std::move(column_name)}) {
 }
 
-ColumnRefExpression::ColumnRefExpression(string column_name) : ColumnRefExpression(vector<string> {move(column_name)}) {
+ColumnRefExpression::ColumnRefExpression(string column_name)
+    : ColumnRefExpression(vector<string> {std::move(column_name)}) {
 }
 
 ColumnRefExpression::ColumnRefExpression(vector<string> column_names_p)
-    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF), column_names(move(column_names_p)) {
+    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF),
+      column_names(std::move(column_names_p)) {
 #ifdef DEBUG
 	for (auto &col_name : column_names) {
 		D_ASSERT(!col_name.empty());
@@ -59,7 +61,7 @@ string ColumnRefExpression::ToString() const {
 	return result;
 }
 
-bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
+bool ColumnRefExpression::Equal(const ColumnRefExpression *a, const ColumnRefExpression *b) {
 	if (a->column_names.size() != b->column_names.size()) {
 		return false;
 	}
@@ -85,7 +87,7 @@ hash_t ColumnRefExpression::Hash() const {
 unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
 	auto copy = make_unique<ColumnRefExpression>(column_names);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void ColumnRefExpression::Serialize(FieldWriter &writer) const {
@@ -94,8 +96,8 @@ void ColumnRefExpression::Serialize(FieldWriter &writer) const {
 
 unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto column_names = reader.ReadRequiredList<string>();
-	auto expression = make_unique<ColumnRefExpression>(move(column_names));
-	return move(expression);
+	auto expression = make_unique<ColumnRefExpression>(std::move(column_names));
+	return std::move(expression);
 }
 
 } // namespace duckdb