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

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

@@ -0,0 +1,278 @@
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/common/types/string_type.hpp"
+
+namespace duckdb {
+
+void Bit::SetEmptyBitString(string_t &target, string_t &input) {
+	char *res_buf = target.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
+	memset(res_buf, 0, input.GetSize());
+	res_buf[0] = buf[0];
+}
+
+idx_t Bit::BitLength(string_t bits) {
+	return ((bits.GetSize() - 1) * 8) - GetPadding(bits);
+}
+
+idx_t Bit::OctetLength(string_t bits) {
+	return bits.GetSize() - 1;
+}
+
+idx_t Bit::BitCount(string_t bits) {
+	idx_t count = 0;
+	const char *buf = bits.GetDataUnsafe();
+	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
+		}
+	}
+	return count;
+}
+
+idx_t Bit::BitPosition(string_t substring, string_t bits) {
+	const char *buf = bits.GetDataUnsafe();
+	auto len = bits.GetSize();
+	auto substr_len = BitLength(substring);
+	idx_t substr_idx = 0;
+
+	for (idx_t bit_idx = GetPadding(bits); bit_idx < 8; bit_idx++) {
+		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
+		if (bit == GetBit(substring, substr_idx)) {
+			substr_idx++;
+			if (substr_idx == substr_len) {
+				return (bit_idx - GetPadding(bits)) - substr_len + 2;
+			}
+		} else {
+			substr_idx = 0;
+		}
+	}
+
+	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
+			if (bit == GetBit(substring, substr_idx)) {
+				substr_idx++;
+				if (substr_idx == substr_len) {
+					return (((byte_idx - 1) * 8) + bit_idx - GetPadding(bits)) - substr_len + 2;
+				}
+			} else {
+				substr_idx = 0;
+			}
+		}
+	}
+	return 0;
+}
+
+void Bit::ToString(string_t bits, char *output) {
+	auto data = (const_data_ptr_t)bits.GetDataUnsafe();
+	auto len = bits.GetSize();
+
+	idx_t padding = GetPadding(bits);
+	idx_t output_idx = 0;
+	for (idx_t bit_idx = padding; bit_idx < 8; bit_idx++) {
+		output[output_idx++] = data[1] & (1 << (7 - bit_idx)) ? '1' : '0';
+	}
+	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			output[output_idx++] = data[byte_idx] & (1 << (7 - bit_idx)) ? '1' : '0';
+		}
+	}
+}
+
+string Bit::ToString(string_t str) {
+	auto len = BitLength(str);
+	auto buffer = std::unique_ptr<char[]>(new char[len]);
+	ToString(str, buffer.get());
+	return string(buffer.get(), len);
+}
+
+bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_message) {
+	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto len = str.GetSize();
+	str_len = 0;
+	for (idx_t i = 0; i < len; i++) {
+		if (data[i] == '0' || data[i] == '1') {
+			str_len++;
+		} else {
+			string error = StringUtil::Format("Invalid character encountered in string -> bit conversion: '%s'",
+			                                  string((char *)data + i, 1));
+			HandleCastError::AssignError(error, error_message);
+			return false;
+		}
+	}
+	str_len = str_len % 8 ? (str_len / 8) + 1 : str_len / 8;
+	str_len++; // additional first byte to store info on zero padding
+	return true;
+}
+
+idx_t Bit::GetBitSize(string_t str) {
+	string error_message;
+	idx_t str_len;
+	if (!Bit::TryGetBitStringSize(str, str_len, &error_message)) {
+		throw ConversionException(error_message);
+	}
+	return str_len;
+}
+
+void Bit::ToBit(string_t str, data_ptr_t output) {
+	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto len = str.GetSize();
+
+	char byte = 0;
+	idx_t padded_byte = len % 8;
+	for (idx_t i = 0; i < padded_byte; i++) {
+		byte <<= 1;
+		if (data[i] == '1') {
+			byte |= 1;
+		}
+	}
+	if (padded_byte != 0) {
+		*(output++) = (8 - padded_byte); // the first byte contains the number of padded zeroes
+	}
+	*(output++) = byte;
+
+	for (idx_t byte_idx = padded_byte; byte_idx < len; byte_idx += 8) {
+		byte = 0;
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			byte <<= 1;
+			if (data[byte_idx + bit_idx] == '1') {
+				byte |= 1;
+			}
+		}
+		*(output++) = byte;
+	}
+}
+
+string Bit::ToBit(string_t str) {
+	auto bit_len = GetBitSize(str);
+	auto buffer = std::unique_ptr<char[]>(new char[bit_len]);
+	Bit::ToBit(str, (data_ptr_t)buffer.get());
+	return string(buffer.get(), bit_len);
+}
+
+idx_t Bit::GetBit(string_t bit_string, idx_t n) {
+	const char *buf = bit_string.GetDataUnsafe();
+	n += GetPadding(bit_string);
+
+	char byte = buf[(n / 8) + 1] >> (7 - (n % 8));
+	return (byte & 1 ? 1 : 0);
+}
+
+void Bit::SetBit(const string_t &bit_string, idx_t n, idx_t new_value, string_t &result) {
+	char *result_buf = result.GetDataWriteable();
+	const char *buf = bit_string.GetDataUnsafe();
+	n += GetPadding(bit_string);
+
+	memcpy(result_buf, buf, bit_string.GetSize());
+	char shift_byte = 1 << (7 - (n % 8));
+	if (new_value == 0) {
+		shift_byte = ~shift_byte;
+		result_buf[(n / 8) + 1] = buf[(n / 8) + 1] & shift_byte;
+	} else {
+		result_buf[(n / 8) + 1] = buf[(n / 8) + 1] | shift_byte;
+	}
+}
+
+void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) {
+	char *buf = bit_string.GetDataWriteable();
+	n += GetPadding(bit_string);
+
+	char shift_byte = 1 << (7 - (n % 8));
+	if (new_value == 0) {
+		shift_byte = ~shift_byte;
+		buf[(n / 8) + 1] &= shift_byte;
+	} else {
+		buf[(n / 8) + 1] |= shift_byte;
+	}
+}
+
+inline idx_t Bit::GetPadding(const string_t &bit_string) {
+	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
+	return data[0];
+}
+
+// **** BITWISE OPERATORS ****
+void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
+	char *res_buf = result.GetDataWriteable();
+	const char *buf = bit_string.GetDataUnsafe();
+	res_buf[0] = buf[0];
+	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
+		if (i < shift) {
+			Bit::SetBit(result, i, 0);
+		} else {
+			idx_t bit = Bit::GetBit(bit_string, i - shift);
+			Bit::SetBit(result, i, bit);
+		}
+	}
+}
+
+void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
+	char *res_buf = result.GetDataWriteable();
+	const char *buf = bit_string.GetDataUnsafe();
+	res_buf[0] = buf[0];
+	for (idx_t i = 0; i < Bit::BitLength(bit_string); i++) {
+		if (i < (Bit::BitLength(bit_string) - shift)) {
+			idx_t bit = Bit::GetBit(bit_string, shift + i);
+			Bit::SetBit(result, i, bit);
+		} else {
+			Bit::SetBit(result, i, 0);
+		}
+	}
+}
+
+void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result) {
+	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
+		throw InvalidInputException("Cannot AND bit strings of different sizes");
+	}
+
+	char *buf = result.GetDataWriteable();
+	const char *r_buf = rhs.GetDataUnsafe();
+	const char *l_buf = lhs.GetDataUnsafe();
+
+	buf[0] = l_buf[0];
+	for (idx_t i = 1; i < lhs.GetSize(); i++) {
+		buf[i] = l_buf[i] & r_buf[i];
+	}
+}
+
+void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result) {
+	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
+		throw InvalidInputException("Cannot OR bit strings of different sizes");
+	}
+
+	char *buf = result.GetDataWriteable();
+	const char *r_buf = rhs.GetDataUnsafe();
+	const char *l_buf = lhs.GetDataUnsafe();
+
+	buf[0] = l_buf[0];
+	for (idx_t i = 1; i < lhs.GetSize(); i++) {
+		buf[i] = l_buf[i] | r_buf[i];
+	}
+}
+
+void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result) {
+	if (Bit::BitLength(lhs) != Bit::BitLength(rhs)) {
+		throw InvalidInputException("Cannot XOR bit strings of different sizes");
+	}
+
+	char *buf = result.GetDataWriteable();
+	const char *r_buf = rhs.GetDataUnsafe();
+	const char *l_buf = lhs.GetDataUnsafe();
+
+	buf[0] = l_buf[0];
+	for (idx_t i = 1; i < lhs.GetSize(); i++) {
+		buf[i] = l_buf[i] ^ r_buf[i];
+	}
+}
+
+void Bit::BitwiseNot(const string_t &input, string_t &result) {
+	char *result_buf = result.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
+
+	result_buf[0] = buf[0];
+	for (idx_t i = 1; i < input.GetSize(); i++) {
+		result_buf[i] = ~buf[i];
+	}
+}
+} // namespace duckdb

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

@@ -38,19 +38,19 @@ void ChunkCollection::Merge(ChunkCollection &other) {
 		return;
 	}
 	if (count == 0) {
-		chunks = move(other.chunks);
-		types = move(other.types);
+		chunks = std::move(other.chunks);
+		types = std::move(other.types);
 		count = other.count;
 		return;
 	}
 	unique_ptr<DataChunk> old_back;
 	if (!chunks.empty() && chunks.back()->size() != STANDARD_VECTOR_SIZE) {
-		old_back = move(chunks.back());
+		old_back = std::move(chunks.back());
 		chunks.pop_back();
 		count -= old_back->size();
 	}
 	for (auto &chunk : other.chunks) {
-		chunks.push_back(move(chunk));
+		chunks.push_back(std::move(chunk));
 	}
 	count += other.count;
 	if (old_back) {
@@ -122,7 +122,7 @@ void ChunkCollection::Append(DataChunk &new_chunk) {
 		auto chunk = make_unique<DataChunk>();
 		chunk->Initialize(allocator, types);
 		new_chunk.Copy(*chunk, offset);
-		chunks.push_back(move(chunk));
+		chunks.push_back(std::move(chunk));
 	}
 }
 
@@ -132,7 +132,7 @@ void ChunkCollection::Append(unique_ptr<DataChunk> new_chunk) {
 	}
 	D_ASSERT(types == new_chunk->GetTypes());
 	count += new_chunk->size();
-	chunks.push_back(move(new_chunk));
+	chunks.push_back(std::move(new_chunk));
 }
 
 void ChunkCollection::Fuse(ChunkCollection &other) {
@@ -146,7 +146,7 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 				lhs->data.emplace_back(Vector(v));
 			}
 			lhs->SetCardinality(rhs.size());
-			chunks.push_back(move(lhs));
+			chunks.push_back(std::move(lhs));
 		}
 		count = other.Count();
 	} else {

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

@@ -63,7 +63,7 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 	data.size = 0;
 	data.capacity = block_size;
 	auto pin = alloc.buffer_manager->Allocate(block_size, false, &data.handle);
-	blocks.push_back(move(data));
+	blocks.push_back(std::move(data));
 	return pin;
 }
 
@@ -79,7 +79,7 @@ void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
 	data.size = 0;
 	data.capacity = allocation_amount;
 	data.handle = nullptr;
-	blocks.push_back(move(data));
+	blocks.push_back(std::move(data));
 }
 
 void ColumnDataAllocator::AssignPointer(uint32_t &block_id, uint32_t &offset, data_ptr_t pointer) {
@@ -102,7 +102,7 @@ void ColumnDataAllocator::AllocateBuffer(idx_t size, uint32_t &block_id, uint32_
 		if (chunk_state) {
 			D_ASSERT(!blocks.empty());
 			auto new_block_id = blocks.size() - 1;
-			chunk_state->handles[new_block_id] = move(pinned_block);
+			chunk_state->handles[new_block_id] = std::move(pinned_block);
 		}
 	}
 	auto &block = blocks.back();
@@ -123,7 +123,7 @@ void ColumnDataAllocator::AllocateMemory(idx_t size, uint32_t &block_id, uint32_
 		AllocateEmptyBlock(size);
 		auto &last_block = blocks.back();
 		auto allocated = alloc.allocator->Allocate(last_block.capacity);
-		allocated_data.push_back(move(allocated));
+		allocated_data.push_back(std::move(allocated));
 	}
 	auto &block = blocks.back();
 	D_ASSERT(size <= block.capacity - block.size);
@@ -182,8 +182,8 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	auto strings = FlatVector::GetData<string_t>(result);
 
 	// find first non-inlined string
-	auto i = v_offset;
-	const auto end = v_offset + count;
+	uint32_t i = v_offset;
+	const uint32_t end = v_offset + count;
 	for (; i < end; i++) {
 		if (!validity.RowIsValid(i)) {
 			continue;

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

@@ -51,23 +51,23 @@ ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p) {
 }
 
 ColumnDataCollection::ColumnDataCollection(Allocator &allocator_p, vector<LogicalType> types_p) {
-	Initialize(move(types_p));
+	Initialize(std::move(types_p));
 	allocator = make_shared<ColumnDataAllocator>(allocator_p);
 }
 
 ColumnDataCollection::ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types_p) {
-	Initialize(move(types_p));
+	Initialize(std::move(types_p));
 	allocator = make_shared<ColumnDataAllocator>(buffer_manager);
 }
 
 ColumnDataCollection::ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator_p, vector<LogicalType> types_p) {
-	Initialize(move(types_p));
-	this->allocator = move(allocator_p);
+	Initialize(std::move(types_p));
+	this->allocator = std::move(allocator_p);
 }
 
 ColumnDataCollection::ColumnDataCollection(ClientContext &context, vector<LogicalType> types_p,
                                            ColumnDataAllocatorType type)
-    : ColumnDataCollection(make_shared<ColumnDataAllocator>(context, type), move(types_p)) {
+    : ColumnDataCollection(make_shared<ColumnDataAllocator>(context, type), std::move(types_p)) {
 	D_ASSERT(!types.empty());
 }
 
@@ -81,7 +81,7 @@ ColumnDataCollection::~ColumnDataCollection() {
 }
 
 void ColumnDataCollection::Initialize(vector<LogicalType> types_p) {
-	this->types = move(types_p);
+	this->types = std::move(types_p);
 	this->count = 0;
 	this->finished_append = false;
 	D_ASSERT(!types.empty());
@@ -125,21 +125,14 @@ ColumnDataRowCollection::ColumnDataRowCollection(const ColumnDataCollection &col
 	}
 	// read all the chunks
 	ColumnDataScanState temp_scan_state;
-	collection.InitializeScan(temp_scan_state);
+	collection.InitializeScan(temp_scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY);
 	while (true) {
 		auto chunk = make_unique<DataChunk>();
 		collection.InitializeScanChunk(*chunk);
 		if (!collection.Scan(temp_scan_state, *chunk)) {
 			break;
 		}
-		// we keep the BufferHandles that are needed for the materialized collection pinned in the supplied scan_state
-		auto &temp_handles = temp_scan_state.current_chunk_state.handles;
-		auto &scan_handles = scan_state.current_chunk_state.handles;
-		for (auto &temp_handle_pair : temp_handles) {
-			auto handle_copy = make_pair<uint32_t, BufferHandle>(scan_handles.size(), move(temp_handle_pair.second));
-			scan_state.current_chunk_state.handles.insert(move(handle_copy));
-		}
-		chunks.push_back(move(chunk));
+		chunks.push_back(std::move(chunk));
 	}
 	// now create all of the column data rows
 	rows.reserve(collection.Count());
@@ -176,12 +169,12 @@ ColumnDataChunkIterationHelper ColumnDataCollection::Chunks() const {
 }
 
 ColumnDataChunkIterationHelper ColumnDataCollection::Chunks(vector<column_t> column_ids) const {
-	return ColumnDataChunkIterationHelper(*this, move(column_ids));
+	return ColumnDataChunkIterationHelper(*this, std::move(column_ids));
 }
 
 ColumnDataChunkIterationHelper::ColumnDataChunkIterationHelper(const ColumnDataCollection &collection_p,
                                                                vector<column_t> column_ids_p)
-    : collection(collection_p), column_ids(move(column_ids_p)) {
+    : collection(collection_p), column_ids(std::move(column_ids_p)) {
 }
 
 ColumnDataChunkIterationHelper::ColumnDataChunkIterator::ColumnDataChunkIterator(
@@ -190,7 +183,7 @@ ColumnDataChunkIterationHelper::ColumnDataChunkIterator::ColumnDataChunkIterator
 	if (!collection) {
 		return;
 	}
-	collection->InitializeScan(scan_state, move(column_ids_p));
+	collection->InitializeScan(scan_state, std::move(column_ids_p));
 	collection->InitializeScanChunk(scan_state, *scan_chunk);
 	collection->Scan(scan_state, *scan_chunk);
 }
@@ -343,11 +336,21 @@ struct StringValueCopy : public BaseValueCopy<string_t> {
 	}
 };
 
+struct ConstListValueCopy : public BaseValueCopy<list_entry_t> {
+	using TYPE = list_entry_t;
+
+	static TYPE Operation(ColumnDataMetaData &meta_data, TYPE input) {
+		input.offset = meta_data.child_list_size;
+		return input;
+	}
+};
+
 struct ListValueCopy : public BaseValueCopy<list_entry_t> {
 	using TYPE = list_entry_t;
 
 	static TYPE Operation(ColumnDataMetaData &meta_data, TYPE input) {
-		input.offset += meta_data.child_list_size;
+		input.offset = meta_data.child_list_size;
+		meta_data.child_list_size += input.length;
 		return input;
 	}
 };
@@ -543,22 +546,20 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 template <>
 void ColumnDataCopy<list_entry_t>(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
                                   idx_t offset, idx_t copy_count) {
+
 	auto &segment = meta_data.segment;
 
-	// first append the child entries of the list
 	auto &child_vector = ListVector::GetEntry(source);
-	idx_t child_list_size = ListVector::GetListSize(source);
 	auto &child_type = child_vector.GetType();
 
-	UnifiedVectorFormat child_vector_data;
-	child_vector.ToUnifiedFormat(child_list_size, child_vector_data);
-
 	if (!meta_data.GetVectorMetaData().child_index.IsValid()) {
 		auto child_index = segment.AllocateVector(child_type, meta_data.chunk_data, meta_data.state);
 		meta_data.GetVectorMetaData().child_index = meta_data.segment.AddChildIndex(child_index);
 	}
+
 	auto &child_function = meta_data.copy_function.child_functions[0];
 	auto child_index = segment.GetChildIndex(meta_data.GetVectorMetaData().child_index);
+
 	// figure out the current list size by traversing the set of child entries
 	idx_t current_list_size = 0;
 	auto current_child_index = child_index;
@@ -567,14 +568,37 @@ void ColumnDataCopy<list_entry_t>(ColumnDataMetaData &meta_data, const UnifiedVe
 		current_list_size += child_vdata.count;
 		current_child_index = child_vdata.next_data;
 	}
+
+	// set the child vector
+	UnifiedVectorFormat child_vector_data;
 	ColumnDataMetaData child_meta_data(child_function, meta_data, child_index);
-	// FIXME: appending the entire child list here is not required
-	// We can also scan the actual list entries required per the offset/copy_count
-	child_function.function(child_meta_data, child_vector_data, child_vector, 0, child_list_size);
+	auto info = ListVector::GetConsecutiveChildListInfo(source, offset, copy_count);
+
+	if (info.needs_slicing) {
+		SelectionVector sel(info.child_list_info.length);
+		ListVector::GetConsecutiveChildSelVector(source, sel, offset, copy_count);
+
+		auto sliced_child_vector = Vector(child_vector, sel, info.child_list_info.length);
+		sliced_child_vector.Flatten(info.child_list_info.length);
+		info.child_list_info.offset = 0;
+
+		sliced_child_vector.ToUnifiedFormat(info.child_list_info.length, child_vector_data);
+		child_function.function(child_meta_data, child_vector_data, sliced_child_vector, info.child_list_info.offset,
+		                        info.child_list_info.length);
+
+	} else {
+		child_vector.ToUnifiedFormat(info.child_list_info.length, child_vector_data);
+		child_function.function(child_meta_data, child_vector_data, child_vector, info.child_list_info.offset,
+		                        info.child_list_info.length);
+	}
 
 	// now copy the list entries
 	meta_data.child_list_size = current_list_size;
-	TemplatedColumnDataCopy<ListValueCopy>(meta_data, source_data, source, offset, copy_count);
+	if (info.is_constant) {
+		TemplatedColumnDataCopy<ConstListValueCopy>(meta_data, source_data, source, offset, copy_count);
+	} else {
+		TemplatedColumnDataCopy<ListValueCopy>(meta_data, source_data, source, offset, copy_count);
+	}
 }
 
 void ColumnDataCopyStruct(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
@@ -730,7 +754,7 @@ void ColumnDataCollection::InitializeScan(ColumnDataScanState &state, ColumnData
 	for (idx_t i = 0; i < types.size(); i++) {
 		column_ids.push_back(i);
 	}
-	InitializeScan(state, move(column_ids), properties);
+	InitializeScan(state, std::move(column_ids), properties);
 }
 
 void ColumnDataCollection::InitializeScan(ColumnDataScanState &state, vector<column_t> column_ids,
@@ -741,7 +765,7 @@ void ColumnDataCollection::InitializeScan(ColumnDataScanState &state, vector<col
 	state.next_row_index = 0;
 	state.current_chunk_state.handles.clear();
 	state.properties = properties;
-	state.column_ids = move(column_ids);
+	state.column_ids = std::move(column_ids);
 }
 
 void ColumnDataCollection::InitializeScan(ColumnDataParallelScanState &state,
@@ -751,7 +775,7 @@ void ColumnDataCollection::InitializeScan(ColumnDataParallelScanState &state,
 
 void ColumnDataCollection::InitializeScan(ColumnDataParallelScanState &state, vector<column_t> column_ids,
                                           ColumnDataScanProperties properties) const {
-	InitializeScan(state.scan_state, move(column_ids), properties);
+	InitializeScan(state.scan_state, std::move(column_ids), properties);
 }
 
 bool ColumnDataCollection::Scan(ColumnDataParallelScanState &state, ColumnDataLocalScanState &lstate,
@@ -860,7 +884,7 @@ void ColumnDataCollection::Combine(ColumnDataCollection &other) {
 	this->count += other.count;
 	this->segments.reserve(segments.size() + other.segments.size());
 	for (auto &other_seg : other.segments) {
-		segments.push_back(move(other_seg));
+		segments.push_back(std::move(other_seg));
 	}
 	Verify();
 }

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

@@ -4,7 +4,7 @@ namespace duckdb {
 
 ColumnDataCollectionSegment::ColumnDataCollectionSegment(shared_ptr<ColumnDataAllocator> allocator_p,
                                                          vector<LogicalType> types_p)
-    : allocator(move(allocator_p)), types(move(types_p)), count(0), heap(allocator->GetAllocator()) {
+    : allocator(std::move(allocator_p)), types(std::move(types_p)), count(0), heap(allocator->GetAllocator()) {
 }
 
 idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {
@@ -93,7 +93,7 @@ void ColumnDataCollectionSegment::AllocateNewChunk() {
 		auto vector_idx = AllocateVector(types[i], meta_data);
 		meta_data.vector_data.push_back(vector_idx);
 	}
-	chunk_data.push_back(move(meta_data));
+	chunk_data.push_back(std::move(meta_data));
 }
 
 void ColumnDataCollectionSegment::InitializeChunkState(idx_t chunk_index, ChunkManagementState &state) {

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

@@ -16,7 +16,7 @@ uint32_t ChunkReference::GetMinimumBlockID() const {
 }
 
 ColumnDataConsumer::ColumnDataConsumer(ColumnDataCollection &collection_p, vector<column_t> column_ids)
-    : collection(collection_p), column_ids(move(column_ids)) {
+    : collection(collection_p), column_ids(std::move(column_ids)) {
 }
 
 void ColumnDataConsumer::InitializeScan() {

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

@@ -0,0 +1,18 @@
+#include "duckdb/common/types/constraint_conflict_info.hpp"
+#include "duckdb/storage/index.hpp"
+
+namespace duckdb {
+
+bool ConflictInfo::ConflictTargetMatches(Index &index) const {
+	if (only_check_unique && !index.IsUnique()) {
+		// We only support checking ON CONFLICT for Unique/Primary key constraints
+		return false;
+	}
+	if (column_ids.empty()) {
+		return true;
+	}
+	// Check whether the column ids match
+	return column_ids == index.column_id_set;
+}
+
+} // namespace duckdb