duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/function/scalar/list/list_select.cpp

@@ -0,0 +1,176 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_parameter_expression.hpp"
+
+namespace duckdb {
+
+struct SetSelectionVectorSelect {
+	static void SetSelectionVector(SelectionVector &selection_vector, ValidityMask &validity_mask,
+	                               ValidityMask &input_validity, Vector &selection_entry, idx_t child_idx,
+	                               idx_t &target_offset, idx_t selection_offset, idx_t input_offset,
+	                               idx_t target_length) {
+		idx_t sel_idx = selection_entry.GetValue(selection_offset + child_idx).GetValue<int64_t>() - 1;
+		if (sel_idx < target_length) {
+			selection_vector.set_index(target_offset, input_offset + sel_idx);
+			if (!input_validity.RowIsValid(input_offset + sel_idx)) {
+				validity_mask.SetInvalid(target_offset);
+			}
+		} else {
+			selection_vector.set_index(target_offset, 0);
+			validity_mask.SetInvalid(target_offset);
+		}
+		target_offset++;
+	}
+
+	static void GetResultLength(DataChunk &args, idx_t &result_length, const list_entry_t *selection_data,
+	                            Vector selection_entry, idx_t selection_idx) {
+		result_length += selection_data[selection_idx].length;
+	}
+};
+
+struct SetSelectionVectorWhere {
+	static void SetSelectionVector(SelectionVector &selection_vector, ValidityMask &validity_mask,
+	                               ValidityMask &input_validity, Vector &selection_entry, idx_t child_idx,
+	                               idx_t &target_offset, idx_t selection_offset, idx_t input_offset,
+	                               idx_t target_length) {
+		if (!selection_entry.GetValue(selection_offset + child_idx).GetValue<bool>()) {
+			return;
+		}
+
+		selection_vector.set_index(target_offset, input_offset + child_idx);
+		if (!input_validity.RowIsValid(input_offset + child_idx)) {
+			validity_mask.SetInvalid(target_offset);
+		}
+		target_offset++;
+	}
+
+	static void GetResultLength(DataChunk &args, idx_t &result_length, const list_entry_t *selection_data,
+	                            Vector selection_entry, idx_t selection_idx) {
+		for (idx_t child_idx = 0; child_idx < selection_data[selection_idx].length; child_idx++) {
+			if (selection_entry.GetValue(selection_data[selection_idx].offset + child_idx).IsNull()) {
+				throw InvalidInputException("NULLs are not allowed as list elements in the second input parameter.");
+			}
+			if (selection_entry.GetValue(selection_data[selection_idx].offset + child_idx).GetValue<bool>()) {
+				result_length++;
+			}
+		}
+	}
+};
+
+template <class OP>
+static void ListSelectFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.data.size() == 2);
+	Vector &list = args.data[0];
+	Vector &selection_list = args.data[1];
+	idx_t count = args.size();
+
+	list_entry_t *result_data;
+	result_data = FlatVector::GetData<list_entry_t>(result);
+	auto &result_entry = ListVector::GetEntry(result);
+
+	UnifiedVectorFormat selection_lists;
+	selection_list.ToUnifiedFormat(count, selection_lists);
+	auto selection_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(selection_lists);
+	auto &selection_entry = ListVector::GetEntry(selection_list);
+
+	UnifiedVectorFormat input_list;
+	list.ToUnifiedFormat(count, input_list);
+	auto input_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(input_list);
+	auto &input_entry = ListVector::GetEntry(list);
+	auto &input_validity = FlatVector::Validity(input_entry);
+
+	idx_t result_length = 0;
+	for (idx_t i = 0; i < count; i++) {
+		idx_t input_idx = input_list.sel->get_index(i);
+		idx_t selection_idx = selection_lists.sel->get_index(i);
+		if (input_list.validity.RowIsValid(input_idx) && selection_lists.validity.RowIsValid(selection_idx)) {
+			OP::GetResultLength(args, result_length, selection_lists_data, selection_entry, selection_idx);
+		}
+	}
+
+	ListVector::Reserve(result, result_length);
+	SelectionVector result_selection_vec = SelectionVector(result_length);
+	ValidityMask entry_validity_mask = ValidityMask(result_length);
+	ValidityMask &result_validity_mask = FlatVector::Validity(result);
+
+	idx_t offset = 0;
+	for (idx_t j = 0; j < count; j++) {
+		// Get length and offset of selection list for current output row
+		auto selection_list_idx = selection_lists.sel->get_index(j);
+		idx_t selection_len = 0;
+		idx_t selection_offset = 0;
+		if (selection_lists.validity.RowIsValid(selection_list_idx)) {
+			selection_len = selection_lists_data[selection_list_idx].length;
+			selection_offset = selection_lists_data[selection_list_idx].offset;
+		} else {
+			result_validity_mask.SetInvalid(j);
+			continue;
+		}
+		// Get length and offset of input list for current output row
+		auto input_list_idx = input_list.sel->get_index(j);
+		idx_t input_length = 0;
+		idx_t input_offset = 0;
+		if (input_list.validity.RowIsValid(input_list_idx)) {
+			input_length = input_lists_data[input_list_idx].length;
+			input_offset = input_lists_data[input_list_idx].offset;
+		} else {
+			result_validity_mask.SetInvalid(j);
+			continue;
+		}
+		result_data[j].offset = offset;
+		// Set all selected values in the result
+		for (idx_t child_idx = 0; child_idx < selection_len; child_idx++) {
+			if (selection_entry.GetValue(selection_offset + child_idx).IsNull()) {
+				throw InvalidInputException("NULLs are not allowed as list elements in the second input parameter.");
+			}
+			OP::SetSelectionVector(result_selection_vec, entry_validity_mask, input_validity, selection_entry,
+			                       child_idx, offset, selection_offset, input_offset, input_length);
+		}
+		result_data[j].length = offset - result_data[j].offset;
+	}
+	result_entry.Slice(input_entry, result_selection_vec, count);
+	result_entry.Flatten(offset);
+	ListVector::SetListSize(result, offset);
+	FlatVector::SetValidity(result_entry, entry_validity_mask);
+	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
+}
+
+static unique_ptr<FunctionData> ListSelectBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2);
+	LogicalType child_type;
+	if (arguments[0]->return_type == LogicalTypeId::UNKNOWN || arguments[1]->return_type == LogicalTypeId::UNKNOWN) {
+		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id() ||
+	         LogicalTypeId::SQLNULL == arguments[0]->return_type.id());
+	D_ASSERT(LogicalTypeId::LIST == arguments[1]->return_type.id() ||
+	         LogicalTypeId::SQLNULL == arguments[1]->return_type.id());
+
+	bound_function.return_type = arguments[0]->return_type;
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+ScalarFunction ListWhereFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::LIST(LogicalTypeId::ANY), LogicalType::LIST(LogicalType::BOOLEAN)},
+	                          LogicalType::LIST(LogicalTypeId::ANY), ListSelectFunction<SetSelectionVectorWhere>,
+	                          ListSelectBind);
+	return fun;
+}
+
+ScalarFunction ListSelectFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::LIST(LogicalTypeId::ANY), LogicalType::LIST(LogicalType::BIGINT)},
+	                          LogicalType::LIST(LogicalTypeId::ANY), ListSelectFunction<SetSelectionVectorSelect>,
+	                          ListSelectBind);
+	return fun;
+}
+
+void ListSelectFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_select", "array_select"}, ListSelectFun::GetFunction());
+	set.AddFunction({"list_where", "array_where"}, ListWhereFun::GetFunction());
+}
+} // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_zip.cpp

@@ -0,0 +1,165 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_parameter_expression.hpp"
+#include "duckdb/common/to_string.hpp"
+
+namespace duckdb {
+
+static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	idx_t count = args.size();
+	idx_t args_size = args.ColumnCount();
+	auto *result_data = FlatVector::GetData<list_entry_t>(result);
+	auto &result_struct = ListVector::GetEntry(result);
+	auto &struct_entries = StructVector::GetEntries(result_struct);
+	bool truncate_flags_set = false;
+
+	// Check flag
+	if (args.data.back().GetType().id() == LogicalTypeId::BOOLEAN) {
+		truncate_flags_set = true;
+		args_size--;
+	}
+
+	vector<UnifiedVectorFormat> input_lists;
+	for (idx_t i = 0; i < args.ColumnCount(); i++) {
+		UnifiedVectorFormat curr;
+		args.data[i].ToUnifiedFormat(count, curr);
+		input_lists.push_back(curr);
+	}
+
+	// Handling output row for each input row
+	idx_t result_size = 0;
+	vector<idx_t> lengths;
+	for (idx_t j = 0; j < count; j++) {
+
+		// Is flag for current row set
+		bool truncate_to_shortest = false;
+		if (truncate_flags_set) {
+			idx_t flag_idx = input_lists.back().sel->get_index(j);
+			auto flag_data = UnifiedVectorFormat::GetData<bool>(input_lists.back());
+			truncate_to_shortest = flag_data[flag_idx];
+		}
+
+		// Calculation of the outgoing list size
+		idx_t len = truncate_to_shortest ? NumericLimits<int>::Maximum() : 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			idx_t curr_size;
+			if (args.data[i].GetType() == LogicalType::SQLNULL || ListVector::GetListSize(args.data[i]) == 0) {
+				curr_size = 0;
+			} else {
+				idx_t sel_idx = input_lists[i].sel->get_index(j);
+				auto curr_data = UnifiedVectorFormat::GetData<list_entry_t>(input_lists[i]);
+				curr_size = input_lists[i].validity.RowIsValid(sel_idx) ? curr_data[sel_idx].length : 0;
+			}
+
+			// Dependent on flag using gt or lt
+			if (truncate_to_shortest) {
+				len = len > curr_size ? curr_size : len;
+			} else {
+				len = len < curr_size ? curr_size : len;
+			}
+		}
+		lengths.push_back(len);
+		result_size += len;
+	}
+
+	ListVector::SetListSize(result, result_size);
+	ListVector::Reserve(result, result_size);
+	vector<SelectionVector> selections;
+	vector<ValidityMask> masks;
+	for (idx_t i = 0; i < args_size; i++) {
+		selections.push_back(SelectionVector(result_size));
+		masks.push_back(ValidityMask(result_size));
+	}
+
+	idx_t offset = 0;
+	for (idx_t j = 0; j < count; j++) {
+		idx_t len = lengths[j];
+		for (idx_t i = 0; i < args_size; i++) {
+			UnifiedVectorFormat curr = input_lists[i];
+			idx_t sel_idx = curr.sel->get_index(j);
+			idx_t curr_off = 0;
+			idx_t curr_len = 0;
+
+			// Copying values from the given lists
+			if (curr.validity.RowIsValid(sel_idx)) {
+				auto input_lists_data = UnifiedVectorFormat::GetData<list_entry_t>(curr);
+				curr_off = input_lists_data[sel_idx].offset;
+				curr_len = input_lists_data[sel_idx].length;
+				auto copy_len = len < curr_len ? len : curr_len;
+				idx_t entry = offset;
+				for (idx_t k = 0; k < copy_len; k++) {
+					if (!FlatVector::Validity(ListVector::GetEntry(args.data[i])).RowIsValid(curr_off + k)) {
+						masks[i].SetInvalid(entry + k);
+					}
+					selections[i].set_index(entry + k, curr_off + k);
+				}
+			}
+
+			// Set NULL values for list that are shorter than the output list
+			if (len > curr_len) {
+				for (idx_t d = curr_len; d < len; d++) {
+					masks[i].SetInvalid(d + offset);
+					selections[i].set_index(d + offset, 0);
+				}
+			}
+		}
+		result_data[j].length = len;
+		result_data[j].offset = offset;
+		offset += len;
+	}
+	for (idx_t child_idx = 0; child_idx < args_size; child_idx++) {
+		if (!(args.data[child_idx].GetType() == LogicalType::SQLNULL)) {
+			struct_entries[child_idx]->Slice(ListVector::GetEntry(args.data[child_idx]), selections[child_idx],
+			                                 result_size);
+		}
+		struct_entries[child_idx]->Flatten(result_size);
+		FlatVector::SetValidity((*struct_entries[child_idx]), masks[child_idx]);
+	}
+	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
+}
+
+static unique_ptr<FunctionData> ListZipBind(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
+	child_list_t<LogicalType> struct_children;
+
+	// The last argument could be a flag to be set if we want a minimal list or a maximal list
+	idx_t size = arguments.size();
+	if (size == 0) {
+		throw BinderException("Provide at least one argument to " + bound_function.name);
+	}
+	if (arguments[size - 1]->return_type.id() == LogicalTypeId::BOOLEAN) {
+		size--;
+	}
+
+	case_insensitive_set_t struct_names;
+	for (idx_t i = 0; i < size; i++) {
+		auto &child = arguments[i];
+		switch (child->return_type.id()) {
+		case LogicalTypeId::LIST:
+			struct_children.push_back(make_pair(string(), ListType::GetChildType(child->return_type)));
+			break;
+		case LogicalTypeId::SQLNULL:
+			struct_children.push_back(make_pair(string(), LogicalTypeId::SQLNULL));
+			break;
+		default:
+			throw ParameterNotResolvedException();
+		}
+	}
+	bound_function.return_type = LogicalType::LIST(LogicalType::STRUCT(struct_children));
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+
+ScalarFunction ListZipFun::GetFunction() {
+
+	auto fun = ScalarFunction({}, LogicalType::LIST(LogicalTypeId::STRUCT), ListZipFunction, ListZipBind);
+	fun.varargs = LogicalType::ANY;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; // Special handling needed?
+	return fun;
+}
+
+void ListZipFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_zip", "array_zip"}, GetFunction());
+}
+} // namespace duckdb

package/src/duckdb/src/function/scalar/nested_functions.cpp

@@ -2,6 +2,37 @@
 
 namespace duckdb {
 
+void MapUtil::ReinterpretMap(Vector &result, Vector &input, idx_t count) {
+	UnifiedVectorFormat input_data;
+	input.ToUnifiedFormat(count, input_data);
+	// Copy the list validity
+	FlatVector::SetValidity(result, input_data.validity);
+
+	// Copy the struct validity
+	UnifiedVectorFormat input_struct_data;
+	ListVector::GetEntry(input).ToUnifiedFormat(count, input_struct_data);
+	auto &result_struct = ListVector::GetEntry(result);
+	FlatVector::SetValidity(result_struct, input_struct_data.validity);
+
+	// Set the right vector type
+	result.SetVectorType(input.GetVectorType());
+
+	// Copy the list size
+	auto list_size = ListVector::GetListSize(input);
+	ListVector::SetListSize(result, list_size);
+
+	// Copy the list buffer (the list_entry_t data)
+	result.CopyBuffer(input);
+
+	auto &input_keys = MapVector::GetKeys(input);
+	auto &result_keys = MapVector::GetKeys(result);
+	result_keys.Reference(input_keys);
+
+	auto &input_values = MapVector::GetValues(input);
+	auto &result_values = MapVector::GetValues(result);
+	result_values.Reference(input_values);
+}
+
 void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<StructExtractFun>();
 	Register<ListConcatFun>();
@@ -9,6 +40,8 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListPositionFun>();
 	Register<ListExtractFun>();
 	Register<ListResizeFun>();
+	Register<ListZipFun>();
+	Register<ListSelectFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operators/add.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 
 namespace duckdb {
 
@@ -68,19 +69,43 @@ timestamp_t AddOperator::Operation(date_t left, dtime_t right) {
 	return result;
 }
 
+template <>
+timestamp_t AddOperator::Operation(date_t left, dtime_tz_t right) {
+	if (left == date_t::infinity()) {
+		return timestamp_t::infinity();
+	} else if (left == date_t::ninfinity()) {
+		return timestamp_t::ninfinity();
+	}
+	timestamp_t result;
+	if (!Timestamp::TryFromDatetime(left, right, result)) {
+		throw OutOfRangeException("Timestamp with time zone out of range");
+	}
+	return result;
+}
+
 template <>
 timestamp_t AddOperator::Operation(dtime_t left, date_t right) {
 	return AddOperator::Operation<date_t, dtime_t, timestamp_t>(right, left);
 }
 
 template <>
-date_t AddOperator::Operation(date_t left, interval_t right) {
-	return Interval::Add(left, right);
+timestamp_t AddOperator::Operation(dtime_tz_t left, date_t right) {
+	return AddOperator::Operation<date_t, dtime_tz_t, timestamp_t>(right, left);
 }
 
 template <>
-date_t AddOperator::Operation(interval_t left, date_t right) {
-	return AddOperator::Operation<date_t, interval_t, date_t>(right, left);
+timestamp_t AddOperator::Operation(date_t left, interval_t right) {
+	if (left == date_t::infinity()) {
+		return timestamp_t::infinity();
+	} else if (left == date_t::ninfinity()) {
+		return timestamp_t::ninfinity();
+	}
+	return Interval::Add(Timestamp::FromDatetime(left, dtime_t(0)), right);
+}
+
+template <>
+timestamp_t AddOperator::Operation(interval_t left, date_t right) {
+	return AddOperator::Operation<date_t, interval_t, timestamp_t>(right, left);
 }
 
 template <>
@@ -160,9 +185,18 @@ bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result) {
 	return true;
 }
 
+template <>
+bool TryAddOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result) {
+	if (!Uhugeint::TryAddInPlace(left, right)) {
+		return false;
+	}
+	result = left;
+	return true;
+}
+
 template <>
 bool TryAddOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	if (!Hugeint::AddInPlace(left, right)) {
+	if (!Hugeint::TryAddInPlace(left, right)) {
 		return false;
 	}
 	result = left;
@@ -204,7 +238,9 @@ bool TryDecimalAdd::Operation(int64_t left, int64_t right, int64_t &result) {
 
 template <>
 bool TryDecimalAdd::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left + right;
+	if (!TryAddOperator::Operation(left, right, result)) {
+		return false;
+	}
 	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
 		return false;
 	}
@@ -234,4 +270,15 @@ dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right) {
 	return AddTimeOperator::Operation<dtime_t, interval_t, dtime_t>(right, left);
 }
 
+template <>
+dtime_tz_t AddTimeOperator::Operation(dtime_tz_t left, interval_t right) {
+	date_t date(0);
+	return Interval::Add(left, right, date);
+}
+
+template <>
+dtime_tz_t AddTimeOperator::Operation(interval_t left, dtime_tz_t right) {
+	return AddTimeOperator::Operation<dtime_tz_t, interval_t, dtime_tz_t>(right, left);
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -49,8 +49,11 @@ static scalar_function_t GetScalarIntegerFunction(PhysicalType type) {
 	case PhysicalType::UINT64:
 		function = &ScalarFunction::BinaryFunction<uint64_t, uint64_t, uint64_t, OP>;
 		break;
+	case PhysicalType::UINT128:
+		function = &ScalarFunction::BinaryFunction<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
+		break;
 	default:
-		throw NotImplementedException("Unimplemented type for GetScalarBinaryFunction");
+		throw NotImplementedException("Unimplemented type for GetScalarBinaryFunction: %s", TypeIdToString(type));
 	}
 	return function;
 }
@@ -59,9 +62,6 @@ template <class OP>
 static scalar_function_t GetScalarBinaryFunction(PhysicalType type) {
 	scalar_function_t function;
 	switch (type) {
-	case PhysicalType::INT128:
-		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
-		break;
 	case PhysicalType::FLOAT:
 		function = &ScalarFunction::BinaryFunction<float, float, float, OP>;
 		break;
@@ -238,7 +238,7 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 	} else {
 		bound_function.function = GetScalarBinaryFunction<OP>(result_type.InternalType());
 	}
-	if (result_type.InternalType() != PhysicalType::INT128) {
+	if (result_type.InternalType() != PhysicalType::INT128 && result_type.InternalType() != PhysicalType::UINT128) {
 		if (IS_SUBTRACT) {
 			bound_function.statistics =
 			    PropagateNumericStats<TryDecimalSubtract, SubtractPropagateStatistics, SubtractOperator>;
@@ -319,11 +319,14 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
 			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, AddOperator>);
 		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, interval_t, date_t, AddOperator>);
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
+			                      ScalarFunction::BinaryFunction<date_t, interval_t, timestamp_t, AddOperator>);
 		} else if (right_type.id() == LogicalTypeId::TIME) {
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
 			                      ScalarFunction::BinaryFunction<date_t, dtime_t, timestamp_t, AddOperator>);
+		} else if (right_type.id() == LogicalTypeId::TIME_TZ) {
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ,
+			                      ScalarFunction::BinaryFunction<date_t, dtime_tz_t, timestamp_t, AddOperator>);
 		}
 		break;
 	case LogicalTypeId::INTEGER:
@@ -337,11 +340,14 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::INTERVAL,
 			                      ScalarFunction::BinaryFunction<interval_t, interval_t, interval_t, AddOperator>);
 		} else if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<interval_t, date_t, date_t, AddOperator>);
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
+			                      ScalarFunction::BinaryFunction<interval_t, date_t, timestamp_t, AddOperator>);
 		} else if (right_type.id() == LogicalTypeId::TIME) {
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME,
 			                      ScalarFunction::BinaryFunction<interval_t, dtime_t, dtime_t, AddTimeOperator>);
+		} else if (right_type.id() == LogicalTypeId::TIME_TZ) {
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME_TZ,
+			                      ScalarFunction::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t, AddTimeOperator>);
 		} else if (right_type.id() == LogicalTypeId::TIMESTAMP) {
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
 			                      ScalarFunction::BinaryFunction<interval_t, timestamp_t, timestamp_t, AddOperator>);
@@ -356,6 +362,15 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			                      ScalarFunction::BinaryFunction<dtime_t, date_t, timestamp_t, AddOperator>);
 		}
 		break;
+	case LogicalTypeId::TIME_TZ:
+		if (right_type.id() == LogicalTypeId::DATE) {
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ,
+			                      ScalarFunction::BinaryFunction<dtime_tz_t, date_t, timestamp_t, AddOperator>);
+		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
+			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME_TZ,
+			                      ScalarFunction::BinaryFunction<dtime_tz_t, interval_t, dtime_tz_t, AddTimeOperator>);
+		}
+		break;
 	case LogicalTypeId::TIMESTAMP:
 		if (right_type.id() == LogicalTypeId::INTERVAL) {
 			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
@@ -394,10 +409,17 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
 	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::TIMESTAMP));
 
+	functions.AddFunction(GetFunction(LogicalType::TIME_TZ, LogicalType::INTERVAL));
+	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::TIME_TZ));
+
 	// we can add times to dates
 	functions.AddFunction(GetFunction(LogicalType::TIME, LogicalType::DATE));
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::TIME));
 
+	// we can add times with time zones (offsets) to dates
+	functions.AddFunction(GetFunction(LogicalType::TIME_TZ, LogicalType::DATE));
+	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::TIME_TZ));
+
 	// we can add lists together
 	functions.AddFunction(ListConcatFun::GetFunction());
 
@@ -587,8 +609,8 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 			return ScalarFunction("-", {left_type, right_type}, LogicalType::DATE,
 			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, SubtractOperator>);
 		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, interval_t, date_t, SubtractOperator>);
+			return ScalarFunction("-", {left_type, right_type}, LogicalType::TIMESTAMP,
+			                      ScalarFunction::BinaryFunction<date_t, interval_t, timestamp_t, SubtractOperator>);
 		}
 		break;
 	case LogicalTypeId::TIMESTAMP:
@@ -614,6 +636,13 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 			                      ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, SubtractTimeOperator>);
 		}
 		break;
+	case LogicalTypeId::TIME_TZ:
+		if (right_type.id() == LogicalTypeId::INTERVAL) {
+			return ScalarFunction(
+			    "-", {left_type, right_type}, LogicalType::TIME_TZ,
+			    ScalarFunction::BinaryFunction<dtime_tz_t, interval_t, dtime_tz_t, SubtractTimeOperator>);
+		}
+		break;
 	default:
 		break;
 	}
@@ -643,6 +672,7 @@ void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTERVAL));
 	functions.AddFunction(GetFunction(LogicalType::TIME, LogicalType::INTERVAL));
 	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
+	functions.AddFunction(GetFunction(LogicalType::TIME_TZ, LogicalType::INTERVAL));
 	// we can negate intervals
 	functions.AddFunction(GetFunction(LogicalType::INTERVAL));
 	set.AddFunction(functions);
@@ -856,10 +886,12 @@ struct BinaryZeroIsNullWrapper {
 	}
 };
 
-struct BinaryZeroIsNullHugeintWrapper {
+struct BinaryNumericDivideHugeintWrapper {
 	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
 	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (right.upper == 0 && right.lower == 0) {
+		if (left == NumericLimits<LEFT_TYPE>::Minimum() && right == -1) {
+			throw OutOfRangeException("Overflow in division of %s / %s", left.ToString(), right.ToString());
+		} else if (right == 0) {
 			mask.SetInvalid(idx);
 			return left;
 		} else {
@@ -897,7 +929,9 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 	case LogicalTypeId::UBIGINT:
 		return BinaryScalarFunctionIgnoreZero<uint64_t, uint64_t, uint64_t, OP>;
 	case LogicalTypeId::HUGEINT:
-		return BinaryScalarFunctionIgnoreZero<hugeint_t, hugeint_t, hugeint_t, OP, BinaryZeroIsNullHugeintWrapper>;
+		return BinaryScalarFunctionIgnoreZero<hugeint_t, hugeint_t, hugeint_t, OP, BinaryNumericDivideHugeintWrapper>;
+	case LogicalTypeId::UHUGEINT:
+		return BinaryScalarFunctionIgnoreZero<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
 	case LogicalTypeId::FLOAT:
 		return BinaryScalarFunctionIgnoreZero<float, float, float, OP>;
 	case LogicalTypeId::DOUBLE:

package/src/duckdb/src/function/scalar/operators/multiply.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 
@@ -183,6 +184,11 @@ bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &
 	return Hugeint::TryMultiply(left, right, result);
 }
 
+template <>
+bool TryMultiplyOperator::Operation(uhugeint_t left, uhugeint_t right, uhugeint_t &result) {
+	return Uhugeint::TryMultiply(left, right, result);
+}
+
 //===--------------------------------------------------------------------===//
 // multiply  decimal with overflow check
 //===--------------------------------------------------------------------===//
@@ -211,7 +217,9 @@ bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result)
 
 template <>
 bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left * right;
+	if (!TryMultiplyOperator::Operation(left, right, result)) {
+		return false;
+	}
 	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
 		return false;
 	}