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

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -1,10 +1,8 @@
 #include "duckdb/execution/index/art/prefix.hpp"
 
-namespace duckdb {
+#include "duckdb/execution/index/art/art.hpp"
 
-uint32_t Prefix::Size() const {
-	return size;
-}
+namespace duckdb {
 
 bool Prefix::IsInlined() const {
 	return size <= PREFIX_INLINE_BYTES;
@@ -60,6 +58,10 @@ Prefix::~Prefix() {
 	Destroy();
 }
 
+idx_t Prefix::MemorySize() {
+	return sizeof(*this) + sizeof(uint8_t) * size;
+}
+
 void Prefix::Destroy() {
 	if (!IsInlined()) {
 		DeleteArray<uint8_t>(value.ptr, size);
@@ -99,6 +101,7 @@ void Prefix::Overwrite(uint32_t new_size, uint8_t *data) {
 			prefix[i] = data[i];
 		}
 		DeleteArray<uint8_t>(data, new_size);
+
 	} else {
 		// new entry would not be inlined
 		// take over the data directly
@@ -108,40 +111,47 @@ void Prefix::Overwrite(uint32_t new_size, uint8_t *data) {
 	}
 }
 
-void Prefix::Concatenate(uint8_t key, Prefix &other) {
-	auto new_length = size + 1 + other.size;
+void Prefix::Concatenate(ART &art, uint8_t key, Prefix &other) {
+	auto new_size = size + 1 + other.size;
+	art.memory_size += (new_size - size) * sizeof(uint8_t);
 	// have to allocate space in our prefix array
-	auto new_prefix = AllocateArray<uint8_t>(new_length);
+	auto new_prefix = AllocateArray<uint8_t>(new_size);
 	idx_t new_prefix_idx = 0;
+
 	// 1) add the to-be deleted node's prefix
 	for (uint32_t i = 0; i < other.size; i++) {
 		new_prefix[new_prefix_idx++] = other[i];
 	}
-	// 2) now move the current key as part of the prefix
+
+	// 2) now move the current partial key byte as part of the prefix
 	new_prefix[new_prefix_idx++] = key;
+
 	// 3) move the existing prefix (if any)
 	auto prefix = GetPrefixData();
 	for (uint32_t i = 0; i < size; i++) {
 		new_prefix[new_prefix_idx++] = prefix[i];
 	}
-	Overwrite(new_length, new_prefix);
+	Overwrite(new_size, new_prefix);
 }
 
-uint8_t Prefix::Reduce(uint32_t n) {
+uint8_t Prefix::Reduce(ART &art, uint32_t n) {
 	auto new_size = size - n - 1;
+	D_ASSERT(art.memory_size >= (size - new_size) * sizeof(uint8_t));
+	art.memory_size -= (size - new_size) * sizeof(uint8_t);
 	auto prefix = GetPrefixData();
-	auto key = prefix[n];
+	auto partial_key = prefix[n];
+
 	if (new_size == 0) {
 		Destroy();
 		size = 0;
-		return key;
+		return partial_key;
 	}
 	auto new_prefix = AllocateArray<uint8_t>(new_size);
 	for (idx_t i = 0; i < new_size; i++) {
 		new_prefix[i] = prefix[i + n + 1];
 	}
 	Overwrite(new_size, new_prefix);
-	return key;
+	return partial_key;
 }
 
 void Prefix::Serialize(duckdb::MetaBlockWriter &writer) {
@@ -157,7 +167,7 @@ void Prefix::Deserialize(duckdb::MetaBlockReader &reader) {
 	reader.ReadData(prefix, size);
 }
 
-uint32_t Prefix::KeyMismatchPosition(Key &key, uint64_t depth) {
+uint32_t Prefix::KeyMismatchPosition(Key &key, uint32_t depth) {
 	uint64_t pos;
 	auto prefix = GetPrefixData();
 	for (pos = 0; pos < size; pos++) {

package/src/duckdb/src/execution/index/art/swizzleable_pointer.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/execution/index/art/swizzleable_pointer.hpp"
 
+#include "duckdb/execution/index/art/art.hpp"
+
 namespace duckdb {
 SwizzleablePointer::~SwizzleablePointer() {
 	if (pointer) {
@@ -11,8 +13,8 @@ SwizzleablePointer::~SwizzleablePointer() {
 
 SwizzleablePointer::SwizzleablePointer(duckdb::MetaBlockReader &reader) {
 	idx_t block_id = reader.Read<block_id_t>();
-	idx_t offset = reader.Read<uint32_t>();
-	if (block_id == DConstants::INVALID_INDEX || offset == DConstants::INVALID_INDEX) {
+	uint32_t offset = reader.Read<uint32_t>();
+	if (block_id == DConstants::INVALID_INDEX || offset == (uint32_t)DConstants::INVALID_INDEX) {
 		pointer = 0;
 		return;
 	}
@@ -78,6 +80,7 @@ Node *SwizzleablePointer::Unswizzle(ART &art) {
 		// first we unset the bae
 		auto block_info = GetSwizzledBlockInfo();
 		*this = Node::Deserialize(art, block_info.block_id, block_info.offset);
+		art.Verify();
 	}
 	return (Node *)pointer;
 }

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -18,9 +18,9 @@ using ProbeSpillLocalState = JoinHashTable::ProbeSpillLocalAppendState;
 
 JoinHashTable::JoinHashTable(BufferManager &buffer_manager, const vector<JoinCondition> &conditions,
                              vector<LogicalType> btypes, JoinType type)
-    : buffer_manager(buffer_manager), conditions(conditions), build_types(move(btypes)), entry_size(0), tuple_size(0),
-      vfound(Value::BOOLEAN(false)), join_type(type), finalized(false), has_null(false), external(false), radix_bits(4),
-      tuples_per_round(0), partition_start(0), partition_end(0) {
+    : buffer_manager(buffer_manager), conditions(conditions), build_types(std::move(btypes)), entry_size(0),
+      tuple_size(0), vfound(Value::BOOLEAN(false)), join_type(type), finalized(false), has_null(false), external(false),
+      radix_bits(4), tuples_per_round(0), partition_start(0), partition_end(0) {
 	for (auto &condition : conditions) {
 		D_ASSERT(condition.left->return_type == condition.right->return_type);
 		auto type = condition.left->return_type;
@@ -93,9 +93,9 @@ void JoinHashTable::Merge(JoinHashTable &other) {
 		D_ASSERT(partition_string_heaps.empty());
 		// Move partitions to this HT
 		for (idx_t p = 0; p < other.partition_block_collections.size(); p++) {
-			partition_block_collections.push_back(move(other.partition_block_collections[p]));
+			partition_block_collections.push_back(std::move(other.partition_block_collections[p]));
 			if (!layout.AllConstant()) {
-				partition_string_heaps.push_back(move(other.partition_string_heaps[p]));
+				partition_string_heaps.push_back(std::move(other.partition_string_heaps[p]));
 			}
 		}
 		return;
@@ -254,7 +254,7 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 	// serialize the keys to the key locations
 	for (idx_t i = 0; i < keys.ColumnCount(); i++) {
 		source_chunk.data[i].Reference(keys.data[i]);
-		source_data.emplace_back(move(key_data[i]));
+		source_data.emplace_back(std::move(key_data[i]));
 	}
 	// now serialize the payload
 	D_ASSERT(build_types.size() == payload.ColumnCount());
@@ -262,21 +262,21 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 		source_chunk.data[source_data.size()].Reference(payload.data[i]);
 		UnifiedVectorFormat pdata;
 		payload.data[i].ToUnifiedFormat(payload.size(), pdata);
-		source_data.emplace_back(move(pdata));
+		source_data.emplace_back(std::move(pdata));
 	}
 	if (IsRightOuterJoin(join_type)) {
 		// for FULL/RIGHT OUTER joins initialize the "found" boolean to false
 		source_chunk.data[source_data.size()].Reference(vfound);
 		UnifiedVectorFormat fdata;
 		vfound.ToUnifiedFormat(keys.size(), fdata);
-		source_data.emplace_back(move(fdata));
+		source_data.emplace_back(std::move(fdata));
 	}
 
 	// serialise the hashes at the end
 	source_chunk.data[source_data.size()].Reference(hash_values);
 	UnifiedVectorFormat hdata;
 	hash_values.ToUnifiedFormat(keys.size(), hdata);
-	source_data.emplace_back(move(hdata));
+	source_data.emplace_back(std::move(hdata));
 
 	source_chunk.SetCardinality(keys);
 
@@ -364,7 +364,7 @@ void JoinHashTable::Finalize(idx_t block_idx_start, idx_t block_idx_end, bool pa
 			auto &heap_block = string_heap->blocks[block_idx];
 			auto heap_handle = buffer_manager.Pin(heap_block->block);
 			heap_ptr = heap_handle.Ptr();
-			local_pinned_handles.push_back(move(heap_handle));
+			local_pinned_handles.push_back(std::move(heap_handle));
 		}
 
 		idx_t entry = 0;
@@ -386,12 +386,12 @@ void JoinHashTable::Finalize(idx_t block_idx_start, idx_t block_idx_end, bool pa
 
 			entry += next;
 		}
-		local_pinned_handles.push_back(move(handle));
+		local_pinned_handles.push_back(std::move(handle));
 	}
 
 	lock_guard<mutex> lock(pinned_handles_lock);
 	for (auto &local_pinned_handle : local_pinned_handles) {
-		pinned_handles.push_back(move(local_pinned_handle));
+		pinned_handles.push_back(std::move(local_pinned_handle));
 	}
 }
 
@@ -444,7 +444,6 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
 	if (finished) {
 		return;
 	}
-
 	switch (ht.join_type) {
 	case JoinType::INNER:
 	case JoinType::RIGHT:
@@ -823,10 +822,10 @@ void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &input, DataChunk
 	for (idx_t i = 0; i < ht.build_types.size(); i++) {
 		auto &vector = result.data[input.ColumnCount() + i];
 		// set NULL entries for every entry that was not found
-		auto &mask = FlatVector::Validity(vector);
-		mask.SetAllInvalid(input.size());
-		for (idx_t j = 0; j < result_count; j++) {
-			mask.SetValid(result_sel.get_index(j));
+		for (idx_t j = 0; j < input.size(); j++) {
+			if (!found_match[j]) {
+				FlatVector::SetNull(vector, j, true);
+			}
 		}
 		// for the remaining values we fetch the values
 		GatherResult(vector, result_sel, result_sel, result_count, i + ht.condition_types.size());
@@ -1238,7 +1237,7 @@ void ProbeSpill::Finalize() {
 			global_spill_collection =
 			    make_unique<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types);
 		} else {
-			global_spill_collection = move(local_spill_collections[0]);
+			global_spill_collection = std::move(local_spill_collections[0]);
 			for (idx_t i = 1; i < local_spill_collections.size(); i++) {
 				global_spill_collection->Combine(*local_spill_collections[i]);
 			}
@@ -1257,7 +1256,7 @@ void ProbeSpill::PrepareNextProbe() {
 			    make_unique<ColumnDataCollection>(BufferManager::GetBufferManager(context), probe_types);
 		} else {
 			// Move specific partitions to the global spill collection
-			global_spill_collection = move(partitions[ht.partition_start]);
+			global_spill_collection = std::move(partitions[ht.partition_start]);
 			for (idx_t i = ht.partition_start + 1; i < ht.partition_end; i++) {
 				global_spill_collection->Combine(*partitions[i]);
 			}

package/src/duckdb/src/execution/operator/aggregate/aggregate_object.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 AggregateObject::AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count,
                                  idx_t payload_size, AggregateType aggr_type, PhysicalType return_type,
                                  Expression *filter)
-    : function(move(function)), bind_data(bind_data), child_count(child_count), payload_size(payload_size),
+    : function(std::move(function)), bind_data(bind_data), child_count(child_count), payload_size(payload_size),
       aggr_type(aggr_type), return_type(return_type), filter(filter) {
 }
 

package/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 //! Shared information about a collection of distinct aggregates
 DistinctAggregateCollectionInfo::DistinctAggregateCollectionInfo(const vector<unique_ptr<Expression>> &aggregates,
                                                                  vector<idx_t> indices)
-    : indices(move(indices)), aggregates(aggregates) {
+    : indices(std::move(indices)), aggregates(aggregates) {
 	table_count = CreateTableIndexMap();
 
 	const idx_t aggregate_count = aggregates.size();
@@ -193,7 +193,7 @@ DistinctAggregateCollectionInfo::Create(vector<unique_ptr<Expression>> &aggregat
 	if (indices.empty()) {
 		return nullptr;
 	}
-	return make_unique<DistinctAggregateCollectionInfo>(aggregates, move(indices));
+	return make_unique<DistinctAggregateCollectionInfo>(aggregates, std::move(indices));
 }
 
 bool DistinctAggregateData::IsDistinct(idx_t index) const {

package/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp

@@ -13,7 +13,7 @@ const vector<vector<idx_t>> &GroupedAggregateData::GetGroupingFunctions() const
 void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> groups,
                                              vector<unique_ptr<Expression>> expressions,
                                              vector<vector<idx_t>> grouping_functions) {
-	InitializeGroupbyGroups(move(groups));
+	InitializeGroupbyGroups(std::move(groups));
 	vector<LogicalType> payload_types_filters;
 
 	SetGroupingFunctions(grouping_functions);
@@ -36,7 +36,7 @@ void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> grou
 		if (!aggr.function.combine) {
 			throw InternalException("Aggregate function %s is missing a combine method", aggr.function.name);
 		}
-		aggregates.push_back(move(expr));
+		aggregates.push_back(std::move(expr));
 	}
 	for (const auto &pay_filters : payload_types_filters) {
 		payload_types.push_back(pay_filters);
@@ -83,13 +83,13 @@ void GroupedAggregateData::InitializeGroupbyGroups(vector<unique_ptr<Expression>
 	for (auto &expr : groups) {
 		group_types.push_back(expr->return_type);
 	}
-	this->groups = move(groups);
+	this->groups = std::move(groups);
 }
 
 void GroupedAggregateData::SetGroupingFunctions(vector<vector<idx_t>> &functions) {
 	grouping_functions.reserve(functions.size());
 	for (idx_t i = 0; i < functions.size(); i++) {
-		grouping_functions.push_back(move(functions[i]));
+		grouping_functions.push_back(std::move(functions[i]));
 	}
 }
 

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -102,13 +102,14 @@ bool PhysicalHashAggregate::CanSkipRegularSink() const {
 
 PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
                                              vector<unique_ptr<Expression>> expressions, idx_t estimated_cardinality)
-    : PhysicalHashAggregate(context, move(types), move(expressions), {}, estimated_cardinality) {
+    : PhysicalHashAggregate(context, std::move(types), std::move(expressions), {}, estimated_cardinality) {
 }
 
 PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
                                              vector<unique_ptr<Expression>> expressions,
                                              vector<unique_ptr<Expression>> groups_p, idx_t estimated_cardinality)
-    : PhysicalHashAggregate(context, move(types), move(expressions), move(groups_p), {}, {}, estimated_cardinality) {
+    : PhysicalHashAggregate(context, std::move(types), std::move(expressions), std::move(groups_p), {}, {},
+                            estimated_cardinality) {
 }
 
 PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
@@ -116,8 +117,8 @@ PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<Logi
                                              vector<unique_ptr<Expression>> groups_p,
                                              vector<GroupingSet> grouping_sets_p,
                                              vector<vector<idx_t>> grouping_functions_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::HASH_GROUP_BY, move(types), estimated_cardinality),
-      grouping_sets(move(grouping_sets_p)) {
+    : PhysicalOperator(PhysicalOperatorType::HASH_GROUP_BY, std::move(types), estimated_cardinality),
+      grouping_sets(std::move(grouping_sets_p)) {
 	// get a list of all aggregates to be computed
 	const idx_t group_count = groups_p.size();
 	if (grouping_sets.empty()) {
@@ -125,11 +126,12 @@ PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<Logi
 		for (idx_t i = 0; i < group_count; i++) {
 			set.insert(i);
 		}
-		grouping_sets.push_back(move(set));
+		grouping_sets.push_back(std::move(set));
 	}
 	input_group_types = CreateGroupChunkTypes(groups_p);
 
-	grouped_aggregate_data.InitializeGroupby(move(groups_p), move(expressions), move(grouping_functions_p));
+	grouped_aggregate_data.InitializeGroupby(std::move(groups_p), std::move(expressions),
+	                                         std::move(grouping_functions_p));
 
 	auto &aggregates = grouped_aggregate_data.aggregates;
 	// filter_indexes must be pre-built, not lazily instantiated in parallel...
@@ -459,7 +461,7 @@ public:
 			table.ScheduleTasks(pipeline->executor, shared_from_this(), *grouping_gstate.table_state, tasks);
 		}
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 };
 
@@ -469,8 +471,8 @@ class HashAggregateFinalizeTask : public ExecutorTask {
 public:
 	HashAggregateFinalizeTask(Pipeline &pipeline, shared_ptr<Event> event_p, HashAggregateGlobalState &state_p,
 	                          ClientContext &context, const PhysicalHashAggregate &op)
-	    : ExecutorTask(pipeline.executor), pipeline(pipeline), event(move(event_p)), gstate(state_p), context(context),
-	      op(op) {
+	    : ExecutorTask(pipeline.executor), pipeline(pipeline), event(std::move(event_p)), gstate(state_p),
+	      context(context), op(op) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
@@ -505,7 +507,7 @@ public:
 		vector<unique_ptr<Task>> tasks;
 		tasks.push_back(make_unique<HashAggregateFinalizeTask>(*pipeline, shared_from_this(), gstate, context, op));
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 };
 
@@ -516,8 +518,8 @@ public:
 	HashDistinctAggregateFinalizeTask(Pipeline &pipeline, shared_ptr<Event> event_p, HashAggregateGlobalState &state_p,
 	                                  ClientContext &context, const PhysicalHashAggregate &op,
 	                                  vector<vector<unique_ptr<GlobalSourceState>>> &global_sources_p)
-	    : ExecutorTask(pipeline.executor), pipeline(pipeline), event(move(event_p)), gstate(state_p), context(context),
-	      op(op), global_sources(global_sources_p) {
+	    : ExecutorTask(pipeline.executor), pipeline(pipeline), event(std::move(event_p)), gstate(state_p),
+	      context(context), op(op), global_sources(global_sources_p) {
 	}
 
 	void AggregateDistinctGrouping(DistinctAggregateCollectionInfo &info,
@@ -657,13 +659,13 @@ public:
 			                                                               context, op, global_sources));
 		}
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 
 	void FinishEvent() override {
 		//! Now that everything is added to the main ht, we can actually finalize
 		auto new_event = make_shared<HashAggregateFinalizeEvent>(op, gstate, pipeline.get(), context);
-		this->InsertEvent(move(new_event));
+		this->InsertEvent(std::move(new_event));
 	}
 
 private:
@@ -691,7 +693,7 @@ private:
 				auto &radix_table_p = data.radix_tables[table_idx];
 				aggregate_sources.push_back(radix_table_p->GetGlobalSourceState(context));
 			}
-			grouping_sources.push_back(move(aggregate_sources));
+			grouping_sources.push_back(std::move(aggregate_sources));
 		}
 		return grouping_sources;
 	}
@@ -727,13 +729,13 @@ public:
 		}
 
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 
 	void FinishEvent() override {
 		//! Now that all tables are combined, it's time to do the distinct aggregations
 		auto new_event = make_shared<HashDistinctAggregateFinalizeEvent>(op, gstate, *pipeline, client);
-		this->InsertEvent(move(new_event));
+		this->InsertEvent(std::move(new_event));
 	}
 };
 
@@ -765,12 +767,12 @@ SinkFinalizeType PhysicalHashAggregate::FinalizeDistinct(Pipeline &pipeline, Eve
 	if (any_partitioned) {
 		// If any of the groupings are partitioned then we first need to combine those, then aggregate
 		auto new_event = make_shared<HashDistinctCombineFinalizeEvent>(*this, gstate, pipeline, context);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 	} else {
 		// Hashtables aren't partitioned, they dont need to be joined first
 		// so we can already compute the aggregate
 		auto new_event = make_shared<HashDistinctAggregateFinalizeEvent>(*this, gstate, pipeline, context);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 	}
 	return SinkFinalizeType::READY;
 }
@@ -798,7 +800,7 @@ SinkFinalizeType PhysicalHashAggregate::FinalizeInternal(Pipeline &pipeline, Eve
 	}
 	if (any_partitioned) {
 		auto new_event = make_shared<HashAggregateMergeEvent>(*this, gstate, &pipeline);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 	}
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp

@@ -13,15 +13,15 @@ PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &contex
                                                            vector<unique_ptr<Expression>> groups_p,
                                                            vector<unique_ptr<BaseStatistics>> group_stats,
                                                            vector<idx_t> required_bits_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PERFECT_HASH_GROUP_BY, move(types_p), estimated_cardinality),
-      groups(move(groups_p)), aggregates(move(aggregates_p)), required_bits(move(required_bits_p)) {
+    : PhysicalOperator(PhysicalOperatorType::PERFECT_HASH_GROUP_BY, std::move(types_p), estimated_cardinality),
+      groups(std::move(groups_p)), aggregates(std::move(aggregates_p)), required_bits(std::move(required_bits_p)) {
 	D_ASSERT(groups.size() == group_stats.size());
 	group_minima.reserve(group_stats.size());
 	for (auto &stats : group_stats) {
 		D_ASSERT(stats);
 		auto &nstats = (NumericStatistics &)*stats;
 		D_ASSERT(!nstats.min.IsNull());
-		group_minima.push_back(move(nstats.min));
+		group_minima.push_back(std::move(nstats.min));
 	}
 	for (auto &expr : groups) {
 		group_types.push_back(expr->return_type);

package/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 
 PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
                                                  idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
+    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
 }
 
 class StreamingWindowGlobalState : public GlobalOperatorState {

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -20,8 +20,8 @@ namespace duckdb {
 PhysicalUngroupedAggregate::PhysicalUngroupedAggregate(vector<LogicalType> types,
                                                        vector<unique_ptr<Expression>> expressions,
                                                        idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::UNGROUPED_AGGREGATE, move(types), estimated_cardinality),
-      aggregates(move(expressions)) {
+    : PhysicalOperator(PhysicalOperatorType::UNGROUPED_AGGREGATE, std::move(types), estimated_cardinality),
+      aggregates(std::move(expressions)) {
 
 	distinct_collection_info = DistinctAggregateCollectionInfo::Create(aggregates);
 	if (!distinct_collection_info) {
@@ -40,7 +40,7 @@ struct AggregateState {
 			auto &aggr = (BoundAggregateExpression &)*aggregate;
 			auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
 			aggr.function.initialize(state.get());
-			aggregates.push_back(move(state));
+			aggregates.push_back(std::move(state));
 			destructors.push_back(aggr.function.destructor);
 #ifdef DEBUG
 			counts.push_back(0);
@@ -61,8 +61,8 @@ struct AggregateState {
 	}
 
 	void Move(AggregateState &other) {
-		other.aggregates = move(aggregates);
-		other.destructors = move(destructors);
+		other.aggregates = std::move(aggregates);
+		other.destructors = std::move(destructors);
 	}
 
 	//! The aggregate values
@@ -337,7 +337,7 @@ public:
 	UngroupedDistinctAggregateFinalizeTask(Executor &executor, shared_ptr<Event> event_p,
 	                                       UngroupedAggregateGlobalState &state_p, ClientContext &context,
 	                                       const PhysicalUngroupedAggregate &op)
-	    : ExecutorTask(executor), event(move(event_p)), gstate(state_p), context(context), op(op) {
+	    : ExecutorTask(executor), event(std::move(event_p)), gstate(state_p), context(context), op(op) {
 	}
 
 	void AggregateDistinct() {
@@ -440,7 +440,7 @@ public:
 		tasks.push_back(make_unique<UngroupedDistinctAggregateFinalizeTask>(pipeline->executor, shared_from_this(),
 		                                                                    gstate, context, op));
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 };
 
@@ -466,13 +466,13 @@ public:
 			                                                     *distinct_state.radix_states[table_idx], tasks);
 		}
 		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
+		SetTasks(std::move(tasks));
 	}
 
 	void FinishEvent() override {
 		//! Now that all tables are combined, it's time to do the distinct aggregations
 		auto new_event = make_shared<UngroupedDistinctAggregateFinalizeEvent>(op, gstate, *pipeline, client);
-		this->InsertEvent(move(new_event));
+		this->InsertEvent(std::move(new_event));
 	}
 };
 
@@ -493,12 +493,12 @@ SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline
 	}
 	if (any_partitioned) {
 		auto new_event = make_shared<UngroupedDistinctCombineFinalizeEvent>(*this, gstate, pipeline, context);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 	} else {
 		//! Hashtables aren't partitioned, they dont need to be joined first
 		//! So we can compute the aggregate already
 		auto new_event = make_shared<UngroupedDistinctAggregateFinalizeEvent>(*this, gstate, pipeline, context);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 	}
 	return SinkFinalizeType::READY;
 }