duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -142,7 +142,7 @@ struct ICUCalendarSub : public ICUDateFunc {
 	static void AddFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -278,7 +278,7 @@ struct ICUCalendarDiff : public ICUDateFunc {
 	static void AddFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 

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

@@ -177,7 +177,7 @@ struct ICUDateTrunc : public ICUDateFunc {
 	static void AddBinaryTimestampFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDateTruncFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -224,6 +224,13 @@ ICUDateFunc::part_trunc_t ICUDateFunc::TruncationFactory(DatePartSpecifier type)
 	}
 }
 
+timestamp_t ICUDateFunc::CurrentMidnight(icu::Calendar *calendar, ExpressionState &state) {
+	const auto current_timestamp = MetaTransaction::Get(state.GetContext()).start_timestamp;
+	auto current_micros = SetTime(calendar, current_timestamp);
+	ICUDateTrunc::TruncDay(calendar, current_micros);
+	return GetTime(calendar);
+}
+
 void RegisterICUDateTruncFunctions(DatabaseInstance &db) {
 	ICUDateTrunc::AddBinaryTimestampFunction("date_trunc", db);
 	ICUDateTrunc::AddBinaryTimestampFunction("datetrunc", db);

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

@@ -187,14 +187,14 @@ struct ICUListRange : public ICUDateFunc {
 		range.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                                 LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<false>,
 		                                 Bind));
-		ExtensionUtil::AddFunctionOverload(db, range);
+		ExtensionUtil::RegisterFunction(db, range);
 
 		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 		ScalarFunctionSet generate_series("generate_series");
 		generate_series.AddFunction(
 		    ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                   LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<true>, Bind));
-		ExtensionUtil::AddFunctionOverload(db, generate_series);
+		ExtensionUtil::RegisterFunction(db, generate_series);
 	}
 };
 

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

@@ -94,8 +94,13 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 
 	template <typename T>
 	static void FromMicros(DataChunk &input, ExpressionState &state, Vector &result) {
-		UnaryExecutor::Execute<T, timestamp_t>(input.data[0], result, input.size(),
-		                                       [&](T micros) { return timestamp_t(micros); });
+		UnaryExecutor::Execute<T, timestamp_t>(input.data[0], result, input.size(), [&](T micros) {
+			const auto result = timestamp_t(micros);
+			if (!Timestamp::IsFinite(result)) {
+				throw ConversionException("Timestamp microseconds out of range: %ld", micros);
+			}
+			return result;
+		});
 	}
 
 	template <typename T>
@@ -137,21 +142,27 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 
 	template <typename TA>
 	static ScalarFunction GetSenaryFunction(const LogicalTypeId &type) {
-		return ScalarFunction({type, type, type, type, type, LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ,
-		                      Execute<TA>, Bind);
+		ScalarFunction function({type, type, type, type, type, LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ,
+		                        Execute<TA>, Bind);
+		BaseScalarFunction::SetReturnsError(function);
+		return function;
 	}
 
 	template <typename TA>
 	static ScalarFunction GetSeptenaryFunction(const LogicalTypeId &type) {
-		return ScalarFunction({type, type, type, type, type, LogicalType::DOUBLE, LogicalType::VARCHAR},
-		                      LogicalType::TIMESTAMP_TZ, Execute<TA>, Bind);
+		ScalarFunction function({type, type, type, type, type, LogicalType::DOUBLE, LogicalType::VARCHAR},
+		                        LogicalType::TIMESTAMP_TZ, Execute<TA>, Bind);
+		BaseScalarFunction::SetReturnsError(function);
+		return function;
 	}
 
 	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetSenaryFunction<int64_t>(LogicalType::BIGINT));
 		set.AddFunction(GetSeptenaryFunction<int64_t>(LogicalType::BIGINT));
-		set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP_TZ, FromMicros<int64_t>));
+		ScalarFunction function({LogicalType::BIGINT}, LogicalType::TIMESTAMP_TZ, FromMicros<int64_t>);
+		BaseScalarFunction::SetReturnsError(function);
+		set.AddFunction(function);
 		ExtensionUtil::RegisterFunction(db, set);
 	}
 };

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

@@ -258,8 +258,14 @@ struct ICUStrptime : public ICUDateFunc {
 			    const auto len = input.GetSize();
 			    string_t tz(nullptr, 0);
 			    bool has_offset = false;
-			    if (!Timestamp::TryConvertTimestampTZ(str, len, result, has_offset, tz)) {
-				    auto msg = Timestamp::ConversionError(string(str, len));
+			    auto success = Timestamp::TryConvertTimestampTZ(str, len, result, has_offset, tz);
+			    if (success != TimestampCastResult::SUCCESS) {
+				    string msg;
+				    if (success == TimestampCastResult::ERROR_RANGE) {
+					    msg = Timestamp::RangeError(string(str, len));
+				    } else {
+					    msg = Timestamp::FormatError(string(str, len));
+				    }
 				    HandleCastError::AssignError(msg, parameters);
 				    mask.SetInvalid(idx);
 			    } else if (!has_offset) {
@@ -434,7 +440,7 @@ struct ICUStrftime : public ICUDateFunc {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 		                               ICUStrftimeFunction, Bind));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 
 	static string_t CastOperation(icu::Calendar *calendar, timestamp_t input, Vector &result) {

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

@@ -195,7 +195,7 @@ struct ICUTableRange {
 		                             nullptr, Bind<false>, nullptr, RangeDateTimeLocalInit);
 		range_function.in_out_function = ICUTableRangeFunction<false>;
 		range.AddFunction(range_function);
-		ExtensionUtil::AddFunctionOverload(db, range);
+		ExtensionUtil::RegisterFunction(db, range);
 
 		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 		TableFunctionSet generate_series("generate_series");
@@ -204,7 +204,7 @@ struct ICUTableRange {
 		    RangeDateTimeLocalInit);
 		generate_series_function.in_out_function = ICUTableRangeFunction<true>;
 		generate_series.AddFunction(generate_series_function);
-		ExtensionUtil::AddFunctionOverload(db, generate_series);
+		ExtensionUtil::RegisterFunction(db, generate_series);
 	}
 };
 

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

@@ -631,7 +631,10 @@ struct ICUTimeBucket : public ICUDateFunc {
 		                               LogicalType::TIMESTAMP_TZ, ICUTimeBucketOriginFunction, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR},
 		                               LogicalType::TIMESTAMP_TZ, ICUTimeBucketTimeZoneFunction, Bind));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		for (auto &func : set.functions) {
+			BaseScalarFunction::SetReturnsError(func);
+		}
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 

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

@@ -339,6 +339,68 @@ struct ICUToTimeTZ : public ICUDateFunc {
 		time = Interval::Add(time, {0, 0, offset * Interval::MICROS_PER_SEC}, date);
 		return dtime_tz_t(time, offset);
 	}
+
+	static inline bool ToTimeTZ(icu::Calendar *calendar, timestamp_t instant, dtime_tz_t &result) {
+		if (!ICUIsFinite(instant)) {
+			return false;
+		}
+
+		//	Time in current TZ
+		auto micros = int32_t(SetTime(calendar, instant));
+		const auto hour = ExtractField(calendar, UCAL_HOUR_OF_DAY);
+		const auto minute = ExtractField(calendar, UCAL_MINUTE);
+		const auto second = ExtractField(calendar, UCAL_SECOND);
+		const auto millis = ExtractField(calendar, UCAL_MILLISECOND);
+		micros += millis * int32_t(Interval::MICROS_PER_MSEC);
+		if (!Time::IsValidTime(hour, minute, second, micros)) {
+			return false;
+		}
+		const auto time = Time::FromTime(hour, minute, second, micros);
+
+		//	Offset in current TZ
+		auto offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
+		offset += ExtractField(calendar, UCAL_DST_OFFSET);
+		offset /= Interval::MSECS_PER_SEC;
+
+		result = dtime_tz_t(time, offset);
+		return true;
+	}
+
+	static bool CastToTimeTZ(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
+		auto &info = cast_data.info->Cast<BindData>();
+		CalendarPtr calendar(info.calendar->clone());
+
+		UnaryExecutor::ExecuteWithNulls<timestamp_t, dtime_tz_t>(source, result, count,
+		                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
+			                                                         dtime_tz_t output;
+			                                                         if (ToTimeTZ(calendar.get(), input, output)) {
+				                                                         return output;
+			                                                         } else {
+				                                                         mask.SetInvalid(idx);
+				                                                         return dtime_tz_t();
+			                                                         }
+		                                                         });
+		return true;
+	}
+
+	static BoundCastInfo BindCastToTimeTZ(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+		if (!input.context) {
+			throw InternalException("Missing context for TIMESTAMPTZ to TIMETZ cast.");
+		}
+
+		auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
+
+		return BoundCastInfo(CastToTimeTZ, std::move(cast_data));
+	}
+
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
+		auto &casts = config.GetCastFunctions();
+
+		const auto implicit_cost = CastRules::ImplicitCast(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ);
+		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ, BindCastToTimeTZ, implicit_cost);
+	}
 };
 
 struct ICUTimeZoneFunc : public ICUDateFunc {
@@ -382,7 +444,10 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 		                               Execute<ICUToNaiveTimestamp, timestamp_t>, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
 		                               Execute<ICUToTimeTZ, dtime_tz_t>, Bind));
-		ExtensionUtil::AddFunctionOverload(db, set);
+		for (auto &func : set.functions) {
+			BaseScalarFunction::SetReturnsError(func);
+		}
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -403,6 +468,7 @@ void RegisterICUTimeZoneFunctions(DatabaseInstance &db) {
 	// 	Casts
 	ICUFromNaiveTimestamp::AddCasts(db);
 	ICUToNaiveTimestamp::AddCasts(db);
+	ICUToTimeTZ::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -154,7 +154,6 @@ static void ICUCollateFunction(DataChunk &args, ExpressionState &state, Vector &
 			str_data[i * 2 + 1] = HEX_TABLE[byte % 16];
 		}
 		str_result.Finalize();
-		// printf("%s: %s\n", input.GetString().c_str(), str_result.GetString().c_str());
 		return str_result;
 	});
 }
@@ -215,9 +214,36 @@ static void SetICUTimeZone(ClientContext &context, SetScope scope, Value &parame
 	icu::StringPiece utf8(str);
 	const auto uid = icu::UnicodeString::fromUTF8(utf8);
 	duckdb::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createTimeZone(uid));
-	if (*tz == icu::TimeZone::getUnknown()) {
-		throw NotImplementedException("Unknown TimeZone '%s'", str);
+	if (*tz != icu::TimeZone::getUnknown()) {
+		return;
 	}
+
+	//	Try to be friendlier
+	//	Go through all the zone names and look for a case insensitive match
+	//	If we don't find one, make a suggestion
+	UErrorCode status = U_ZERO_ERROR;
+	duckdb::unique_ptr<icu::Calendar> calendar(icu::Calendar::createInstance(status));
+	duckdb::unique_ptr<icu::StringEnumeration> tzs(icu::TimeZone::createEnumeration());
+	vector<string> candidates;
+	for (;;) {
+		auto long_id = tzs->snext(status);
+		if (U_FAILURE(status) || !long_id) {
+			break;
+		}
+		std::string utf8;
+		long_id->toUTF8String(utf8);
+		if (StringUtil::CIEquals(utf8, str)) {
+			parameter = Value(utf8);
+			return;
+		}
+
+		candidates.emplace_back(utf8);
+	}
+
+	string candidate_str =
+	    StringUtil::CandidatesMessage(StringUtil::TopNJaroWinkler(candidates, str), "Candidate time zones");
+
+	throw NotImplementedException("Unknown TimeZone '%s'!\n%s", str, candidate_str);
 }
 
 struct ICUCalendarData : public GlobalTableFunctionState {
@@ -274,9 +300,38 @@ static void SetICUCalendar(ClientContext &context, SetScope scope, Value &parame
 
 	UErrorCode status = U_ZERO_ERROR;
 	duckdb::unique_ptr<icu::Calendar> cal(icu::Calendar::createInstance(locale, status));
-	if (U_FAILURE(status) || name != cal->getType()) {
-		throw NotImplementedException("Unknown Calendar setting");
+	if (!U_FAILURE(status) && name == cal->getType()) {
+		return;
+	}
+
+	//	Try to be friendlier
+	//	Go through all the calendar names and look for a case insensitive match
+	//	If we don't find one, make a suggestion
+	status = U_ZERO_ERROR;
+	duckdb::unique_ptr<icu::StringEnumeration> calendars;
+	calendars.reset(icu::Calendar::getKeywordValuesForLocale("calendar", icu::Locale::getDefault(), false, status));
+
+	vector<string> candidates;
+	for (;;) {
+		auto calendar = calendars->snext(status);
+		if (U_FAILURE(status) || !calendar) {
+			break;
+		}
+
+		std::string utf8;
+		calendar->toUTF8String(utf8);
+		if (StringUtil::CIEquals(utf8, name)) {
+			parameter = Value(utf8);
+			return;
+		}
+
+		candidates.emplace_back(utf8);
 	}
+
+	string candidate_str =
+	    StringUtil::CandidatesMessage(StringUtil::TopNJaroWinkler(candidates, name), "Candidate calendars");
+
+	throw NotImplementedException("Unknown Calendar '%s'!\n%s", name, candidate_str);
 }
 
 static void LoadInternal(DuckDB &ddb) {

package/src/duckdb/extension/icu/include/icu-datefunc.hpp

@@ -62,7 +62,7 @@ struct ICUDateFunc {
 	//! Extracts the field from the calendar
 	static int32_t ExtractField(icu::Calendar *calendar, UCalendarDateFields field);
 	//! Subtracts the field of the given date from the calendar
-	static int64_t SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date);
+	static int32_t SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date);
 	//! Adds the timestamp and the interval using the calendar
 	static timestamp_t Add(icu::Calendar *calendar, timestamp_t timestamp, interval_t interval);
 	//! Subtracts the interval from the timestamp using the calendar
@@ -77,6 +77,7 @@ struct ICUDateFunc {
 	//! Truncates the calendar time to the given part precision
 	typedef void (*part_trunc_t)(icu::Calendar *calendar, uint64_t &micros);
 	static part_trunc_t TruncationFactory(DatePartSpecifier part);
+	static timestamp_t CurrentMidnight(icu::Calendar *calendar, ExpressionState &state);
 
 	//! Subtracts the two times at the given part precision
 	typedef int64_t (*part_sub_t)(icu::Calendar *calendar, timestamp_t start_date, timestamp_t end_date);

package/src/duckdb/extension/icu/third_party/icu/common/bytestriebuilder.cpp

@@ -343,7 +343,7 @@ BytesTrieBuilder::BTLinearMatchNode::BTLinearMatchNode(const char *bytes, int32_
         static_cast<uint32_t>(hash)*37u + static_cast<uint32_t>(ustr_hashCharsN(bytes, len)));
 }
 
-UBool
+bool
 BytesTrieBuilder::BTLinearMatchNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/dtintrv.cpp

@@ -53,7 +53,7 @@ DateInterval::clone() const {
 }
 
 
-UBool 
+bool
 DateInterval::operator==(const DateInterval& other) const { 
     return ( fromDate == other.fromDate && toDate == other.toDate );
 }

package/src/duckdb/extension/icu/third_party/icu/common/filteredbrk.cpp

@@ -175,7 +175,7 @@
 //   }
 //   virtual SimpleFilteredSentenceBreakIterator* clone() const { return new SimpleFilteredSentenceBreakIterator(*this); }
 //   virtual UClassID getDynamicClassID(void) const { return NULL; }
-//   virtual UBool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; }
+//   virtual bool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; }
 
 //   /* -- text modifying -- */
 //   virtual void setText(UText *text, UErrorCode &status) { fDelegate->setText(text,status); }

package/src/duckdb/extension/icu/third_party/icu/common/locid.cpp

@@ -482,7 +482,7 @@ Locale::clone() const {
     return new Locale(*this);
 }
 
-UBool
+bool
 Locale::operator==( const   Locale& other) const
 {
     return (uprv_strcmp(other.fullName, fullName) == 0);

package/src/duckdb/extension/icu/third_party/icu/common/lsr.cpp

@@ -60,7 +60,7 @@ LSR &LSR::operator=(LSR &&other) U_NOEXCEPT {
     return *this;
 }
 
-UBool LSR::operator==(const LSR &other) const {
+bool LSR::operator==(const LSR &other) const {
     return
         uprv_strcmp(language, other.language) == 0 &&
         uprv_strcmp(script, other.script) == 0 &&

package/src/duckdb/extension/icu/third_party/icu/common/lsr.h

@@ -55,9 +55,9 @@ struct LSR final : public UMemory {
      */
     static int32_t indexForRegion(const char *region);
 
-    UBool operator==(const LSR &other) const;
+    bool operator==(const LSR &other) const;
 
-    inline UBool operator!=(const LSR &other) const {
+    inline bool operator!=(const LSR &other) const {
         return !operator==(other);
     }
 

package/src/duckdb/extension/icu/third_party/icu/common/messagepattern.cpp

@@ -309,7 +309,7 @@ MessagePattern::clear() {
     numericValuesLength=0;
 }
 
-UBool
+bool
 MessagePattern::operator==(const MessagePattern &other) const {
     if(this==&other) {
         return TRUE;
@@ -387,7 +387,7 @@ MessagePattern::getPluralOffset(int32_t pluralStart) const {
 
 // MessagePattern::Part ---------------------------------------------------- ***
 
-UBool
+bool
 MessagePattern::Part::operator==(const Part &other) const {
     if(this==&other) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/normlzr.cpp

@@ -108,7 +108,7 @@ int32_t Normalizer::hashCode() const
     return text->hashCode() + fUMode + fOptions + buffer.hashCode() + bufferPos + currentIndex + nextIndex;
 }
     
-UBool Normalizer::operator==(const Normalizer& that) const
+bool Normalizer::operator==(const Normalizer& that) const
 {
     return
         this==&that ||

package/src/duckdb/extension/icu/third_party/icu/common/rbbinode.h

@@ -108,7 +108,7 @@ class RBBINode : public UMemory {
 
     private:
         RBBINode &operator = (const RBBINode &other); // No defs.
-        UBool operator == (const RBBINode &other);    // Private, so these functions won't accidently be used.
+        bool operator == (const RBBINode &other);    // Private, so these functions won't accidently be used.
 
 #ifdef RBBI_DEBUG
     public:

package/src/duckdb/extension/icu/third_party/icu/common/schriter.cpp

@@ -79,7 +79,7 @@ StringCharacterIterator::operator=(const StringCharacterIterator& that) {
     return *this;
 }
 
-UBool
+bool
 StringCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
     if (this == &that) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/stringtriebuilder.cpp

@@ -383,7 +383,7 @@ StringTrieBuilder::equalNodes(const void *left, const void *right) {
     return *(const Node *)left==*(const Node *)right;
 }
 
-UBool
+bool
 StringTrieBuilder::Node::operator==(const Node &other) const {
     return this==&other || (typeid(*this)==typeid(other) && hash==other.hash);
 }
@@ -396,7 +396,7 @@ StringTrieBuilder::Node::markRightEdgesFirst(int32_t edgeNumber) {
     return edgeNumber;
 }
 
-UBool
+bool
 StringTrieBuilder::FinalValueNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -413,7 +413,7 @@ StringTrieBuilder::FinalValueNode::write(StringTrieBuilder &builder) {
     offset=builder.writeValueAndFinal(value, TRUE);
 }
 
-UBool
+bool
 StringTrieBuilder::ValueNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -425,7 +425,7 @@ StringTrieBuilder::ValueNode::operator==(const Node &other) const {
     return hasValue==o.hasValue && (!hasValue || value==o.value);
 }
 
-UBool
+bool
 StringTrieBuilder::IntermediateValueNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -451,7 +451,7 @@ StringTrieBuilder::IntermediateValueNode::write(StringTrieBuilder &builder) {
     offset=builder.writeValueAndFinal(value, FALSE);
 }
 
-UBool
+bool
 StringTrieBuilder::LinearMatchNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -471,7 +471,7 @@ StringTrieBuilder::LinearMatchNode::markRightEdgesFirst(int32_t edgeNumber) {
     return edgeNumber;
 }
 
-UBool
+bool
 StringTrieBuilder::ListBranchNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -550,7 +550,7 @@ StringTrieBuilder::ListBranchNode::write(StringTrieBuilder &builder) {
     }
 }
 
-UBool
+bool
 StringTrieBuilder::SplitBranchNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;
@@ -584,7 +584,7 @@ StringTrieBuilder::SplitBranchNode::write(StringTrieBuilder &builder) {
     offset=builder.write(unit);
 }
 
-UBool
+bool
 StringTrieBuilder::BranchHeadNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/ucharstriebuilder.cpp

@@ -290,7 +290,7 @@ UCharsTrieBuilder::UCTLinearMatchNode::UCTLinearMatchNode(const UChar *units, in
     hash=hash*37u+ustr_hashUCharsN(units, len);
 }
 
-UBool
+bool
 UCharsTrieBuilder::UCTLinearMatchNode::operator==(const Node &other) const {
     if(this==&other) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/uchriter.cpp

@@ -66,7 +66,7 @@ UCharCharacterIterator::operator=(const UCharCharacterIterator& that) {
 UCharCharacterIterator::~UCharCharacterIterator() {
 }
 
-UBool
+bool
 UCharCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
     if (this == &that) {
         return TRUE;

package/src/duckdb/extension/icu/third_party/icu/common/unicode/brkiter.h

@@ -123,7 +123,7 @@
 //      * object, and styles are not considered.
 //      * @stable ICU 2.0
 //      */
-//     virtual UBool operator==(const BreakIterator&) const = 0;
+//     virtual bool operator==(const BreakIterator&) const = 0;
 
 //     /**
 //      * Returns the complement of the result of operator==
@@ -131,7 +131,7 @@
 //      * @return the complement of the result of operator==
 //      * @stable ICU 2.0
 //      */
-//     UBool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); }
+//     bool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); }
 
 //     /**
 //      * Return a polymorphic copy of this object.  This is an abstract

package/src/duckdb/extension/icu/third_party/icu/common/unicode/bytestriebuilder.h

@@ -151,7 +151,7 @@ private:
     class BTLinearMatchNode : public LinearMatchNode {
     public:
         BTLinearMatchNode(const char *units, int32_t len, Node *nextNode);
-        virtual UBool operator==(const Node &other) const;
+        virtual bool operator==(const Node &other) const;
         virtual void write(StringTrieBuilder &builder);
     private:
         const char *s;

package/src/duckdb/extension/icu/third_party/icu/common/unicode/chariter.h

@@ -114,7 +114,7 @@ public:
      * character in the same character-storage object
      * @stable ICU 2.0
      */
-    virtual UBool operator==(const ForwardCharacterIterator& that) const = 0;
+    virtual bool operator==(const ForwardCharacterIterator& that) const = 0;
     
     /**
      * Returns true when the iterators refer to different
@@ -126,7 +126,7 @@ public:
      * same text-storage object
      * @stable ICU 2.0
      */
-    inline UBool operator!=(const ForwardCharacterIterator& that) const;
+    inline bool operator!=(const ForwardCharacterIterator& that) const;
     
     /**
      * Generates a hash code for this iterator.  
@@ -692,7 +692,7 @@ protected:
     int32_t  end;
 };
 
-inline UBool
+inline bool
 ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
     return !operator==(that);
 }

package/src/duckdb/extension/icu/third_party/icu/common/unicode/dtintrv.h

@@ -109,14 +109,14 @@ public:
      * @return TRUE if the two DateIntervals are the same
      * @stable ICU 4.0
      */
-    virtual UBool operator==(const DateInterval& other) const;
+    virtual bool operator==(const DateInterval& other) const;
 
     /**
      * Non-equality operator
      * @return TRUE if the two DateIntervals are not the same
      * @stable ICU 4.0
      */
-    inline UBool operator!=(const DateInterval& other) const;
+    inline bool operator!=(const DateInterval& other) const;
 
 
     /**
@@ -151,7 +151,7 @@ DateInterval::getToDate() const {
 }
 
 
-inline UBool 
+inline bool
 DateInterval::operator!=(const DateInterval& other) const { 
     return ( !operator==(other) );
 }