duckdb 0.7.2-dev2320.0 → 0.7.2-dev2410.0

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -78,7 +78,7 @@ struct LikeMatcher : public FunctionData {
 	}
 
 	bool Match(string_t &str) {
-		auto str_data = (const unsigned char *)str.GetDataUnsafe();
+		auto str_data = (const unsigned char *)str.GetData();
 		auto str_len = str.GetSize();
 		idx_t segment_idx = 0;
 		idx_t end_idx = segments.size() - 1;
@@ -213,11 +213,11 @@ bool LikeOperatorFunction(const char *s, idx_t slen, const char *pattern, idx_t
 }
 
 bool LikeOperatorFunction(string_t &s, string_t &pat) {
-	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize());
+	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize());
 }
 
 bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
-	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize(), escape);
+	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize(), escape);
 }
 
 bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
@@ -362,15 +362,14 @@ static char GetEscapeChar(string_t escape) {
 	if (escape.GetSize() > 1) {
 		throw SyntaxException("Invalid escape string. Escape string must be empty or one character.");
 	}
-	return escape.GetSize() == 0 ? '\0' : *escape.GetDataUnsafe();
+	return escape.GetSize() == 0 ? '\0' : *escape.GetData();
 }
 
 struct LikeEscapeOperator {
 	template <class TA, class TB, class TC>
 	static inline bool Operation(TA str, TB pattern, TC escape) {
 		char escape_char = GetEscapeChar(escape);
-		return LikeOperatorFunction(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize(),
-		                            escape_char);
+		return LikeOperatorFunction(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize(), escape_char);
 	}
 };
 
@@ -389,9 +388,9 @@ struct LikeOperator {
 };
 
 bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0') {
-	auto str_data = str.GetDataUnsafe();
+	auto str_data = str.GetData();
 	auto str_size = str.GetSize();
-	auto pat_data = pattern.GetDataUnsafe();
+	auto pat_data = pattern.GetData();
 	auto pat_size = pattern.GetSize();
 
 	// lowercase both the str and the pattern
@@ -446,8 +445,8 @@ struct NotILikeOperator {
 struct ILikeOperatorASCII {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA str, TB pattern) {
-		return TemplatedLikeOperator<'%', '_', false, ASCIILCaseReader>(
-		    str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize(), '\0');
+		return TemplatedLikeOperator<'%', '_', false, ASCIILCaseReader>(str.GetData(), str.GetSize(), pattern.GetData(),
+		                                                                pattern.GetSize(), '\0');
 	}
 };
 
@@ -461,7 +460,7 @@ struct NotILikeOperatorASCII {
 struct GlobOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA str, TB pattern) {
-		return LikeFun::Glob(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize());
+		return LikeFun::Glob(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize());
 	}
 };
 

package/src/duckdb/src/function/scalar/string/mismatches.cpp

@@ -18,8 +18,8 @@ static int64_t MismatchesScalarFunction(Vector &result, const string_t str, stri
 	}
 
 	idx_t mismatches = 0;
-	auto str_str = str.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
+	auto str_str = str.GetData();
+	auto tgt_str = tgt.GetData();
 
 	for (idx_t idx = 0; idx < str_len; ++idx) {
 		if (str_str[idx] != tgt_str[idx]) {

package/src/duckdb/src/function/scalar/string/nfc_normalize.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 struct NFCNormalizeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		if (StripAccentsFun::IsAscii(input_data, input_length)) {
 			return input;

package/src/duckdb/src/function/scalar/string/pad.cpp

@@ -27,7 +27,7 @@ static pair<idx_t, idx_t> PadCountChars(const idx_t len, const char *data, const
 
 static bool InsertPadding(const idx_t len, const string_t &pad, vector<char> &result) {
 	//  Copy the padding until the output is long enough
-	auto data = pad.GetDataUnsafe();
+	auto data = pad.GetData();
 	auto size = pad.GetSize();
 
 	//  Check whether we need data that we don't have
@@ -63,7 +63,7 @@ static string_t LeftPadFunction(const string_t &str, const int32_t len, const st
 	result.clear();
 
 	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
+	auto data_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	//  Count how much of str will fit in the output
@@ -92,7 +92,7 @@ static string_t RightPadFunction(const string_t &str, const int32_t len, const s
 	result.clear();
 
 	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
+	auto data_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	// Count how much of str will fit in the output

package/src/duckdb/src/function/scalar/string/prefix.cpp

@@ -46,8 +46,8 @@ static bool PrefixFunction(const string_t &str, const string_t &pattern) {
 			}
 		}
 		// compare the rest of the prefix
-		const char *str_data = str.GetDataUnsafe();
-		const char *patt_data = pattern.GetDataUnsafe();
+		const char *str_data = str.GetData();
+		const char *patt_data = pattern.GetData();
 		D_ASSERT(patt_length <= str_length);
 		for (idx_t i = string_t::PREFIX_LENGTH; i < patt_length; ++i) {
 			if (str_data[i] != patt_data[i]) {

package/src/duckdb/src/function/scalar/string/printf.cpp

@@ -138,7 +138,7 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			case LogicalTypeId::VARCHAR: {
 				auto arg_data = FlatVector::GetData<string_t>(col);
 				auto string_view =
-				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetDataUnsafe(), arg_data[arg_idx].GetSize());
+				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetData(), arg_data[arg_idx].GetSize());
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(string_view));
 				break;
 			}

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -86,7 +86,7 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 		idx_t child_idx = current_list_size;
 		if (match_group.empty()) {
 			// This group was not matched
-			list_content[child_idx] = string_t(string.GetDataUnsafe(), 0);
+			list_content[child_idx] = string_t(string.GetData(), 0);
 			if (match_group.begin() == nullptr) {
 				// This group is optional
 				child_validity.SetInvalid(child_idx);
@@ -94,9 +94,9 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 		} else {
 			// Every group is a substring of the original, we can find out the offset using the pointer
 			// the 'match_group' address is guaranteed to be bigger than that of the source
-			D_ASSERT((const char *)match_group.begin() >= string.GetDataUnsafe());
-			idx_t offset = match_group.begin() - string.GetDataUnsafe();
-			list_content[child_idx] = string_t(string.GetDataUnsafe() + offset, match_group.size());
+			D_ASSERT((const char *)match_group.begin() >= string.GetData());
+			idx_t offset = match_group.begin() - string.GetData();
+			list_content[child_idx] = string_t(string.GetData() + offset, match_group.size());
 		}
 		current_list_size++;
 		if (startpos > input.size()) {

package/src/duckdb/src/function/scalar/string/repeat.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 
 static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vector<char> &result) {
 	// Get information about the repeated string
-	auto input_str = str.GetDataUnsafe();
+	auto input_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	//  Reuse the buffer

package/src/duckdb/src/function/scalar/string/replace.cpp

@@ -29,13 +29,13 @@ static idx_t NextNeedle(const char *input_haystack, idx_t size_haystack, const c
 static string_t ReplaceScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
                                       vector<char> &result) {
 	// Get information about the needle, the haystack and the "thread"
-	auto input_haystack = haystack.GetDataUnsafe();
+	auto input_haystack = haystack.GetData();
 	auto size_haystack = haystack.GetSize();
 
-	auto input_needle = needle.GetDataUnsafe();
+	auto input_needle = needle.GetData();
 	auto size_needle = needle.GetSize();
 
-	auto input_thread = thread.GetDataUnsafe();
+	auto input_thread = thread.GetData();
 	auto size_thread = thread.GetSize();
 
 	//  Reuse the buffer

package/src/duckdb/src/function/scalar/string/reverse.cpp

@@ -32,7 +32,7 @@ static void StrReverseUnicode(const char *input, idx_t n, char *output) {
 struct ReverseOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 
 		auto target = StringVector::EmptyString(result, input_length);

package/src/duckdb/src/function/scalar/string/starts_with.cpp

@@ -17,9 +17,9 @@ static bool StartsWith(const unsigned char *haystack, idx_t haystack_size, const
 }
 
 static bool StartsWith(const string_t &haystack_s, const string_t &needle_s) {
-	auto haystack = (const unsigned char *)haystack_s.GetDataUnsafe();
+	auto haystack = (const unsigned char *)haystack_s.GetData();
 	auto haystack_size = haystack_s.GetSize();
-	auto needle = (const unsigned char *)needle_s.GetDataUnsafe();
+	auto needle = (const unsigned char *)needle_s.GetData();
 	auto needle_size = needle_s.GetSize();
 	if (needle_size == 0) {
 		// empty needle: always true

package/src/duckdb/src/function/scalar/string/string_split.cpp

@@ -68,9 +68,9 @@ struct RegexpStringSplit {
 struct StringSplitter {
 	template <class OP>
 	static idx_t Split(string_t input, string_t delim, StringSplitInput &state, void *data) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_size = input.GetSize();
-		auto delim_data = delim.GetDataUnsafe();
+		auto delim_data = delim.GetData();
 		auto delim_size = delim.GetSize();
 		idx_t list_idx = 0;
 		while (input_size > 0) {
@@ -135,7 +135,7 @@ static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector
 		StringSplitInput split_input(result, child_entry, total_splits);
 		if (!delim_data.validity.RowIsValid(delim_idx)) {
 			// delim is NULL: copy the complete entry
-			split_input.AddSplit(inputs[input_idx].GetDataUnsafe(), inputs[input_idx].GetSize(), 0);
+			split_input.AddSplit(inputs[input_idx].GetData(), inputs[input_idx].GetSize(), 0);
 			list_struct_data[i].length = 1;
 			list_struct_data[i].offset = total_splits;
 			total_splits++;

package/src/duckdb/src/function/scalar/string/strip_accents.cpp

@@ -17,12 +17,12 @@ bool StripAccentsFun::IsAscii(const char *input, idx_t n) {
 struct StripAccentsOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		if (StripAccentsFun::IsAscii(input.GetDataUnsafe(), input.GetSize())) {
+		if (StripAccentsFun::IsAscii(input.GetData(), input.GetSize())) {
 			return input;
 		}
 
 		// non-ascii, perform collation
-		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetDataUnsafe(), input.GetSize());
+		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(), input.GetSize());
 		auto result_str = StringVector::AddString(result, (const char *)stripped);
 		free(stripped);
 		return result_str;

package/src/duckdb/src/function/scalar/string/substring.cpp

@@ -82,7 +82,7 @@ bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64
 }
 
 string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);
@@ -95,7 +95,7 @@ string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t
 }
 
 string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);
@@ -190,7 +190,7 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 }
 
 string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);

package/src/duckdb/src/function/scalar/string/suffix.cpp

@@ -21,8 +21,8 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 		return false;
 	}
 
-	auto suffix_data = suffix.GetDataUnsafe();
-	auto str_data = str.GetDataUnsafe();
+	auto suffix_data = suffix.GetData();
+	auto str_data = str.GetData();
 	int32_t suf_idx = suffix_size - 1;
 	idx_t str_idx = str_size - 1;
 	for (; suf_idx >= 0; --suf_idx, --str_idx) {

package/src/duckdb/src/function/scalar/string/translate.cpp

@@ -16,13 +16,13 @@ namespace duckdb {
 static string_t TranslateScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
                                         vector<char> &result) {
 	// Get information about the haystack, the needle and the "thread"
-	auto input_haystack = haystack.GetDataUnsafe();
+	auto input_haystack = haystack.GetData();
 	auto size_haystack = haystack.GetSize();
 
-	auto input_needle = needle.GetDataUnsafe();
+	auto input_needle = needle.GetData();
 	auto size_needle = needle.GetSize();
 
-	auto input_thread = thread.GetDataUnsafe();
+	auto input_thread = thread.GetData();
 	auto size_thread = thread.GetSize();
 
 	// Reuse the buffer

package/src/duckdb/src/function/scalar/string/trim.cpp

@@ -13,7 +13,7 @@ template <bool LTRIM, bool RTRIM>
 struct TrimOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
+		auto data = input.GetData();
 		auto size = input.GetSize();
 
 		utf8proc_int32_t codepoint;
@@ -64,7 +64,7 @@ static void UnaryTrimFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_t> &ignored_codepoints) {
-	auto dataptr = (utf8proc_uint8_t *)ignored.GetDataUnsafe();
+	auto dataptr = (utf8proc_uint8_t *)ignored.GetData();
 	auto size = ignored.GetSize();
 	idx_t pos = 0;
 	while (pos < size) {
@@ -78,7 +78,7 @@ template <bool LTRIM, bool RTRIM>
 static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    input.data[0], input.data[1], result, input.size(), [&](string_t input, string_t ignored) {
-		    auto data = input.GetDataUnsafe();
+		    auto data = input.GetData();
 		    auto size = input.GetSize();
 
 		    unordered_set<utf8proc_int32_t> ignored_codepoints;

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -62,7 +62,7 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw BinderException("Key name for struct_extract needs to be a constant string");
 	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child.get());
+	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
 	auto &key_str = StringValue::Get(key_val);
 	if (key_val.IsNull() || key_str.empty()) {

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -91,7 +91,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 		if (state_data.validity.RowIsValid(state_idx)) {
 			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
-			memcpy((void *)target_ptr, state_entry->GetDataUnsafe(), bind_data.state_size);
+			memcpy((void *)target_ptr, state_entry->GetData(), bind_data.state_size);
 		} else {
 			// create a dummy state because finalize does not understand NULLs in its input
 			// we put the NULL back in explicitly below
@@ -145,13 +145,11 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			continue;
 		}
 		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state0.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state0.GetData(), bind_data.state_size);
 			continue;
 		}
 		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state1.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state1.GetData(), bind_data.state_size);
 			continue;
 		}
 
@@ -161,8 +159,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			                  state0.GetSize(), state1.GetSize());
 		}
 
-		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
-		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
+		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
+		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
 
 		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);

package/src/duckdb/src/function/scalar/union/union_extract.cpp

@@ -60,7 +60,7 @@ static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarF
 	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw BinderException("Key name for union_extract needs to be a constant string");
 	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child.get());
+	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
 	auto &key_str = StringValue::Get(key_val);
 	if (key_val.IsNull() || key_str.empty()) {

package/src/duckdb/src/function/table/copy_csv.cpp

@@ -357,7 +357,7 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 			// FIXME: we could gain some performance here by checking for certain types if they ever require quotes
 			// (e.g. integers only require quotes if the delimiter is a number, decimals only require quotes if the
 			// delimiter is a number or "." character)
-			WriteQuotedString(writer, csv_data, str_value.GetDataUnsafe(), str_value.GetSize(),
+			WriteQuotedString(writer, csv_data, str_value.GetData(), str_value.GetSize(),
 			                  csv_data.options.force_quote[col_idx]);
 		}
 		writer.WriteBufferData(csv_data.newline);

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -239,7 +239,7 @@ struct MacroExtractor {
 
 	static Value GetMacroDefinition(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		D_ASSERT(entry.function->type == MacroType::SCALAR_MACRO);
-		auto &func = (ScalarMacroFunction &)*entry.function;
+		auto &func = entry.function->Cast<ScalarMacroFunction>();
 		return func.expression->ToString();
 	}
 
@@ -295,7 +295,7 @@ struct TableMacroExtractor {
 
 	static Value GetMacroDefinition(TableMacroCatalogEntry &entry, idx_t offset) {
 		if (entry.function->type == MacroType::SCALAR_MACRO) {
-			auto &func = (ScalarMacroFunction &)*entry.function;
+			auto &func = entry.function->Cast<ScalarMacroFunction>();
 			return func.expression->ToString();
 		}
 		return Value();

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2320"
+#define DUCKDB_VERSION "0.7.2-dev2410"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "04b7296af3"
+#define DUCKDB_SOURCE_ID "e413e0b40d"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/crypto/md5.hpp

@@ -26,7 +26,7 @@ public:
 	}
 	void Add(const char *data);
 	void Add(string_t string) {
-		MD5Update((const_data_ptr_t)string.GetDataUnsafe(), string.GetSize());
+		MD5Update((const_data_ptr_t)string.GetData(), string.GetSize());
 	}
 	void Add(const string &data) {
 		MD5Update((const_data_ptr_t)data.c_str(), data.size());

package/src/duckdb/src/include/duckdb/common/enums/debug_initialize.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/debug_initialize.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class DebugInitialize : uint8_t { NO_INITIALIZE = 0, DEBUG_ZERO_INITIALIZE = 1, DEBUG_ONE_INITIALIZE = 2 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/order_type.hpp

@@ -17,4 +17,12 @@ enum class OrderType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2,
 
 enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };
 
+enum class DefaultOrderByNullType : uint8_t {
+	INVALID = 0,
+	NULLS_FIRST = 2,
+	NULLS_LAST = 3,
+	NULLS_FIRST_ON_ASC_LAST_ON_DESC = 4,
+	NULLS_LAST_ON_ASC_FIRST_ON_DESC = 5
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -58,6 +58,7 @@ enum class PhysicalOperatorType : uint8_t {
 	DELIM_JOIN,
 	INDEX_JOIN,
 	POSITIONAL_JOIN,
+	ASOF_JOIN,
 	// -----------------------------
 	// SetOps
 	// -----------------------------

package/src/duckdb/src/include/duckdb/common/file_buffer.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/enums/debug_initialize.hpp"
 
 namespace duckdb {
 class Allocator;
@@ -62,6 +63,8 @@ public:
 
 	MemoryRequirement CalculateMemory(uint64_t user_size);
 
+	void Initialize(DebugInitialize info);
+
 protected:
 	//! The pointer to the internal buffer that will be read or written, including the buffer header
 	data_ptr_t internal_buffer;

package/src/duckdb/src/include/duckdb/common/radix.hpp

@@ -50,7 +50,7 @@ public:
 
 	static inline void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
 		auto len = value.GetSize();
-		memcpy(dataptr, value.GetDataUnsafe(), MinValue(len, prefix_len));
+		memcpy(dataptr, value.GetData(), MinValue(len, prefix_len));
 		if (len < prefix_len) {
 			memset(dataptr + len, '\0', prefix_len - len);
 		}

package/src/duckdb/src/include/duckdb/common/radix_partitioning.hpp

@@ -49,6 +49,9 @@ public:
 	//! Select using a cutoff on the radix bits of the hash
 	static idx_t Select(Vector &hashes, const SelectionVector *sel, idx_t count, idx_t radix_bits, idx_t cutoff,
 	                    SelectionVector *true_sel, SelectionVector *false_sel);
+
+	//! Convert hashes to bins
+	static void HashesToBins(Vector &hashes, idx_t radix_bits, Vector &bins, idx_t count);
 };
 
 //! Templated radix partitioning constants, can be templated to the number of radix bits

package/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp

@@ -25,6 +25,8 @@ public:
 	PartitionGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
 	                         const Types &payload_types, bool external);
 
+	int ComparePartitions(const SBIterator &left, const SBIterator &right) const;
+
 	void ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask);
 
 	GlobalSortStatePtr global_sort;
@@ -43,8 +45,12 @@ public:
 	using GroupingPartition = unique_ptr<PartitionedColumnData>;
 	using GroupingAppend = unique_ptr<PartitionedColumnDataAppendState>;
 
-	PartitionGlobalSinkState(ClientContext &context, const vector<unique_ptr<Expression>> &partitions_p,
-	                         const vector<BoundOrderByNode> &orders_p, const Types &payload_types,
+	static void GenerateOrderings(Orders &partitions, Orders &orders,
+	                              const vector<unique_ptr<Expression>> &partition_bys, const Orders &order_bys,
+	                              const vector<unique_ptr<BaseStatistics>> &partitions_stats);
+
+	PartitionGlobalSinkState(ClientContext &context, const vector<unique_ptr<Expression>> &partition_bys,
+	                         const vector<BoundOrderByNode> &order_bys, const Types &payload_types,
 	                         const vector<unique_ptr<BaseStatistics>> &partitions_stats, idx_t estimated_cardinality);
 
 	void UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
@@ -68,6 +74,8 @@ public:
 	const Types payload_types;
 	vector<HashGroupPtr> hash_groups;
 	bool external;
+	//	Reverse lookup from hash bins to non-empty hash groups
+	vector<size_t> bin_groups;
 
 	// OVER() (no sorting)
 	unique_ptr<RowDataCollection> rows;
@@ -121,7 +129,7 @@ class PartitionGlobalMergeState {
 public:
 	using GroupDataPtr = unique_ptr<ColumnDataCollection>;
 
-	explicit PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data);
+	PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data, hash_t hash_bin);
 
 	bool IsSorted() const {
 		lock_guard<mutex> guard(lock);
@@ -187,61 +195,4 @@ public:
 	void Schedule() override;
 };
 
-class PartitionGlobalSourceState {
-public:
-	explicit PartitionGlobalSourceState(PartitionGlobalSinkState &gsink_p) : gsink(gsink_p), next_bin(0) {
-	}
-
-	PartitionGlobalSinkState &gsink;
-	//! The output read position.
-	atomic<idx_t> next_bin;
-
-public:
-	idx_t MaxThreads() {
-		// If there is only one partition, we have to process it on one thread.
-		if (!gsink.grouping_data) {
-			return 1;
-		}
-
-		// If there is not a lot of data, process serially.
-		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
-			return 1;
-		}
-
-		return gsink.hash_groups.size();
-	}
-};
-
-// Per-thread read state
-class PartitionLocalSourceState {
-public:
-	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-
-	explicit PartitionLocalSourceState(PartitionGlobalSinkState &gstate_p);
-
-	void MaterializeSortedData();
-	idx_t GeneratePartition(const idx_t hash_bin);
-
-	PartitionGlobalSinkState &gstate;
-
-	//! The read partition
-	idx_t hash_bin;
-	HashGroupPtr hash_group;
-
-	//! The generated input chunks
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> heap;
-	RowLayout layout;
-	//! The partition boundary mask
-	vector<validity_t> partition_bits;
-	ValidityMask partition_mask;
-	//! The order boundary mask
-	vector<validity_t> order_bits;
-	ValidityMask order_mask;
-	//! The read cursor
-	unique_ptr<RowDataCollectionScanner> scanner;
-	//! Buffer for the inputs
-	DataChunk input_chunk;
-};
-
 } // namespace duckdb