duckdb 1.1.2-dev4.0 → 1.1.3

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

@@ -0,0 +1,359 @@
+//===--------------------------------------------------------------------===//
+// row_match.cpp
+// Description: This file contains the implementation of the match operators
+//===--------------------------------------------------------------------===//
+
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/operator/constant_operators.hpp"
+#include "duckdb/common/row_operations/row_operations.hpp"
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
+
+namespace duckdb {
+
+using ValidityBytes = RowLayout::ValidityBytes;
+using Predicates = RowOperations::Predicates;
+
+template <typename OP>
+static idx_t SelectComparison(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                              SelectionVector *true_sel, SelectionVector *false_sel) {
+	throw NotImplementedException("Unsupported nested comparison operand for RowOperations::Match");
+}
+
+template <>
+idx_t SelectComparison<Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                               SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
+}
+
+template <>
+idx_t SelectComparison<NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                                  SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
+}
+
+template <>
+idx_t SelectComparison<GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                                    SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
+}
+
+template <>
+idx_t SelectComparison<GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                                          SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
+}
+
+template <>
+idx_t SelectComparison<LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                                 SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
+}
+
+template <>
+idx_t SelectComparison<LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
+                                       SelectionVector *true_sel, SelectionVector *false_sel) {
+	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
+}
+
+template <class T, class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, SelectionVector &sel, idx_t &count,
+                               idx_t col_offset, idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
+	// Precompute row_mask indexes
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
+
+	auto data = UnifiedVectorFormat::GetData<T>(col);
+	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
+	idx_t match_count = 0;
+	if (!col.validity.AllValid()) {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			auto col_idx = col.sel->get_index(idx);
+			if (!col.validity.RowIsValid(col_idx)) {
+				if (isnull) {
+					// match: move to next value to compare
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			} else {
+				auto value = Load<T>(row + col_offset);
+				if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			}
+		}
+	} else {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			auto col_idx = col.sel->get_index(idx);
+			auto value = Load<T>(row + col_offset);
+			if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
+				sel.set_index(match_count++, idx);
+			} else {
+				if (NO_MATCH_SEL) {
+					no_match->set_index(no_match_count++, idx);
+				}
+			}
+		}
+	}
+	count = match_count;
+}
+
+//! Forward declaration for recursion
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
+                             idx_t &no_match_count, const idx_t original_count);
+
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchStruct(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                                 SelectionVector &sel, idx_t &count, const idx_t col_no, SelectionVector *no_match,
+                                 idx_t &no_match_count, const idx_t original_count) {
+	// Precompute row_mask indexes
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
+
+	// Work our way through the validity of the whole struct
+	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
+	idx_t match_count = 0;
+	if (!col.validity.AllValid()) {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			auto col_idx = col.sel->get_index(idx);
+			if (!col.validity.RowIsValid(col_idx)) {
+				if (isnull) {
+					// match: move to next value to compare
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			} else {
+				if (!isnull) {
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			}
+		}
+	} else {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			if (!isnull) {
+				sel.set_index(match_count++, idx);
+			} else {
+				if (NO_MATCH_SEL) {
+					no_match->set_index(no_match_count++, idx);
+				}
+			}
+		}
+	}
+	count = match_count;
+
+	// Now we construct row pointers to the structs
+	Vector struct_rows(LogicalTypeId::POINTER);
+	auto struct_ptrs = FlatVector::GetData<data_ptr_t>(struct_rows);
+
+	const auto col_offset = layout.GetOffsets()[col_no];
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = sel.get_index(i);
+		auto row = ptrs[idx];
+		struct_ptrs[idx] = row + col_offset;
+	}
+
+	// Get the struct layout, child columns, then recurse
+	const auto &struct_layout = layout.GetStructLayout(col_no);
+	auto &struct_entries = StructVector::GetEntries(vec);
+	D_ASSERT(struct_layout.ColumnCount() == struct_entries.size());
+	for (idx_t struct_col_no = 0; struct_col_no < struct_layout.ColumnCount(); struct_col_no++) {
+		auto &struct_vec = *struct_entries[struct_col_no];
+		UnifiedVectorFormat struct_col;
+		struct_vec.ToUnifiedFormat(original_count, struct_col);
+		TemplatedMatchOp<OP, NO_MATCH_SEL>(struct_vec, struct_col, struct_layout, struct_rows, sel, count,
+		                                   struct_col_no, no_match, no_match_count, original_count);
+	}
+}
+
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchList(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count,
+                               const TupleDataLayout &layout, const idx_t col_no, SelectionVector *no_match,
+                               idx_t &no_match_count) {
+	// Gather a dense Vector containing the column values being matched
+	Vector key(col.GetType());
+	const auto gather_function = TupleDataCollection::GetGatherFunction(col.GetType());
+	gather_function.function(layout, rows, col_no, sel, count, key, *FlatVector::IncrementalSelectionVector(), key,
+	                         gather_function.child_functions);
+
+	// Densify the input column
+	Vector sliced(col, sel, count);
+
+	if (NO_MATCH_SEL) {
+		SelectionVector no_match_sel_offset(no_match->data() + no_match_count);
+		auto match_count = SelectComparison<OP>(sliced, key, sel, count, &sel, &no_match_sel_offset);
+		no_match_count += count - match_count;
+		count = match_count;
+	} else {
+		count = SelectComparison<OP>(sliced, key, sel, count, &sel, nullptr);
+	}
+}
+
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
+                             idx_t &no_match_count, const idx_t original_count) {
+	if (count == 0) {
+		return;
+	}
+	auto col_offset = layout.GetOffsets()[col_no];
+	switch (layout.GetTypes()[col_no].InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		TemplatedMatchType<int8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                             no_match_count);
+		break;
+	case PhysicalType::INT16:
+		TemplatedMatchType<int16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                              no_match_count);
+		break;
+	case PhysicalType::INT32:
+		TemplatedMatchType<int32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                              no_match_count);
+		break;
+	case PhysicalType::INT64:
+		TemplatedMatchType<int64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                              no_match_count);
+		break;
+	case PhysicalType::UINT8:
+		TemplatedMatchType<uint8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                              no_match_count);
+		break;
+	case PhysicalType::UINT16:
+		TemplatedMatchType<uint16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                               no_match_count);
+		break;
+	case PhysicalType::UINT32:
+		TemplatedMatchType<uint32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                               no_match_count);
+		break;
+	case PhysicalType::UINT64:
+		TemplatedMatchType<uint64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                               no_match_count);
+		break;
+	case PhysicalType::INT128:
+		TemplatedMatchType<hugeint_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                                no_match_count);
+		break;
+	case PhysicalType::FLOAT:
+		TemplatedMatchType<float, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                            no_match_count);
+		break;
+	case PhysicalType::DOUBLE:
+		TemplatedMatchType<double, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                             no_match_count);
+		break;
+	case PhysicalType::INTERVAL:
+		TemplatedMatchType<interval_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                                 no_match_count);
+		break;
+	case PhysicalType::VARCHAR:
+		TemplatedMatchType<string_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
+		                                               no_match_count);
+		break;
+	case PhysicalType::STRUCT:
+		TemplatedMatchStruct<OP, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+		                                       original_count);
+		break;
+	case PhysicalType::LIST:
+		TemplatedMatchList<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
+		break;
+	default:
+		throw InternalException("Unsupported column type for RowOperations::Match");
+	}
+}
+
+template <bool NO_MATCH_SEL>
+static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
+                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t &count,
+                           SelectionVector *no_match, idx_t &no_match_count) {
+	for (idx_t col_no = 0; col_no < predicates.size(); ++col_no) {
+		auto &vec = columns.data[col_no];
+		auto &col = col_data[col_no];
+		switch (predicates[col_no]) {
+		case ExpressionType::COMPARE_EQUAL:
+		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		case ExpressionType::COMPARE_DISTINCT_FROM:
+			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+			                                       count);
+			break;
+		case ExpressionType::COMPARE_NOTEQUAL:
+			TemplatedMatchOp<NotEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
+			                                          no_match_count, count);
+			break;
+		case ExpressionType::COMPARE_GREATERTHAN:
+			TemplatedMatchOp<GreaterThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
+			                                            no_match_count, count);
+			break;
+		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			TemplatedMatchOp<GreaterThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
+			                                                  no_match_count, count);
+			break;
+		case ExpressionType::COMPARE_LESSTHAN:
+			TemplatedMatchOp<LessThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
+			                                         no_match_count, count);
+			break;
+		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+			TemplatedMatchOp<LessThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
+			                                               no_match_count, count);
+			break;
+		default:
+			throw InternalException("Unsupported comparison type for RowOperations::Match");
+		}
+	}
+}
+
+idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
+                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t count,
+                           SelectionVector *no_match, idx_t &no_match_count) {
+	if (no_match) {
+		TemplatedMatch<true>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
+	} else {
+		TemplatedMatch<false>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
+	}
+
+	return count;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,27 @@
+#include "duckdb/common/serializer/buffered_deserializer.hpp"
+
+#include <cstring>
+
+namespace duckdb {
+
+BufferedDeserializer::BufferedDeserializer(data_ptr_t ptr, idx_t data_size) : ptr(ptr), endptr(ptr + data_size) {
+}
+
+BufferedDeserializer::BufferedDeserializer(BufferedSerializer &serializer)
+    : BufferedDeserializer(serializer.data, serializer.maximum_size) {
+	SetVersion(serializer.GetVersion());
+}
+
+void BufferedDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
+	if (ptr + read_size > endptr) {
+		throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
+	}
+	memcpy(buffer, ptr, read_size);
+	ptr += read_size;
+}
+
+ClientContext &BufferedContextDeserializer::GetContext() {
+	return context;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,36 @@
+#include "duckdb/common/serializer/buffered_serializer.hpp"
+
+#include <cstring>
+
+namespace duckdb {
+
+BufferedSerializer::BufferedSerializer(idx_t maximum_size)
+    : BufferedSerializer(make_unsafe_uniq_array<data_t>(maximum_size), maximum_size) {
+}
+
+BufferedSerializer::BufferedSerializer(unsafe_unique_array<data_t> data, idx_t size)
+    : maximum_size(size), data(data.get()) {
+	blob.size = 0;
+	blob.data = std::move(data);
+}
+
+BufferedSerializer::BufferedSerializer(data_ptr_t data, idx_t size) : maximum_size(size), data(data) {
+	blob.size = 0;
+}
+
+void BufferedSerializer::WriteData(const_data_ptr_t buffer, idx_t write_size) {
+	if (blob.size + write_size >= maximum_size) {
+		do {
+			maximum_size *= 2;
+		} while (blob.size + write_size > maximum_size);
+		auto new_data = new data_t[maximum_size];
+		memcpy(new_data, data, blob.size);
+		data = new_data;
+		blob.data = unsafe_unique_array<data_t>(new_data);
+	}
+
+	memcpy(data + blob.size, buffer, write_size);
+	blob.size += write_size;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,15 @@
+#include "duckdb/common/serializer/format_serializer.hpp"
+
+namespace duckdb {
+
+template <>
+void FormatSerializer::WriteValue(const vector<bool> &vec) {
+	auto count = vec.size();
+	OnListBegin(count);
+	for (auto item : vec) {
+		WriteValue(item);
+	}
+	OnListEnd(count);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,24 @@
+#include "duckdb/common/serializer.hpp"
+
+namespace duckdb {
+
+template <>
+string Deserializer::Read() {
+	uint32_t size = Read<uint32_t>();
+	if (size == 0) {
+		return string();
+	}
+	auto buffer = make_unsafe_uniq_array<data_t>(size);
+	ReadData(buffer.get(), size);
+	return string(const_char_ptr_cast(buffer.get()), size);
+}
+
+void Deserializer::ReadStringVector(vector<string> &list) {
+	uint32_t sz = Read<uint32_t>();
+	list.resize(sz);
+	for (idx_t i = 0; i < sz; i++) {
+		list[i] = Read<string>();
+	}
+}
+
+} // namespace duckdb

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

@@ -24,7 +24,7 @@ bool Comparators::TieIsBreakable(const idx_t &tie_col, const data_ptr_t &row_ptr
 	}
 	const auto &tie_col_offset = row_layout.GetOffsets()[col_idx];
 	auto tie_string = Load<string_t>(row_ptr + tie_col_offset);
-	if (tie_string.GetSize() < sort_layout.prefix_lengths[tie_col]) {
+	if (tie_string.GetSize() < sort_layout.prefix_lengths[tie_col] && tie_string.GetSize() > 0) {
 		// No need to break the tie - we already compared the full string
 		return false;
 	}
@@ -71,7 +71,7 @@ int Comparators::BreakBlobTie(const idx_t &tie_col, const SBScanState &left, con
                               const SortLayout &sort_layout, const bool &external) {
 	data_ptr_t l_data_ptr = left.DataPtr(*left.sb->blob_sorting_data);
 	data_ptr_t r_data_ptr = right.DataPtr(*right.sb->blob_sorting_data);
-	if (!TieIsBreakable(tie_col, l_data_ptr, sort_layout)) {
+	if (!TieIsBreakable(tie_col, l_data_ptr, sort_layout) && !TieIsBreakable(tie_col, r_data_ptr, sort_layout)) {
 		// Quick check to see if ties can be broken
 		return 0;
 	}