duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/.github/workflows/NodeJS.yml

@@ -243,7 +243,7 @@ jobs:
 
   win-nodejs:
     name: node.js Windows
-    runs-on: windows-latest
+    runs-on: windows-2019
     needs: set-up-npm
     continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
     env:

package/binding.gyp

@@ -26,6 +26,7 @@
                 "src/duckdb/ub_src_common_row_operations.cpp", 
                 "src/duckdb/ub_src_common_serializer.cpp", 
                 "src/duckdb/ub_src_common_sort.cpp", 
+                "src/duckdb/ub_src_common_tree_renderer.cpp", 
                 "src/duckdb/ub_src_common_types.cpp", 
                 "src/duckdb/ub_src_common_types_column.cpp", 
                 "src/duckdb/ub_src_common_types_row.cpp", 
@@ -243,6 +244,7 @@
                 "src/duckdb/extension/parquet/parquet_writer.cpp", 
                 "src/duckdb/extension/parquet/serialize_parquet.cpp", 
                 "src/duckdb/extension/parquet/zstd_file_system.cpp", 
+                "src/duckdb/extension/parquet/geo_parquet.cpp", 
                 "src/duckdb/third_party/parquet/parquet_constants.cpp", 
                 "src/duckdb/third_party/parquet/parquet_types.cpp", 
                 "src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp", 
@@ -272,6 +274,37 @@
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
                 "src/duckdb/third_party/lz4/lz4.cpp", 
+                "src/duckdb/third_party/brotli/common/constants.cpp", 
+                "src/duckdb/third_party/brotli/common/context.cpp", 
+                "src/duckdb/third_party/brotli/common/dictionary.cpp", 
+                "src/duckdb/third_party/brotli/common/platform.cpp", 
+                "src/duckdb/third_party/brotli/common/shared_dictionary.cpp", 
+                "src/duckdb/third_party/brotli/common/transform.cpp", 
+                "src/duckdb/third_party/brotli/dec/bit_reader.cpp", 
+                "src/duckdb/third_party/brotli/dec/decode.cpp", 
+                "src/duckdb/third_party/brotli/dec/huffman.cpp", 
+                "src/duckdb/third_party/brotli/dec/state.cpp", 
+                "src/duckdb/third_party/brotli/enc/backward_references.cpp", 
+                "src/duckdb/third_party/brotli/enc/backward_references_hq.cpp", 
+                "src/duckdb/third_party/brotli/enc/bit_cost.cpp", 
+                "src/duckdb/third_party/brotli/enc/block_splitter.cpp", 
+                "src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp", 
+                "src/duckdb/third_party/brotli/enc/cluster.cpp", 
+                "src/duckdb/third_party/brotli/enc/command.cpp", 
+                "src/duckdb/third_party/brotli/enc/compound_dictionary.cpp", 
+                "src/duckdb/third_party/brotli/enc/compress_fragment.cpp", 
+                "src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp", 
+                "src/duckdb/third_party/brotli/enc/dictionary_hash.cpp", 
+                "src/duckdb/third_party/brotli/enc/encode.cpp", 
+                "src/duckdb/third_party/brotli/enc/encoder_dict.cpp", 
+                "src/duckdb/third_party/brotli/enc/entropy_encode.cpp", 
+                "src/duckdb/third_party/brotli/enc/fast_log.cpp", 
+                "src/duckdb/third_party/brotli/enc/histogram.cpp", 
+                "src/duckdb/third_party/brotli/enc/literal_cost.cpp", 
+                "src/duckdb/third_party/brotli/enc/memory.cpp", 
+                "src/duckdb/third_party/brotli/enc/metablock.cpp", 
+                "src/duckdb/third_party/brotli/enc/static_dict.cpp", 
+                "src/duckdb/third_party/brotli/enc/utf8_util.cpp", 
                 "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
@@ -313,6 +346,10 @@
                 "src/duckdb/third_party/libpg_query", 
                 "src/duckdb/third_party/libpg_query/include", 
                 "src/duckdb/third_party/lz4", 
+                "src/duckdb/third_party/brotli/include", 
+                "src/duckdb/third_party/brotli/common", 
+                "src/duckdb/third_party/brotli/dec", 
+                "src/duckdb/third_party/brotli/enc", 
                 "src/duckdb/third_party/mbedtls", 
                 "src/duckdb/third_party/mbedtls/include", 
                 "src/duckdb/third_party/mbedtls/library", 
@@ -328,6 +365,10 @@
                 "src/duckdb/third_party/parquet", 
                 "src/duckdb/third_party/thrift", 
                 "src/duckdb/third_party/lz4", 
+                "src/duckdb/third_party/brotli/include", 
+                "src/duckdb/third_party/brotli/common", 
+                "src/duckdb/third_party/brotli/dec", 
+                "src/duckdb/third_party/brotli/enc", 
                 "src/duckdb/third_party/snappy", 
                 "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/third_party/mbedtls", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "1.0.1-dev22.0",
+  "version": "1.0.1-dev27.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -101,13 +101,15 @@ timestamp_t ICUCalendarAdd::Operation(timestamp_t timestamp, interval_t interval
 		calendar->add(UCAL_MINUTE, interval_m, status);
 		CalendarAddHour(calendar, interval_h, status);
 
-		calendar->add(UCAL_DATE, interval.days, status);
+		// PG Adds months before days
 		calendar->add(UCAL_MONTH, interval.months, status);
+		calendar->add(UCAL_DATE, interval.days, status);
 	} else {
-		// Add interval fields from highest to lowest (ragged to non-ragged)
+		// PG Adds months before days
 		calendar->add(UCAL_MONTH, interval.months, status);
 		calendar->add(UCAL_DATE, interval.days, status);
 
+		// Add interval fields from highest to lowest (ragged to non-ragged)
 		CalendarAddHour(calendar, interval_h, status);
 		calendar->add(UCAL_MINUTE, interval_m, status);
 		calendar->add(UCAL_SECOND, interval_s, status);

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -73,6 +73,10 @@ unique_ptr<FunctionData> ICUDateFunc::Bind(ClientContext &context, ScalarFunctio
 
 void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
 	auto tz = icu_66::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_id.GetString())));
+	if (*tz == icu::TimeZone::getUnknown()) {
+		delete tz;
+		throw NotImplementedException("Unknown TimeZone '%s'", tz_id.GetString());
+	}
 	calendar->adoptTimeZone(tz);
 }
 
@@ -83,7 +87,7 @@ timestamp_t ICUDateFunc::GetTimeUnsafe(icu::Calendar *calendar, uint64_t micros)
 	if (U_FAILURE(status)) {
 		throw InternalException("Unable to get ICU calendar time.");
 	}
-	return timestamp_t(millis * Interval::MICROS_PER_MSEC + micros);
+	return timestamp_t(millis * Interval::MICROS_PER_MSEC + int64_t(micros));
 }
 
 bool ICUDateFunc::TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp_t &result) {
@@ -98,7 +102,7 @@ bool ICUDateFunc::TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp
 	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(millis, Interval::MICROS_PER_MSEC, millis)) {
 		return false;
 	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(millis, micros, millis)) {
+	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(millis, int64_t(micros), millis)) {
 		return false;
 	}
 

package/src/duckdb/extension/icu/icu-datesub.cpp

@@ -209,6 +209,17 @@ struct ICUCalendarDiff : public ICUDateFunc {
 		return sub_func(calendar, start_date, end_date);
 	}
 
+	static part_trunc_t DiffTruncationFactory(DatePartSpecifier type) {
+		switch (type) {
+		case DatePartSpecifier::WEEK:
+			//	Weeks are computed without anchors
+			return TruncationFactory(DatePartSpecifier::DAY);
+		default:
+			break;
+		}
+		return TruncationFactory(type);
+	}
+
 	template <typename T>
 	static void ICUDateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 3);
@@ -229,7 +240,7 @@ struct ICUCalendarDiff : public ICUDateFunc {
 			} else {
 				const auto specifier = ConstantVector::GetData<string_t>(part_arg)->GetString();
 				const auto part = GetDatePartSpecifier(specifier);
-				auto trunc_func = TruncationFactory(part);
+				auto trunc_func = DiffTruncationFactory(part);
 				auto sub_func = SubtractFactory(part);
 				BinaryExecutor::ExecuteWithNulls<T, T, int64_t>(
 				    startdate_arg, enddate_arg, result, args.size(),
@@ -248,7 +259,7 @@ struct ICUCalendarDiff : public ICUDateFunc {
 			    [&](string_t specifier, T start_date, T end_date, ValidityMask &mask, idx_t idx) {
 				    if (Timestamp::IsFinite(start_date) && Timestamp::IsFinite(end_date)) {
 					    const auto part = GetDatePartSpecifier(specifier.GetString());
-					    auto trunc_func = TruncationFactory(part);
+					    auto trunc_func = DiffTruncationFactory(part);
 					    auto sub_func = SubtractFactory(part);
 					    return DifferenceFunc<T>(calendar, start_date, end_date, trunc_func, sub_func);
 				    } else {

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -68,15 +68,15 @@ struct ICUStrptime : public ICUDateFunc {
 		}
 
 		// Now get the parts in the given time zone
-		uint64_t micros = 0;
+		uint64_t micros = parsed.GetMicros();
 		calendar->set(UCAL_EXTENDED_YEAR, parsed.data[0]); // strptime doesn't understand eras
 		calendar->set(UCAL_MONTH, parsed.data[1] - 1);
 		calendar->set(UCAL_DATE, parsed.data[2]);
 		calendar->set(UCAL_HOUR_OF_DAY, parsed.data[3]);
 		calendar->set(UCAL_MINUTE, parsed.data[4]);
 		calendar->set(UCAL_SECOND, parsed.data[5]);
-		calendar->set(UCAL_MILLISECOND, parsed.data[6] / Interval::MICROS_PER_MSEC);
-		micros = parsed.data[6] % Interval::MICROS_PER_MSEC;
+		calendar->set(UCAL_MILLISECOND, micros / Interval::MICROS_PER_MSEC);
+		micros %= Interval::MICROS_PER_MSEC;
 
 		// This overrides the TZ setting, so only use it if an offset was parsed.
 		// Note that we don't bother/worry about the DST setting because the two just combine.
@@ -158,7 +158,7 @@ struct ICUStrptime : public ICUDateFunc {
 		}
 	}
 
-	static bind_scalar_function_t bind_strptime;
+	static bind_scalar_function_t bind_strptime; // NOLINT
 
 	static duckdb::unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
 	                                                             vector<duckdb::unique_ptr<Expression>> &arguments) {
@@ -194,7 +194,7 @@ struct ICUStrptime : public ICUDateFunc {
 				throw InvalidInputException("strptime format list must not be empty");
 			}
 			vector<StrpTimeFormat> formats;
-			bool has_tz = true;
+			bool has_tz = false;
 			for (const auto &child : children) {
 				format_string = child.ToString();
 				format.format_specifier = format_string;
@@ -341,7 +341,7 @@ struct ICUStrptime : public ICUDateFunc {
 	}
 };
 
-bind_scalar_function_t ICUStrptime::bind_strptime = nullptr;
+bind_scalar_function_t ICUStrptime::bind_strptime = nullptr; // NOLINT
 
 struct ICUStrftime : public ICUDateFunc {
 	static void ParseFormatSpecifier(string_t &format_str, StrfTimeFormat &format) {

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

@@ -13,14 +13,13 @@ namespace duckdb {
 struct ICUTableRange {
 	using CalendarPtr = unique_ptr<icu::Calendar>;
 
-	struct BindData : public TableFunctionData {
-		BindData(const BindData &other)
+	struct ICURangeBindData : public TableFunctionData {
+		ICURangeBindData(const ICURangeBindData &other)
 		    : TableFunctionData(other), tz_setting(other.tz_setting), cal_setting(other.cal_setting),
-		      calendar(other.calendar->clone()), start(other.start), end(other.end), increment(other.increment),
-		      inclusive_bound(other.inclusive_bound), greater_than_check(other.greater_than_check) {
+		      calendar(other.calendar->clone()) {
 		}
 
-		explicit BindData(ClientContext &context) {
+		explicit ICURangeBindData(ClientContext &context) {
 			Value tz_value;
 			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
 				tz_setting = tz_value.ToString();
@@ -48,6 +47,15 @@ struct ICUTableRange {
 		string tz_setting;
 		string cal_setting;
 		CalendarPtr calendar;
+	};
+
+	struct ICURangeLocalState : public LocalTableFunctionState {
+		ICURangeLocalState() {
+		}
+
+		bool initialized_row = false;
+		idx_t current_input_row = 0;
+		timestamp_t current_state;
 
 		timestamp_t start;
 		timestamp_t end;
@@ -55,17 +63,6 @@ struct ICUTableRange {
 		bool inclusive_bound;
 		bool greater_than_check;
 
-		bool Equals(const FunctionData &other_p) const override {
-			auto &other = other_p.Cast<const BindData>();
-			return other.start == start && other.end == end && other.increment == increment &&
-			       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check &&
-			       *calendar == *other.calendar;
-		}
-
-		unique_ptr<FunctionData> Copy() const override {
-			return make_uniq<BindData>(*this);
-		}
-
 		bool Finished(timestamp_t current_value) const {
 			if (greater_than_check) {
 				if (inclusive_bound) {
@@ -84,107 +81,129 @@ 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<BindData>(context);
-
-		auto &inputs = input.inputs;
-		D_ASSERT(inputs.size() == 3);
-		for (const auto &value : inputs) {
-			if (value.IsNull()) {
-				throw BinderException("RANGE with NULL bounds is not supported");
+	static void GenerateRangeDateTimeParameters(DataChunk &input, idx_t row_id, ICURangeLocalState &result) {
+		input.Flatten();
+		for (idx_t c = 0; c < input.ColumnCount(); c++) {
+			if (FlatVector::IsNull(input.data[c], row_id)) {
+				result.start = timestamp_t(0);
+				result.end = timestamp_t(0);
+				result.increment = interval_t();
+				result.greater_than_check = true;
+				result.inclusive_bound = false;
+				return;
 			}
 		}
-		result->start = inputs[0].GetValue<timestamp_t>();
-		result->end = inputs[1].GetValue<timestamp_t>();
-		result->increment = inputs[2].GetValue<interval_t>();
+
+		result.start = FlatVector::GetValue<timestamp_t>(input.data[0], row_id);
+		result.end = FlatVector::GetValue<timestamp_t>(input.data[1], row_id);
+		result.increment = FlatVector::GetValue<interval_t>(input.data[2], row_id);
 
 		// Infinities either cause errors or infinite loops, so just ban them
-		if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+		if (!Timestamp::IsFinite(result.start) || !Timestamp::IsFinite(result.end)) {
 			throw BinderException("RANGE with infinite bounds is not supported");
 		}
 
-		if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
+		if (result.increment.months == 0 && result.increment.days == 0 && result.increment.micros == 0) {
 			throw BinderException("interval cannot be 0!");
 		}
 		// all elements should point in the same direction
-		if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
-			if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
+		if (result.increment.months > 0 || result.increment.days > 0 || result.increment.micros > 0) {
+			if (result.increment.months < 0 || result.increment.days < 0 || result.increment.micros < 0) {
 				throw BinderException("RANGE with composite interval that has mixed signs is not supported");
 			}
-			result->greater_than_check = true;
-			if (result->start > result->end) {
+			result.greater_than_check = true;
+			if (result.start > result.end) {
 				throw BinderException(
 				    "start is bigger than end, but increment is positive: cannot generate infinite series");
 			}
 		} else {
-			result->greater_than_check = false;
-			if (result->start < result->end) {
+			result.greater_than_check = false;
+			if (result.start < result.end) {
 				throw BinderException(
 				    "start is smaller than end, but increment is negative: cannot generate infinite series");
 			}
 		}
-		return_types.push_back(inputs[0].type());
+		result.inclusive_bound = GENERATE_SERIES;
+	}
+
+	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);
+
+		return_types.push_back(LogicalType::TIMESTAMP_TZ);
 		if (GENERATE_SERIES) {
-			// generate_series has inclusive bounds on the RHS
-			result->inclusive_bound = true;
 			names.emplace_back("generate_series");
 		} else {
-			result->inclusive_bound = false;
 			names.emplace_back("range");
 		}
 		return std::move(result);
 	}
 
-	struct State : public GlobalTableFunctionState {
-		explicit State(timestamp_t start_p) : current_state(start_p) {
-		}
-
-		timestamp_t current_state;
-		bool finished = false;
-	};
-
-	static unique_ptr<GlobalTableFunctionState> Init(ClientContext &context, TableFunctionInitInput &input) {
-		auto &bind_data = input.bind_data->Cast<BindData>();
-		return make_uniq<State>(bind_data.start);
+	static unique_ptr<LocalTableFunctionState> RangeDateTimeLocalInit(ExecutionContext &context,
+	                                                                  TableFunctionInitInput &input,
+	                                                                  GlobalTableFunctionState *global_state) {
+		return make_uniq<ICURangeLocalState>();
 	}
 
-	static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-		auto &bind_data = data_p.bind_data->Cast<BindData>();
+	template <bool GENERATE_SERIES>
+	static OperatorResultType ICUTableRangeFunction(ExecutionContext &context, TableFunctionInput &data_p,
+	                                                DataChunk &input, DataChunk &output) {
+		auto &bind_data = data_p.bind_data->Cast<ICURangeBindData>();
+		auto &state = data_p.local_state->Cast<ICURangeLocalState>();
 		CalendarPtr calendar_ptr(bind_data.calendar->clone());
 		auto calendar = calendar_ptr.get();
-		auto &state = data_p.global_state->Cast<State>();
-		if (state.finished) {
-			return;
-		}
-
-		idx_t size = 0;
-		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
 		while (true) {
-			data[size++] = state.current_state;
-			state.current_state = ICUDateFunc::Add(calendar, state.current_state, bind_data.increment);
-			if (bind_data.Finished(state.current_state)) {
-				state.finished = true;
-				break;
+			if (!state.initialized_row) {
+				// initialize for the current input row
+				if (state.current_input_row >= input.size()) {
+					// ran out of rows
+					state.current_input_row = 0;
+					state.initialized_row = false;
+					return OperatorResultType::NEED_MORE_INPUT;
+				}
+				GenerateRangeDateTimeParameters<GENERATE_SERIES>(input, state.current_input_row, state);
+				state.initialized_row = true;
+				state.current_state = state.start;
+			}
+			idx_t size = 0;
+			auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+			while (true) {
+				if (state.Finished(state.current_state)) {
+					break;
+				}
+				data[size++] = state.current_state;
+				state.current_state = ICUDateFunc::Add(calendar, state.current_state, state.increment);
+				if (size >= STANDARD_VECTOR_SIZE) {
+					break;
+				}
 			}
-			if (size >= STANDARD_VECTOR_SIZE) {
-				break;
+			if (size == 0) {
+				// move to next row
+				state.current_input_row++;
+				state.initialized_row = false;
+				continue;
 			}
+			output.SetCardinality(size);
+			return OperatorResultType::HAVE_MORE_OUTPUT;
 		}
-		output.SetCardinality(size);
 	}
 
 	static void AddICUTableRangeFunction(DatabaseInstance &db) {
 		TableFunctionSet range("range");
-		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
-		                                ICUTableRangeFunction, Bind<false>, Init));
+		TableFunction range_function({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                             nullptr, Bind<false>, nullptr, RangeDateTimeLocalInit);
+		range_function.in_out_function = ICUTableRangeFunction<false>;
+		range.AddFunction(range_function);
 		ExtensionUtil::AddFunctionOverload(db, range);
 
 		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 		TableFunctionSet generate_series("generate_series");
-		generate_series.AddFunction(
-		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
-		                  ICUTableRangeFunction, Bind<true>, Init));
+		TableFunction generate_series_function(
+		    {LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, nullptr, Bind<true>, nullptr,
+		    RangeDateTimeLocalInit);
+		generate_series_function.in_out_function = ICUTableRangeFunction<true>;
+		generate_series.AddFunction(generate_series_function);
 		ExtensionUtil::AddFunctionOverload(db, generate_series);
 	}
 };

package/src/duckdb/extension/icu/icu-timebucket.cpp

@@ -63,6 +63,9 @@ struct ICUTimeBucket : public ICUDateFunc {
 
 	static inline timestamp_t WidthConvertibleToMicrosCommon(int64_t bucket_width_micros, const timestamp_t ts,
 	                                                         const timestamp_t origin, icu::Calendar *calendar) {
+		if (!bucket_width_micros) {
+			throw OutOfRangeException("Can't bucket using zero microseconds");
+		}
 		int64_t ts_micros = SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(
 		    Timestamp::GetEpochMicroSeconds(ts), Timestamp::GetEpochMicroSeconds(origin));
 		int64_t result_micros = (ts_micros / bucket_width_micros) * bucket_width_micros;
@@ -76,6 +79,9 @@ struct ICUTimeBucket : public ICUDateFunc {
 
 	static inline timestamp_t WidthConvertibleToDaysCommon(int32_t bucket_width_days, const timestamp_t ts,
 	                                                       const timestamp_t origin, icu::Calendar *calendar) {
+		if (!bucket_width_days) {
+			throw OutOfRangeException("Can't bucket using zero days");
+		}
 		const auto sub_days = SubtractFactory(DatePartSpecifier::DAY);
 
 		int64_t ts_days = sub_days(calendar, origin, ts);
@@ -95,6 +101,9 @@ struct ICUTimeBucket : public ICUDateFunc {
 
 	static inline timestamp_t WidthConvertibleToMonthsCommon(int32_t bucket_width_months, const timestamp_t ts,
 	                                                         const timestamp_t origin, icu::Calendar *calendar) {
+		if (!bucket_width_months) {
+			throw OutOfRangeException("Can't bucket using zero months");
+		}
 		const auto trunc_months = TruncationFactory(DatePartSpecifier::MONTH);
 		const auto sub_months = SubtractFactory(DatePartSpecifier::MONTH);
 
@@ -106,8 +115,9 @@ struct ICUTimeBucket : public ICUDateFunc {
 		trunc_months(calendar, tmp_micros);
 		timestamp_t truncated_origin = GetTimeUnsafe(calendar, tmp_micros);
 
-		int64_t ts_months = sub_months(calendar, truncated_origin, truncated_ts);
-		int64_t result_months = (ts_months / bucket_width_months) * bucket_width_months;
+		int32_t ts_months =
+		    NumericCast<int64_t, int32_t>(sub_months(calendar, truncated_origin, truncated_ts)); // NOLINT
+		auto result_months = (ts_months / bucket_width_months) * bucket_width_months;
 		if (result_months < NumericLimits<int32_t>::Minimum() || result_months > NumericLimits<int32_t>::Maximum()) {
 			throw OutOfRangeException("Timestamp out of range");
 		}

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -125,7 +125,7 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		int32_t secs;
 		int32_t frac;
 		Time::Convert(local_time, hr, mn, secs, frac);
-		int32_t millis = frac / Interval::MICROS_PER_MSEC;
+		int32_t millis = frac / int32_t(Interval::MICROS_PER_MSEC);
 		uint64_t micros = frac % Interval::MICROS_PER_MSEC;
 
 		// Use them to set the time in the time zone
@@ -199,7 +199,7 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		}
 
 		// Extract the time zone parts
-		auto micros = SetTime(calendar, instant);
+		auto micros = int32_t(SetTime(calendar, instant));
 		const auto era = ExtractField(calendar, UCAL_ERA);
 		const auto year = ExtractField(calendar, UCAL_YEAR);
 		const auto mm = ExtractField(calendar, UCAL_MONTH) + 1;
@@ -216,7 +216,7 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		const auto secs = ExtractField(calendar, UCAL_SECOND);
 		const auto millis = ExtractField(calendar, UCAL_MILLISECOND);
 
-		micros += millis * Interval::MICROS_PER_MSEC;
+		micros += millis * int32_t(Interval::MICROS_PER_MSEC);
 		dtime_t local_time = Time::FromTime(hr, mn, secs, micros);
 
 		timestamp_t naive;