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

package/src/duckdb/src/common/pipe_file_system.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 class PipeFile : public FileHandle {
 public:
 	PipeFile(unique_ptr<FileHandle> child_handle_p, const string &path)
-	    : FileHandle(pipe_fs, path), child_handle(move(child_handle_p)) {
+	    : FileHandle(pipe_fs, path), child_handle(std::move(child_handle_p)) {
 	}
 
 	PipeFileSystem pipe_fs;
@@ -50,7 +50,7 @@ void PipeFileSystem::FileSync(FileHandle &handle) {
 
 unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
 	auto path = handle->path;
-	return make_unique<PipeFile>(move(handle), path);
+	return make_unique<PipeFile>(std::move(handle), path);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/preserved_error.cpp

@@ -26,7 +26,7 @@ const string &PreservedError::Message() {
 }
 
 string PreservedError::SanitizeErrorMessage(string error) {
-	return StringUtil::Replace(move(error), string("\0", 1), "\\0");
+	return StringUtil::Replace(std::move(error), string("\0", 1), "\\0");
 }
 
 void PreservedError::Throw(const string &prepended_message) const {

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -11,7 +11,7 @@
 namespace duckdb {
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&...args) {
+RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&... args) {
 	D_ASSERT(radix_bits <= sizeof(hash_t) * 8);
 	switch (radix_bits) {
 	case 1:
@@ -40,7 +40,7 @@ RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&...args) {
 }
 
 template <class OP, class RETURN_TYPE, idx_t radix_bits_1, typename... ARGS>
-RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&...args) {
+RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&... args) {
 	D_ASSERT(radix_bits_2 <= sizeof(hash_t) * 8);
 	switch (radix_bits_2) {
 	case 1:
@@ -69,7 +69,7 @@ RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&...args) {
 }
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE DoubleRadixBitsSwitch1(idx_t radix_bits_1, idx_t radix_bits_2, ARGS &&...args) {
+RETURN_TYPE DoubleRadixBitsSwitch1(idx_t radix_bits_1, idx_t radix_bits_2, ARGS &&... args) {
 	D_ASSERT(radix_bits_1 <= sizeof(hash_t) * 8);
 	switch (radix_bits_1) {
 	case 1:
@@ -422,7 +422,7 @@ void RadixPartitioning::PartitionRowData(BufferManager &buffer_manager, const Ro
 //===--------------------------------------------------------------------===//
 RadixPartitionedColumnData::RadixPartitionedColumnData(ClientContext &context_p, vector<LogicalType> types_p,
                                                        idx_t radix_bits_p, idx_t hash_col_idx_p)
-    : PartitionedColumnData(PartitionedColumnDataType::RADIX, context_p, move(types_p)), radix_bits(radix_bits_p),
+    : PartitionedColumnData(PartitionedColumnDataType::RADIX, context_p, std::move(types_p)), radix_bits(radix_bits_p),
       hash_col_idx(hash_col_idx_p) {
 	D_ASSERT(hash_col_idx < types.size());
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
@@ -435,6 +435,7 @@ RadixPartitionedColumnData::RadixPartitionedColumnData(ClientContext &context_p,
 
 RadixPartitionedColumnData::RadixPartitionedColumnData(const RadixPartitionedColumnData &other)
     : PartitionedColumnData(other), radix_bits(other.radix_bits), hash_col_idx(other.hash_col_idx) {
+
 	for (idx_t i = 0; i < RadixPartitioning::NumberOfPartitions(radix_bits); i++) {
 		partitions.emplace_back(CreatePartitionCollection(i));
 	}

package/src/duckdb/src/common/row_operations/row_aggregate.cpp

@@ -22,7 +22,7 @@ void RowOperations::InitializeStates(RowLayout &layout, Vector &addresses, const
 	auto &offsets = layout.GetOffsets();
 	auto aggr_idx = layout.ColumnCount();
 
-	for (auto &aggr : layout.GetAggregates()) {
+	for (const auto &aggr : layout.GetAggregates()) {
 		for (idx_t i = 0; i < count; ++i) {
 			auto row_idx = sel.get_index(i);
 			auto row = pointers[row_idx];
@@ -38,7 +38,7 @@ void RowOperations::DestroyStates(RowLayout &layout, Vector &addresses, idx_t co
 	}
 	//	Move to the first aggregate state
 	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), count);
-	for (auto &aggr : layout.GetAggregates()) {
+	for (const auto &aggr : layout.GetAggregates()) {
 		if (aggr.function.destructor) {
 			aggr.function.destructor(addresses, count);
 		}

package/src/duckdb/src/common/serializer/buffered_serializer.cpp

@@ -10,7 +10,7 @@ BufferedSerializer::BufferedSerializer(idx_t maximum_size)
 
 BufferedSerializer::BufferedSerializer(unique_ptr<data_t[]> data, idx_t size) : maximum_size(size), data(data.get()) {
 	blob.size = 0;
-	blob.data = move(data);
+	blob.data = std::move(data);
 }
 
 BufferedSerializer::BufferedSerializer(data_ptr_t data, idx_t size) : maximum_size(size), data(data) {

package/src/duckdb/src/common/sort/merge_sorter.cpp

@@ -334,8 +334,8 @@ void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
 
 	auto &l_blocks = l.sb->radix_sorting_data;
 	auto &r_blocks = r.sb->radix_sorting_data;
-	RowDataBlock *l_block;
-	RowDataBlock *r_block;
+	RowDataBlock *l_block = nullptr;
+	RowDataBlock *r_block = nullptr;
 
 	data_ptr_t l_ptr;
 	data_ptr_t r_ptr;
@@ -364,18 +364,24 @@ void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
 		const bool l_done = l.block_idx == l_blocks.size();
 		const bool r_done = r.block_idx == r_blocks.size();
 		// Pin the radix sortable blocks
+		idx_t l_count;
 		if (!l_done) {
 			l_block = l_blocks[l.block_idx].get();
 			left->PinRadix(l.block_idx);
 			l_ptr = l.RadixPtr();
+			l_count = l_block->count;
+		} else {
+			l_count = 0;
 		}
+		idx_t r_count;
 		if (!r_done) {
 			r_block = r_blocks[r.block_idx].get();
 			r.PinRadix(r.block_idx);
 			r_ptr = r.RadixPtr();
+			r_count = r_block->count;
+		} else {
+			r_count = 0;
 		}
-		const idx_t &l_count = !l_done ? l_block->count : 0;
-		const idx_t &r_count = !r_done ? r_block->count : 0;
 		// Copy using computed merge
 		if (!l_done && !r_done) {
 			// Both sides have data - merge
@@ -420,7 +426,7 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 	auto result_data_handle = buffer_manager.Pin(result_data_block->block);
 	data_ptr_t result_data_ptr = result_data_handle.Ptr() + result_data_block->count * row_width;
 	// Result heap to write to (if needed)
-	RowDataBlock *result_heap_block;
+	RowDataBlock *result_heap_block = nullptr;
 	BufferHandle result_heap_handle;
 	data_ptr_t result_heap_ptr;
 	if (!layout.AllConstant() && state.external) {

package/src/duckdb/src/common/sort/sort_state.cpp

@@ -1,9 +1,10 @@
 #include "duckdb/common/fast_mem.hpp"
+#include "duckdb/common/radix.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/sort/sorted_block.hpp"
 #include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/common/radix.hpp"
+
 #include <algorithm>
 #include <numeric>
 
@@ -237,16 +238,16 @@ void LocalSortState::Sort(GlobalSortState &global_sort_state, bool reorder_heap)
 	auto &sb = *sorted_blocks.back();
 	// Fixed-size sorting data
 	auto sorting_block = ConcatenateBlocks(*radix_sorting_data);
-	sb.radix_sorting_data.push_back(move(sorting_block));
+	sb.radix_sorting_data.push_back(std::move(sorting_block));
 	// Variable-size sorting data
 	if (!sort_layout->all_constant) {
 		auto &blob_data = *blob_sorting_data;
 		auto new_block = ConcatenateBlocks(blob_data);
-		sb.blob_sorting_data->data_blocks.push_back(move(new_block));
+		sb.blob_sorting_data->data_blocks.push_back(std::move(new_block));
 	}
 	// Payload data
 	auto payload_block = ConcatenateBlocks(*payload_data);
-	sb.payload_data->data_blocks.push_back(move(payload_block));
+	sb.payload_data->data_blocks.push_back(std::move(payload_block));
 	// Now perform the actual sort
 	SortInMemory();
 	// Re-order before the merge sort
@@ -256,7 +257,7 @@ void LocalSortState::Sort(GlobalSortState &global_sort_state, bool reorder_heap)
 unique_ptr<RowDataBlock> LocalSortState::ConcatenateBlocks(RowDataCollection &row_data) {
 	//	Don't copy and delete if there is only one block.
 	if (row_data.blocks.size() == 1) {
-		auto new_block = move(row_data.blocks[0]);
+		auto new_block = std::move(row_data.blocks[0]);
 		row_data.blocks.clear();
 		row_data.count = 0;
 		return new_block;
@@ -270,10 +271,12 @@ unique_ptr<RowDataBlock> LocalSortState::ConcatenateBlocks(RowDataCollection &ro
 	auto new_block_handle = buffer_manager->Pin(new_block->block);
 	data_ptr_t new_block_ptr = new_block_handle.Ptr();
 	// Copy the data of the blocks into a single block
-	for (auto &block : row_data.blocks) {
+	for (idx_t i = 0; i < row_data.blocks.size(); i++) {
+		auto &block = row_data.blocks[i];
 		auto block_handle = buffer_manager->Pin(block->block);
 		memcpy(new_block_ptr, block_handle.Ptr(), block->count * entry_size);
 		new_block_ptr += block->count * entry_size;
+		block.reset();
 	}
 	row_data.blocks.clear();
 	row_data.count = 0;
@@ -302,10 +305,10 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 		ordered_data_ptr += row_width;
 		sorting_ptr += sorting_entry_size;
 	}
-	ordered_data_block->block->SetSwizzling(sd.layout.AllConstant() ? nullptr : "LocalSortState::ReOrder.ordered_data");
+	ordered_data_block->block->SetSwizzling(sd.swizzled ? "LocalSortState::ReOrder.ordered_data" : nullptr);
 	// Replace the unordered data block with the re-ordered data block
 	sd.data_blocks.clear();
-	sd.data_blocks.push_back(move(ordered_data_block));
+	sd.data_blocks.push_back(std::move(ordered_data_block));
 	// Deal with the heap (if necessary)
 	if (!sd.layout.AllConstant() && reorder_heap) {
 		// Swizzle the column pointers to offsets
@@ -334,7 +337,7 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 		// Swizzle the base pointer to the offset of each row in the heap
 		RowOperations::SwizzleHeapPointer(sd.layout, ordered_data_handle.Ptr(), ordered_heap_handle.Ptr(), count);
 		// Move the re-ordered heap to the SortedData, and clear the local heap
-		sd.heap_blocks.push_back(move(ordered_heap_block));
+		sd.heap_blocks.push_back(std::move(ordered_heap_block));
 		heap.pinned_blocks.clear();
 		heap.blocks.clear();
 		heap.count = 0;
@@ -373,18 +376,18 @@ void GlobalSortState::AddLocalState(LocalSortState &local_sort_state) {
 	// Append local state sorted data to this global state
 	lock_guard<mutex> append_guard(lock);
 	for (auto &sb : local_sort_state.sorted_blocks) {
-		sorted_blocks.push_back(move(sb));
+		sorted_blocks.push_back(std::move(sb));
 	}
 	auto &payload_heap = local_sort_state.payload_heap;
 	for (idx_t i = 0; i < payload_heap->blocks.size(); i++) {
-		heap_blocks.push_back(move(payload_heap->blocks[i]));
-		pinned_blocks.push_back(move(payload_heap->pinned_blocks[i]));
+		heap_blocks.push_back(std::move(payload_heap->blocks[i]));
+		pinned_blocks.push_back(std::move(payload_heap->pinned_blocks[i]));
 	}
 	if (!sort_layout.all_constant) {
 		auto &blob_heap = local_sort_state.blob_sorting_heap;
 		for (idx_t i = 0; i < blob_heap->blocks.size(); i++) {
-			heap_blocks.push_back(move(blob_heap->blocks[i]));
-			pinned_blocks.push_back(move(blob_heap->pinned_blocks[i]));
+			heap_blocks.push_back(std::move(blob_heap->blocks[i]));
+			pinned_blocks.push_back(std::move(blob_heap->pinned_blocks[i]));
 		}
 	}
 }
@@ -429,7 +432,7 @@ void GlobalSortState::InitializeMergeRound() {
 	std::reverse(sorted_blocks.begin(), sorted_blocks.end());
 	// Uneven number of blocks - keep one on the side
 	if (sorted_blocks.size() % 2 == 1) {
-		odd_one_out = move(sorted_blocks.back());
+		odd_one_out = std::move(sorted_blocks.back());
 		sorted_blocks.pop_back();
 	}
 	// Init merge path path indices
@@ -451,7 +454,7 @@ void GlobalSortState::CompleteMergeRound(bool keep_radix_data) {
 	}
 	sorted_blocks_temp.clear();
 	if (odd_one_out) {
-		sorted_blocks.push_back(move(odd_one_out));
+		sorted_blocks.push_back(std::move(odd_one_out));
 		odd_one_out = nullptr;
 	}
 	// Only one block left: Done!

package/src/duckdb/src/common/sort/sorted_block.cpp

@@ -71,9 +71,10 @@ void SortedData::Unswizzle() {
 		auto heap_handle_p = buffer_manager.Pin(heap_block->block);
 		RowOperations::UnswizzlePointers(layout, data_handle_p.Ptr(), heap_handle_p.Ptr(), data_block->count);
 		data_block->block->SetSwizzling("SortedData::Unswizzle");
-		state.heap_blocks.push_back(move(heap_block));
-		state.pinned_blocks.push_back(move(heap_handle_p));
+		state.heap_blocks.push_back(std::move(heap_block));
+		state.pinned_blocks.push_back(std::move(heap_handle_p));
 	}
+	swizzled = false;
 	heap_blocks.clear();
 }
 
@@ -112,22 +113,22 @@ void SortedBlock::AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blo
 	D_ASSERT(Count() == 0);
 	for (auto &sb : sorted_blocks) {
 		for (auto &radix_block : sb->radix_sorting_data) {
-			radix_sorting_data.push_back(move(radix_block));
+			radix_sorting_data.push_back(std::move(radix_block));
 		}
 		if (!sort_layout.all_constant) {
 			for (auto &blob_block : sb->blob_sorting_data->data_blocks) {
-				blob_sorting_data->data_blocks.push_back(move(blob_block));
+				blob_sorting_data->data_blocks.push_back(std::move(blob_block));
 			}
 			for (auto &heap_block : sb->blob_sorting_data->heap_blocks) {
-				blob_sorting_data->heap_blocks.push_back(move(heap_block));
+				blob_sorting_data->heap_blocks.push_back(std::move(heap_block));
 			}
 		}
 		for (auto &payload_data_block : sb->payload_data->data_blocks) {
-			payload_data->data_blocks.push_back(move(payload_data_block));
+			payload_data->data_blocks.push_back(std::move(payload_data_block));
 		}
 		if (!payload_data->layout.AllConstant()) {
 			for (auto &payload_heap_block : sb->payload_data->heap_blocks) {
-				payload_data->heap_blocks.push_back(move(payload_heap_block));
+				payload_data->heap_blocks.push_back(std::move(payload_heap_block));
 			}
 		}
 	}
@@ -299,9 +300,9 @@ PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_
 
 	if (flush_p) {
 		// If we are flushing, we can just move the data
-		rows->blocks = move(sorted_data.data_blocks);
+		rows->blocks = std::move(sorted_data.data_blocks);
 		if (!layout.AllConstant()) {
-			heap->blocks = move(sorted_data.heap_blocks);
+			heap->blocks = std::move(sorted_data.heap_blocks);
 		}
 	} else {
 		// Not flushing, create references to the blocks
@@ -330,7 +331,7 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	// Create collections to put the data into so we can use RowDataCollectionScanner
 	rows = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
 	if (flush_p) {
-		rows->blocks.emplace_back(move(sorted_data.data_blocks[block_idx]));
+		rows->blocks.emplace_back(std::move(sorted_data.data_blocks[block_idx]));
 	} else {
 		rows->blocks.emplace_back(sorted_data.data_blocks[block_idx]->Copy());
 	}
@@ -339,7 +340,7 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	heap = make_unique<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
 	if (!sorted_data.layout.AllConstant() && sorted_data.swizzled) {
 		if (flush_p) {
-			heap->blocks.emplace_back(move(sorted_data.heap_blocks[block_idx]));
+			heap->blocks.emplace_back(std::move(sorted_data.heap_blocks[block_idx]));
 		} else {
 			heap->blocks.emplace_back(sorted_data.heap_blocks[block_idx]->Copy());
 		}

package/src/duckdb/src/common/string_util.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/common/string_util.hpp"
+
+#include "duckdb/common/exception.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/to_string.hpp"
-#include "duckdb/common/exception.hpp"
 
 #include <algorithm>
 #include <cctype>
@@ -31,6 +32,13 @@ void StringUtil::RTrim(string &str) {
 	          str.end());
 }
 
+void StringUtil::RTrim(string &str, const string &chars_to_trim) {
+	str.erase(find_if(str.rbegin(), str.rend(),
+	                  [&chars_to_trim](int ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; })
+	              .base(),
+	          str.end());
+}
+
 void StringUtil::Trim(string &str) {
 	StringUtil::LTrim(str);
 	StringUtil::RTrim(str);

package/src/duckdb/src/common/tree_renderer.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/execution/operator/join/physical_delim_join.hpp"
 #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 
 #include "utf8proc_wrapper.hpp"
@@ -37,7 +38,7 @@ idx_t RenderTree::GetPosition(idx_t x, idx_t y) {
 }
 
 void RenderTree::SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node) {
-	nodes[GetPosition(x, y)] = move(node);
+	nodes[GetPosition(x, y)] = std::move(node);
 }
 
 void TreeRenderer::RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y) {
@@ -357,8 +358,8 @@ string TreeRenderer::ExtraInfoSeparator() {
 
 unique_ptr<RenderTreeNode> TreeRenderer::CreateRenderNode(string name, string extra_info) {
 	auto result = make_unique<RenderTreeNode>();
-	result->name = move(name);
-	result->extra_text = move(extra_info);
+	result->name = std::move(name);
+	result->extra_text = std::move(extra_info);
 	return result;
 }
 
@@ -378,10 +379,13 @@ public:
 
 template <>
 bool TreeChildrenIterator::HasChildren(const PhysicalOperator &op) {
-	if (op.type == PhysicalOperatorType::DELIM_JOIN) {
+	switch (op.type) {
+	case PhysicalOperatorType::DELIM_JOIN:
+	case PhysicalOperatorType::POSITIONAL_SCAN:
 		return true;
+	default:
+		return !op.children.empty();
 	}
-	return !op.children.empty();
 }
 template <>
 void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
@@ -392,6 +396,11 @@ void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
 	if (op.type == PhysicalOperatorType::DELIM_JOIN) {
 		auto &delim = (PhysicalDelimJoin &)op;
 		callback(*delim.join);
+	} else if ((op.type == PhysicalOperatorType::POSITIONAL_SCAN)) {
+		auto &pscan = (PhysicalPositionalScan &)op;
+		for (auto &table : pscan.child_tables) {
+			callback(*table);
+		}
 	}
 }
 
@@ -438,7 +447,7 @@ static void GetTreeWidthHeight(const T &op, idx_t &width, idx_t &height) {
 template <class T>
 idx_t TreeRenderer::CreateRenderTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y) {
 	auto node = TreeRenderer::CreateNode(op);
-	result.SetNode(x, y, move(node));
+	result.SetNode(x, y, std::move(node));
 
 	if (!TreeChildrenIterator::HasChildren(op)) {
 		return 1;
@@ -536,8 +545,8 @@ unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &op) {
 	unique_ptr<PipelineRenderNode> node;
 	for (auto &op : operators) {
 		auto new_node = make_unique<PipelineRenderNode>(*op);
-		new_node->child = move(node);
-		node = move(new_node);
+		new_node->child = std::move(node);
+		node = std::move(new_node);
 	}
 	return CreateRenderTree<PipelineRenderNode>(*node);
 }

package/src/duckdb/src/common/types/batched_data_collection.cpp

@@ -4,7 +4,7 @@
 
 namespace duckdb {
 
-BatchedDataCollection::BatchedDataCollection(vector<LogicalType> types_p) : types(move(types_p)) {
+BatchedDataCollection::BatchedDataCollection(vector<LogicalType> types_p) : types(std::move(types_p)) {
 }
 
 void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
@@ -26,7 +26,7 @@ void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
 		last_collection.batch_index = batch_index;
 		new_collection->InitializeAppend(last_collection.append_state);
 		collection = new_collection.get();
-		data.insert(make_pair(batch_index, move(new_collection)));
+		data.insert(make_pair(batch_index, std::move(new_collection)));
 	}
 	collection->Append(last_collection.append_state, input);
 }
@@ -39,7 +39,7 @@ void BatchedDataCollection::Merge(BatchedDataCollection &other) {
 			    "batch indexes are not uniquely distributed over threads",
 			    entry.first);
 		}
-		data[entry.first] = move(entry.second);
+		data[entry.first] = std::move(entry.second);
 	}
 	other.data.clear();
 }
@@ -73,7 +73,7 @@ unique_ptr<ColumnDataCollection> BatchedDataCollection::FetchCollection() {
 	unique_ptr<ColumnDataCollection> result;
 	for (auto &entry : data) {
 		if (!result) {
-			result = move(entry.second);
+			result = std::move(entry.second);
 		} else {
 			result->Combine(*entry.second);
 		}