Update vendored DuckDB sources to e144689926

Author: duckdblabs-bot

CMakeLists.txt

@@ -57,7 +57,7 @@ static void MapExtractValueFunc(DataChunk &args, ExpressionState &state, Vector
 
 	// Collect the matching positions
 	Vector pos_vec(LogicalType::INTEGER, count);
-	ListSearchOp<true>(map_vec, key_vec, arg_vec, pos_vec, args.size());
+	ListSearchOp<int32_t>(map_vec, key_vec, arg_vec, pos_vec, args.size());
 
 	UnifiedVectorFormat pos_format;
 	UnifiedVectorFormat lst_format;
@@ -68,7 +68,6 @@ static void MapExtractValueFunc(DataChunk &args, ExpressionState &state, Vector
 	const auto pos_data = UnifiedVectorFormat::GetData<int32_t>(pos_format);
 	const auto inc_list_data = ListVector::GetData(map_vec);
 
-	auto &result_validity = FlatVector::Validity(result);
 	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 		auto lst_idx = lst_format.sel->get_index(row_idx);
 		if (!lst_format.validity.RowIsValid(lst_idx)) {
@@ -79,7 +78,7 @@ static void MapExtractValueFunc(DataChunk &args, ExpressionState &state, Vector
 		const auto pos_idx = pos_format.sel->get_index(row_idx);
 		if (!pos_format.validity.RowIsValid(pos_idx)) {
 			// We didnt find the key in the map, so return NULL
-			result_validity.SetInvalid(row_idx);
+			FlatVector::SetNull(result, row_idx, true);
 			continue;
 		}
 
@@ -118,7 +117,7 @@ static void MapExtractListFunc(DataChunk &args, ExpressionState &state, Vector &
 
 	// Collect the matching positions
 	Vector pos_vec(LogicalType::INTEGER, count);
-	ListSearchOp<true>(map_vec, key_vec, arg_vec, pos_vec, args.size());
+	ListSearchOp<int32_t>(map_vec, key_vec, arg_vec, pos_vec, args.size());
 
 	UnifiedVectorFormat val_format;
 	UnifiedVectorFormat pos_format;

src/duckdb/extension/core_functions/scalar/map/map_extract.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/common/operator/decimal_cast_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/likely.hpp"
@@ -566,6 +567,34 @@ struct RoundDecimalOperator {
 	}
 };
 
+struct RoundIntegerOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA input, TB precision) {
+		if (precision < 0) {
+			//	Do all the arithmetic at higher precision
+			using POWERS_OF_TEN_CLASS = typename DecimalCastTraits<TA>::POWERS_OF_TEN_CLASS;
+			if (precision <= -POWERS_OF_TEN_CLASS::CACHED_POWERS_OF_TEN) {
+				return 0;
+			}
+			const auto power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-precision];
+			auto addition = power_of_ten / 2;
+			if (input < 0) {
+				addition = -addition;
+			}
+			addition += input;
+			addition /= power_of_ten;
+			if (addition) {
+				return UnsafeNumericCast<TR>(addition * power_of_ten);
+			} else {
+				return 0;
+			}
+		} else {
+			//	Rounding integers to higher precision is a NOP
+			return input;
+		}
+	}
+};
+
 struct RoundPrecisionFunctionData : public FunctionData {
 	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
 	}
@@ -698,10 +727,6 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 		scalar_function_t round_func = nullptr;
 		bind_scalar_function_t bind_func = nullptr;
 		bind_scalar_function_t bind_prec_func = nullptr;
-		if (type.IsIntegral()) {
-			// no round for integral numbers
-			continue;
-		}
 		switch (type.id()) {
 		case LogicalTypeId::FLOAT:
 			round_func = ScalarFunction::UnaryFunction<float, float, RoundOperator>;
@@ -715,7 +740,31 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 			bind_func = BindGenericRoundFunctionDecimal<RoundDecimalOperator>;
 			bind_prec_func = BindDecimalRoundPrecision;
 			break;
+		case LogicalTypeId::TINYINT:
+			round_func = ScalarFunction::NopFunction;
+			round_prec_func = ScalarFunction::BinaryFunction<int8_t, int32_t, int8_t, RoundIntegerOperator>;
+			break;
+		case LogicalTypeId::SMALLINT:
+			round_func = ScalarFunction::NopFunction;
+			round_prec_func = ScalarFunction::BinaryFunction<int16_t, int32_t, int16_t, RoundIntegerOperator>;
+			break;
+		case LogicalTypeId::INTEGER:
+			round_func = ScalarFunction::NopFunction;
+			round_prec_func = ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, RoundIntegerOperator>;
+			break;
+		case LogicalTypeId::BIGINT:
+			round_func = ScalarFunction::NopFunction;
+			round_prec_func = ScalarFunction::BinaryFunction<int64_t, int32_t, int64_t, RoundIntegerOperator>;
+			break;
+		case LogicalTypeId::HUGEINT:
+			round_func = ScalarFunction::NopFunction;
+			round_prec_func = ScalarFunction::BinaryFunction<hugeint_t, int32_t, hugeint_t, RoundIntegerOperator>;
+			break;
 		default:
+			if (type.IsIntegral()) {
+				// no round for integral numbers
+				continue;
+			}
 			throw InternalException("Unimplemented numeric type for function \"floor\"");
 		}
 		round.AddFunction(ScalarFunction({type}, type, round_func, bind_func));

src/duckdb/extension/core_functions/scalar/math/numeric.cpp

@@ -1,10 +1,10 @@
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "include/icu-datefunc.hpp"
 #include "unicode/calendar.h"
 #include "tz_calendar.hpp"
@@ -17,10 +17,10 @@ struct ICUTableRange {
 	struct ICURangeBindData : public TableFunctionData {
 		ICURangeBindData(const ICURangeBindData &other)
 		    : TableFunctionData(other), tz_setting(other.tz_setting), cal_setting(other.cal_setting),
-		      calendar(other.calendar->clone()) {
+		      calendar(other.calendar->clone()), cardinality(other.cardinality) {
 		}
 
-		explicit ICURangeBindData(ClientContext &context) {
+		explicit ICURangeBindData(ClientContext &context, const vector<Value> &inputs) {
 			Value tz_value;
 			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
 				tz_setting = tz_value.ToString();
@@ -43,11 +43,36 @@ struct ICUTableRange {
 			if (U_FAILURE(success)) {
 				throw InternalException("Unable to create ICU calendar.");
 			}
+
+			timestamp_tz_t bounds[2];
+			interval_t step;
+			for (idx_t i = 0; i < inputs.size(); i++) {
+				if (inputs[i].IsNull()) {
+					return;
+				}
+				if (i >= 2) {
+					step = inputs[i].GetValue<interval_t>();
+				} else {
+					bounds[i] = inputs[i].GetValue<timestamp_tz_t>();
+				}
+			}
+			// Estimate cardinality using micros.
+			int64_t increment = 0;
+			if (!Interval::TryGetMicro(step, increment) || !increment) {
+				return;
+			}
+			int64_t delta = 0;
+			if (!TrySubtractOperator::Operation(bounds[1].value, bounds[0].value, delta)) {
+				return;
+			}
+
+			cardinality = idx_t(delta / increment);
 		}
 
 		string tz_setting;
 		string cal_setting;
 		CalendarPtr calendar;
+		idx_t cardinality;
 	};
 
 	struct ICURangeLocalState : public LocalTableFunctionState {
@@ -130,7 +155,7 @@ struct ICUTableRange {
 	template <bool GENERATE_SERIES>
 	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
 	                                     vector<LogicalType> &return_types, vector<string> &names) {
-		auto result = make_uniq<ICURangeBindData>(context);
+		auto result = make_uniq<ICURangeBindData>(context, input.inputs);
 
 		return_types.push_back(LogicalType::TIMESTAMP_TZ);
 		if (GENERATE_SERIES) {
@@ -147,6 +172,14 @@ struct ICUTableRange {
 		return make_uniq<ICURangeLocalState>();
 	}
 
+	static unique_ptr<NodeStatistics> Cardinality(ClientContext &context, const FunctionData *bind_data_p) {
+		if (!bind_data_p) {
+			return nullptr;
+		}
+		auto &bind_data = bind_data_p->Cast<ICURangeBindData>();
+		return make_uniq<NodeStatistics>(bind_data.cardinality, bind_data.cardinality);
+	}
+
 	template <bool GENERATE_SERIES>
 	static OperatorResultType ICUTableRangeFunction(ExecutionContext &context, TableFunctionInput &data_p,
 	                                                DataChunk &input, DataChunk &output) {
@@ -201,6 +234,7 @@ struct ICUTableRange {
 		TableFunction range_function({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                             nullptr, Bind<false>, nullptr, RangeDateTimeLocalInit);
 		range_function.in_out_function = ICUTableRangeFunction<false>;
+		range_function.cardinality = Cardinality;
 		range.AddFunction(range_function);
 		ExtensionUtil::RegisterFunction(db, range);
 
@@ -210,6 +244,7 @@ struct ICUTableRange {
 		    {LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, nullptr, Bind<true>, nullptr,
 		    RangeDateTimeLocalInit);
 		generate_series_function.in_out_function = ICUTableRangeFunction<true>;
+		generate_series_function.cardinality = Cardinality;
 		generate_series.AddFunction(generate_series_function);
 		ExtensionUtil::RegisterFunction(db, generate_series);
 	}

src/duckdb/extension/icu/icu-table-range.cpp

@@ -1563,7 +1563,11 @@ UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLeng
   }
 
   int32_t oldLength = length();
-  int32_t newLength = oldLength + srcLength;
+  int32_t newLength;
+  if (uprv_add32_overflow(oldLength, srcLength, &newLength)) {
+    setToBogus();
+    return *this;
+  }
 
   // Check for append onto ourself
   const UChar* oldArray = getArrayStart();

src/duckdb/extension/icu/third_party/icu/common/unistr.cpp

@@ -18,11 +18,23 @@ using namespace duckdb_yyjson; // NOLINT
 
 namespace duckdb {
 
+class JSONAllocator;
+
+class JSONStringVectorBuffer : public VectorBuffer {
+public:
+	explicit JSONStringVectorBuffer(shared_ptr<JSONAllocator> allocator_p)
+	    : VectorBuffer(VectorBufferType::OPAQUE_BUFFER), allocator(std::move(allocator_p)) {
+	}
+
+private:
+	shared_ptr<JSONAllocator> allocator;
+};
+
 //! JSON allocator is a custom allocator for yyjson that prevents many tiny allocations
-class JSONAllocator {
+class JSONAllocator : public enable_shared_from_this<JSONAllocator> {
 public:
 	explicit JSONAllocator(Allocator &allocator)
-	    : arena_allocator(allocator), yyjson_allocator({Allocate, Reallocate, Free, &arena_allocator}) {
+	    : arena_allocator(allocator), yyjson_allocator({Allocate, Reallocate, Free, this}) {
 	}
 
 	inline yyjson_alc *GetYYAlc() {
@@ -33,15 +45,26 @@ class JSONAllocator {
 		arena_allocator.Reset();
 	}
 
+	void AddBuffer(Vector &vector) {
+		if (vector.GetType().InternalType() == PhysicalType::VARCHAR) {
+			StringVector::AddBuffer(vector, make_buffer<JSONStringVectorBuffer>(shared_from_this()));
+		}
+	}
+
+	static void AddBuffer(Vector &vector, yyjson_alc *alc) {
+		auto alloc = (JSONAllocator *)alc->ctx; // NOLINT
+		alloc->AddBuffer(vector);
+	}
+
 private:
 	static inline void *Allocate(void *ctx, size_t size) {
-		auto alloc = (ArenaAllocator *)ctx;
-		return alloc->AllocateAligned(size);
+		auto alloc = (JSONAllocator *)ctx; // NOLINT
+		return alloc->arena_allocator.AllocateAligned(size);
 	}
 
 	static inline void *Reallocate(void *ctx, void *ptr, size_t old_size, size_t size) {
-		auto alloc = (ArenaAllocator *)ctx;
-		return alloc->ReallocateAligned(data_ptr_cast(ptr), old_size, size);
+		auto alloc = (JSONAllocator *)ctx; // NOLINT
+		return alloc->arena_allocator.ReallocateAligned(data_ptr_cast(ptr), old_size, size);
 	}
 
 	static inline void Free(void *ctx, void *ptr) {
@@ -304,6 +327,20 @@ struct JSONCommon {
 	//! Validate JSON Path ($.field[index]... syntax), returns true if there are wildcards in the path
 	static JSONPathType ValidatePath(const char *ptr, const idx_t &len, const bool binder);
 
+public:
+	//! Same as BigQuery json_value
+	static inline string_t JSONValue(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &mask, idx_t idx) {
+		switch (yyjson_get_tag(val)) {
+		case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
+		case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
+		case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
+			mask.SetInvalid(idx);
+			return string_t {};
+		default:
+			return JSONCommon::WriteVal<yyjson_val>(val, alc);
+		}
+	}
+
 private:
 	//! Get JSON pointer (/field/index/... syntax)
 	static inline yyjson_val *GetPointer(yyjson_val *val, const char *ptr, const idx_t &len) {