duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/core_functions/scalar/list/list_reduce.cpp

@@ -0,0 +1,230 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
+#include "duckdb/core_functions/lambda_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+
+namespace duckdb {
+
+struct ReduceExecuteInfo {
+	ReduceExecuteInfo(LambdaFunctions::LambdaInfo &info, ClientContext &context) : left_slice(*info.child_vector) {
+		SelectionVector left_vector(info.row_count);
+		active_rows.Resize(0, info.row_count);
+		active_rows.SetAllValid(info.row_count);
+
+		right_sel.Initialize(info.row_count);
+		left_sel.Initialize(info.row_count);
+		active_rows_sel.Initialize(info.row_count);
+
+		idx_t reduced_row_idx = 0;
+
+		for (idx_t original_row_idx = 0; original_row_idx < info.row_count; original_row_idx++) {
+			auto list_column_format_index = info.list_column_format.sel->get_index(original_row_idx);
+			if (info.list_column_format.validity.RowIsValid(list_column_format_index)) {
+				if (info.list_entries[list_column_format_index].length == 0) {
+					throw ParameterNotAllowedException("Cannot perform list_reduce on an empty input list");
+				}
+				left_vector.set_index(reduced_row_idx, info.list_entries[list_column_format_index].offset);
+				reduced_row_idx++;
+			} else {
+				// Remove the invalid rows
+				info.result_validity->SetInvalid(original_row_idx);
+				active_rows.SetInvalid(original_row_idx);
+			}
+		}
+
+		left_slice.Slice(left_vector, reduced_row_idx);
+
+		if (info.has_index) {
+			input_types.push_back(LogicalType::BIGINT);
+		}
+		input_types.push_back(left_slice.GetType());
+		input_types.push_back(left_slice.GetType());
+		for (auto &entry : info.column_infos) {
+			input_types.push_back(entry.vector.get().GetType());
+		}
+
+		expr_executor = make_uniq<ExpressionExecutor>(context, *info.lambda_expr);
+	};
+	ValidityMask active_rows;
+	Vector left_slice;
+	unique_ptr<ExpressionExecutor> expr_executor;
+	vector<LogicalType> input_types;
+
+	SelectionVector right_sel;
+	SelectionVector left_sel;
+	SelectionVector active_rows_sel;
+};
+
+static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFunctions::LambdaInfo &info,
+                          DataChunk &result_chunk) {
+	idx_t original_row_idx = 0;
+	idx_t reduced_row_idx = 0;
+	idx_t valid_row_idx = 0;
+
+	// create selection vectors for the left and right slice
+	auto data = execute_info.active_rows.GetData();
+
+	idx_t bits_per_entry = sizeof(idx_t) * 8;
+	for (idx_t entry_idx = 0; original_row_idx < info.row_count; entry_idx++) {
+		if (data[entry_idx] == 0) {
+			original_row_idx += bits_per_entry;
+			continue;
+		}
+
+		for (idx_t j = 0; entry_idx * bits_per_entry + j < info.row_count; j++) {
+			if (!execute_info.active_rows.RowIsValid(original_row_idx)) {
+				original_row_idx++;
+				continue;
+			}
+			auto list_column_format_index = info.list_column_format.sel->get_index(original_row_idx);
+			if (info.list_entries[list_column_format_index].length > loops + 1) {
+				execute_info.right_sel.set_index(reduced_row_idx,
+				                                 info.list_entries[list_column_format_index].offset + loops + 1);
+				execute_info.left_sel.set_index(reduced_row_idx, valid_row_idx);
+				execute_info.active_rows_sel.set_index(reduced_row_idx, original_row_idx);
+
+				reduced_row_idx++;
+			} else {
+				execute_info.active_rows.SetInvalid(original_row_idx);
+				info.result.SetValue(original_row_idx, execute_info.left_slice.GetValue(valid_row_idx));
+			}
+			original_row_idx++;
+			valid_row_idx++;
+		}
+	}
+
+	if (reduced_row_idx == 0) {
+		return true;
+	}
+
+	// create the index vector
+	Vector index_vector(Value::BIGINT(loops + 1));
+
+	// slice the left and right slice
+	execute_info.left_slice.Slice(execute_info.left_slice, execute_info.left_sel, reduced_row_idx);
+	Vector right_slice(*info.child_vector, execute_info.right_sel, reduced_row_idx);
+
+	// create the input chunk
+	DataChunk input_chunk;
+	input_chunk.InitializeEmpty(execute_info.input_types);
+	input_chunk.SetCardinality(reduced_row_idx);
+
+	idx_t slice_offset = info.has_index ? 1 : 0;
+	if (info.has_index) {
+		input_chunk.data[0].Reference(index_vector);
+	}
+	input_chunk.data[slice_offset + 1].Reference(execute_info.left_slice);
+	input_chunk.data[slice_offset].Reference(right_slice);
+
+	// add the other columns
+	vector<Vector> slices;
+	for (idx_t i = 0; i < info.column_infos.size(); i++) {
+		if (info.column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) {
+			// only reference constant vectors
+			input_chunk.data[slice_offset + 2 + i].Reference(info.column_infos[i].vector);
+		} else {
+			// slice the other vectors
+			slices.emplace_back(info.column_infos[i].vector, execute_info.active_rows_sel, reduced_row_idx);
+			input_chunk.data[slice_offset + 2 + i].Reference(slices.back());
+		}
+	}
+
+	result_chunk.Reset();
+	result_chunk.SetCardinality(reduced_row_idx);
+
+	execute_info.expr_executor->Execute(input_chunk, result_chunk);
+
+	// use the result chunk to update the left slice
+	execute_info.left_slice.Reference(result_chunk.data[0]);
+	return false;
+}
+
+void LambdaFunctions::ListReduceFunction(duckdb::DataChunk &args, duckdb::ExpressionState &state,
+                                         duckdb::Vector &result) {
+	// Initializes the left slice from the list entries, active rows, the expression executor and the input types
+	bool completed = false;
+	LambdaFunctions::LambdaInfo info(args, state, result, completed);
+	if (completed) {
+		return;
+	}
+
+	ReduceExecuteInfo execute_info(info, state.GetContext());
+
+	// Since the left slice references the result chunk, we need to create two result chunks.
+	// This means there is always an empty result chunk for the next iteration,
+	// without the referenced chunk having to be reset until the current iteration is complete.
+	DataChunk odd_result_chunk;
+	odd_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
+
+	DataChunk even_result_chunk;
+	even_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
+
+	idx_t loops = 0;
+	bool end = false;
+	// Execute reduce until all rows are finished
+	while (!end) {
+		auto &result_chunk = loops % 2 ? odd_result_chunk : even_result_chunk;
+		auto &spare_result_chunk = loops % 2 ? even_result_chunk : odd_result_chunk;
+
+		end = ExecuteReduce(loops, execute_info, info, result_chunk);
+		spare_result_chunk.Reset();
+
+		loops++;
+	}
+
+	if (info.is_all_constant && !info.is_volatile) {
+		info.result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+
+	// the list column and the bound lambda expression
+	D_ASSERT(arguments.size() == 2);
+	if (arguments[1]->expression_class != ExpressionClass::BOUND_LAMBDA) {
+		throw BinderException("Invalid lambda expression!");
+	}
+
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
+	if (bound_lambda_expr.parameter_count < 2 || bound_lambda_expr.parameter_count > 3) {
+		throw BinderException("list_reduce expects a function with 2 or 3 arguments");
+	}
+	auto has_index = bound_lambda_expr.parameter_count == 3;
+
+	unique_ptr<FunctionData> bind_data = LambdaFunctions::ListLambdaPrepareBind(arguments, context, bound_function);
+	if (bind_data) {
+		return bind_data;
+	}
+
+	auto list_child_type = arguments[0]->return_type;
+	list_child_type = ListType::GetChildType(list_child_type);
+
+	auto cast_lambda_expr =
+	    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), list_child_type, false);
+	if (!cast_lambda_expr) {
+		throw BinderException("Could not cast lambda expression to list child type");
+	}
+	bound_function.return_type = cast_lambda_expr->return_type;
+	return make_uniq<ListLambdaBindData>(bound_function.return_type, std::move(cast_lambda_expr), has_index);
+}
+
+static LogicalType ListReduceBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
+	return LambdaFunctions::BindTernaryLambda(parameter_idx, list_child_type);
+}
+
+ScalarFunction ListReduceFun::GetFunction() {
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::ANY,
+	                   LambdaFunctions::ListReduceFunction, ListReduceBind, nullptr, nullptr);
+
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.serialize = ListLambdaBindData::Serialize;
+	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.bind_lambda = ListReduceBindLambda;
+
+	return fun;
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/scalar/list/list_sort.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/common/enum_util.hpp"
-#include "duckdb/common/types/chunk_collection.hpp"
+
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/main/config.hpp"
@@ -10,14 +11,15 @@
 namespace duckdb {
 
 struct ListSortBindData : public FunctionData {
-	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, const LogicalType &return_type_p,
-	                 const LogicalType &child_type_p, ClientContext &context_p);
+	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, bool is_grade_up,
+	                 const LogicalType &return_type_p, const LogicalType &child_type_p, ClientContext &context_p);
 	~ListSortBindData() override;
 
 	OrderType order_type;
 	OrderByNullType null_order;
 	LogicalType return_type;
 	LogicalType child_type;
+	bool is_grade_up;
 
 	vector<LogicalType> types;
 	vector<LogicalType> payload_types;
@@ -31,11 +33,11 @@ public:
 	unique_ptr<FunctionData> Copy() const override;
 };
 
-ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p,
+ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, bool is_grade_up_p,
                                    const LogicalType &return_type_p, const LogicalType &child_type_p,
                                    ClientContext &context_p)
     : order_type(order_type_p), null_order(null_order_p), return_type(return_type_p), child_type(child_type_p),
-      context(context_p) {
+      is_grade_up(is_grade_up_p), context(context_p) {
 
 	// get the vector types
 	types.emplace_back(LogicalType::USMALLINT);
@@ -57,12 +59,12 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 }
 
 unique_ptr<FunctionData> ListSortBindData::Copy() const {
-	return make_uniq<ListSortBindData>(order_type, null_order, return_type, child_type, context);
+	return make_uniq<ListSortBindData>(order_type, null_order, is_grade_up, return_type, child_type, context);
 }
 
 bool ListSortBindData::Equals(const FunctionData &other_p) const {
 	auto &other = other_p.Cast<ListSortBindData>();
-	return order_type == other.order_type && null_order == other.null_order;
+	return order_type == other.order_type && null_order == other.null_order && is_grade_up == other.is_grade_up;
 }
 
 ListSortBindData::~ListSortBindData() {
@@ -120,18 +122,20 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	LocalSortState local_sort_state;
 	local_sort_state.Initialize(global_sort_state, buffer_manager);
 
+	Vector sort_result_vec = info.is_grade_up ? Vector(input_lists.GetType()) : result;
+
 	// this ensures that we do not change the order of the entries in the input chunk
-	VectorOperations::Copy(input_lists, result, count, 0, 0);
+	VectorOperations::Copy(input_lists, sort_result_vec, count, 0, 0);
 
 	// get the child vector
-	auto lists_size = ListVector::GetListSize(result);
-	auto &child_vector = ListVector::GetEntry(result);
+	auto lists_size = ListVector::GetListSize(sort_result_vec);
+	auto &child_vector = ListVector::GetEntry(sort_result_vec);
 	UnifiedVectorFormat child_data;
 	child_vector.ToUnifiedFormat(lists_size, child_data);
 
 	// get the lists data
 	UnifiedVectorFormat lists_data;
-	result.ToUnifiedFormat(count, lists_data);
+	sort_result_vec.ToUnifiedFormat(count, lists_data);
 	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
 
 	// create the lists_indices vector, this contains an element for each list's entry,
@@ -191,6 +195,13 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 		              local_sort_state, data_to_sort, lists_indices);
 	}
 
+	if (info.is_grade_up) {
+		ListVector::Reserve(result, lists_size);
+		ListVector::SetListSize(result, lists_size);
+		auto result_data = ListVector::GetData(result);
+		memcpy(result_data, list_entries, count * sizeof(list_entry_t));
+	}
+
 	if (data_to_sort) {
 		// add local state to global state, which sorts the data
 		global_sort_state.AddLocalState(local_sort_state);
@@ -224,8 +235,19 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 		}
 
 		D_ASSERT(sel_sorted_idx == incr_payload_count);
-		child_vector.Slice(sel_sorted, sel_sorted_idx);
-		child_vector.Flatten(sel_sorted_idx);
+		if (info.is_grade_up) {
+			auto &result_entry = ListVector::GetEntry(result);
+			auto result_data = ListVector::GetData(result);
+			for (idx_t i = 0; i < count; i++) {
+				for (idx_t j = result_data[i].offset; j < result_data[i].offset + result_data[i].length; j++) {
+					auto b = sel_sorted.get_index(j) - result_data[i].offset;
+					result_entry.SetValue(j, Value::BIGINT(b + 1));
+				}
+			}
+		} else {
+			child_vector.Slice(sel_sorted, sel_sorted_idx);
+			child_vector.Flatten(sel_sorted_idx);
+		}
 	}
 
 	if (args.AllConstant()) {
@@ -242,14 +264,16 @@ static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunct
 		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
 		bound_function.return_type = LogicalType::SQLNULL;
 		child_type = bound_function.return_type;
-		return make_uniq<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
+		return make_uniq<ListSortBindData>(order, null_order, false, bound_function.return_type, child_type, context);
 	}
 
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+	child_type = ListType::GetChildType(arguments[0]->return_type);
+
 	bound_function.arguments[0] = arguments[0]->return_type;
 	bound_function.return_type = arguments[0]->return_type;
-	child_type = ListType::GetChildType(arguments[0]->return_type);
 
-	return make_uniq<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
+	return make_uniq<ListSortBindData>(order, null_order, false, bound_function.return_type, child_type, context);
 }
 
 template <class T>
@@ -262,6 +286,31 @@ static T GetOrder(ClientContext &context, Expression &expr) {
 	return EnumUtil::FromString<T>(order_name.c_str());
 }
 
+static unique_ptr<FunctionData> ListGradeUpBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+
+	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
+	auto order = OrderType::ORDER_DEFAULT;
+	auto null_order = OrderByNullType::ORDER_DEFAULT;
+
+	// get the sorting order
+	if (arguments.size() >= 2) {
+		order = GetOrder<OrderType>(context, *arguments[1]);
+	}
+	// get the null sorting order
+	if (arguments.size() == 3) {
+		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
+	}
+	auto &config = DBConfig::GetConfig(context);
+	order = config.ResolveOrder(order);
+	null_order = config.ResolveNullOrder(order, null_order);
+
+	bound_function.arguments[0] = arguments[0]->return_type;
+	bound_function.return_type = LogicalType::LIST(LogicalTypeId::BIGINT);
+	auto child_type = ListType::GetChildType(arguments[0]->return_type);
+	return make_uniq<ListSortBindData>(order, null_order, true, bound_function.return_type, child_type, context);
+}
+
 static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
@@ -326,6 +375,26 @@ ScalarFunctionSet ListSortFun::GetFunctions() {
 	return list_sort;
 }
 
+ScalarFunctionSet ListGradeUpFun::GetFunctions() {
+	// one parameter: list
+	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
+	                    ListGradeUpBind);
+
+	// two parameters: list, order
+	ScalarFunction sort_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
+	                          LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListGradeUpBind);
+
+	// three parameters: list, order, null order
+	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListGradeUpBind);
+
+	ScalarFunctionSet list_grade_up;
+	list_grade_up.AddFunction(sort);
+	list_grade_up.AddFunction(sort_order);
+	list_grade_up.AddFunction(sort_orders);
+	return list_grade_up;
+}
+
 ScalarFunctionSet ListReverseSortFun::GetFunctions() {
 	// one parameter: list
 	ScalarFunction sort_reverse({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),

package/src/duckdb/src/core_functions/scalar/list/list_transform.cpp

@@ -0,0 +1,41 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
+
+#include "duckdb/core_functions/lambda_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+
+namespace duckdb {
+
+static unique_ptr<FunctionData> ListTransformBind(ClientContext &context, ScalarFunction &bound_function,
+                                                  vector<unique_ptr<Expression>> &arguments) {
+
+	// the list column and the bound lambda expression
+	D_ASSERT(arguments.size() == 2);
+	if (arguments[1]->expression_class != ExpressionClass::BOUND_LAMBDA) {
+		throw BinderException("Invalid lambda expression!");
+	}
+
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
+	bound_function.return_type = LogicalType::LIST(bound_lambda_expr.lambda_expr->return_type);
+	auto has_index = bound_lambda_expr.parameter_count == 2;
+	return LambdaFunctions::ListLambdaBind(context, bound_function, arguments, has_index);
+}
+
+static LogicalType ListTransformBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
+	return LambdaFunctions::BindBinaryLambda(parameter_idx, list_child_type);
+}
+
+ScalarFunction ListTransformFun::GetFunction() {
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::LIST(LogicalType::ANY),
+	                   LambdaFunctions::ListTransformFunction, ListTransformBind, nullptr, nullptr);
+
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.serialize = ListLambdaBindData::Serialize;
+	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.bind_lambda = ListTransformBindLambda;
+
+	return fun;
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/scalar/list/list_value.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/parser/query_error_context.hpp"
 
 namespace duckdb {
 
@@ -36,10 +37,28 @@ static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &r
 static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunction &bound_function,
                                               vector<unique_ptr<Expression>> &arguments) {
 	// collect names and deconflict, construct return type
-	LogicalType child_type = arguments.empty() ? LogicalType::SQLNULL : arguments[0]->return_type;
+	LogicalType child_type =
+	    arguments.empty() ? LogicalType::SQLNULL : ExpressionBinder::GetExpressionReturnType(*arguments[0]);
 	for (idx_t i = 1; i < arguments.size(); i++) {
-		child_type = LogicalType::MaxLogicalType(child_type, arguments[i]->return_type);
+		auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]);
+		if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) {
+			string list_arguments = "Full list: ";
+			idx_t error_index = list_arguments.size();
+			for (idx_t k = 0; k < arguments.size(); k++) {
+				if (k > 0) {
+					list_arguments += ", ";
+				}
+				if (k == i) {
+					error_index = list_arguments.size();
+				}
+				list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString();
+			}
+			auto error = StringUtil::Format("Cannot create a list of types %s and %s - an explicit cast is required",
+			                                child_type.ToString(), arg_type.ToString());
+			throw BinderException(QueryErrorContext::Format(list_arguments, error, int(error_index), false));
+		}
 	}
+	child_type = LogicalType::NormalizeType(child_type);
 
 	// this is more for completeness reasons
 	bound_function.varargs = child_type;

package/src/duckdb/src/core_functions/scalar/map/map.cpp

@@ -32,12 +32,13 @@ static void AlignVectorToReference(const Vector &original, const Vector &referen
 
 	Vector expanded_const(ListType::GetChildType(original.GetType()), new_length);
 
-	auto expansion_factor = new_length / original_length;
-	if (expansion_factor != tuple_count) {
+	if (new_length != tuple_count * original_length) {
 		throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
 		                            "size or incompatible structure");
 	}
+	auto expansion_factor = original_length ? new_length / original_length : original_length;
 	CreateExpandedVector(original, expanded_const, expansion_factor);
+
 	result.Reference(expanded_const);
 }
 
@@ -186,14 +187,14 @@ static unique_ptr<FunctionData> MapBind(ClientContext &context, ScalarFunction &
 	child_list_t<LogicalType> child_types;
 
 	if (arguments.size() != 2 && !arguments.empty()) {
-		throw Exception("We need exactly two lists for a map");
+		throw InvalidInputException("We need exactly two lists for a map");
 	}
 	if (arguments.size() == 2) {
 		if (arguments[0]->return_type.id() != LogicalTypeId::LIST) {
-			throw Exception("First argument is not a list");
+			throw InvalidInputException("First argument is not a list");
 		}
 		if (arguments[1]->return_type.id() != LogicalTypeId::LIST) {
-			throw Exception("Second argument is not a list");
+			throw InvalidInputException("Second argument is not a list");
 		}
 		child_types.push_back(make_pair("key", arguments[0]->return_type));
 		child_types.push_back(make_pair("value", arguments[1]->return_type));

package/src/duckdb/src/core_functions/scalar/map/map_entries.cpp

@@ -10,9 +10,9 @@ namespace duckdb {
 
 // Reverse of map_from_entries
 static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	idx_t count = args.size();
+	auto count = args.size();
 
-	result.Reinterpret(args.data[0]);
+	MapUtil::ReinterpretMap(result, args.data[0], count);
 
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);

package/src/duckdb/src/core_functions/scalar/map/map_from_entries.cpp

@@ -10,8 +10,7 @@ namespace duckdb {
 static void MapFromEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto count = args.size();
 
-	result.Reinterpret(args.data[0]);
-
+	MapUtil::ReinterpretMap(result, args.data[0], count);
 	MapVector::MapConversionVerify(result, count);
 	result.Verify(count);
 

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

@@ -346,7 +346,7 @@ struct CeilDecimalOperator {
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
 		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
 		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
+			if (input <= 0) {
 				// below 0 we floor the number (e.g. -10.5 -> -10)
 				return input / power_of_ten;
 			} else {
@@ -484,6 +484,7 @@ ScalarFunctionSet TruncFun::GetFunctions() {
 		case LogicalTypeId::USMALLINT:
 		case LogicalTypeId::UINTEGER:
 		case LogicalTypeId::UBIGINT:
+		case LogicalTypeId::UHUGEINT:
 			func = ScalarFunction::NopFunction;
 			break;
 		default:
@@ -1067,7 +1068,7 @@ struct ASinOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		if (input < -1 || input > 1) {
-			throw Exception("ASIN is undefined outside [-1,1]");
+			throw InvalidInputException("ASIN is undefined outside [-1,1]");
 		}
 		return (double)std::asin(input);
 	}
@@ -1126,6 +1127,23 @@ ScalarFunction AcosFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cot
 //===--------------------------------------------------------------------===//
+template <class OP>
+struct NoInfiniteNoZeroDoubleWrapper {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		if (DUCKDB_UNLIKELY(!Value::IsFinite(input))) {
+			if (Value::IsNan(input)) {
+				return input;
+			}
+			throw OutOfRangeException("input value %lf is out of range for numeric function", input);
+		}
+		if (DUCKDB_UNLIKELY((double)input == 0.0 || (double)input == -0.0)) {
+			throw OutOfRangeException("input value %lf is out of range for numeric function cotangent", input);
+		}
+		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
+	}
+};
+
 struct CotOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1135,7 +1153,7 @@ struct CotOperator {
 
 ScalarFunction CotFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                      ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CotOperator>>);
+	                      ScalarFunction::UnaryFunction<double, double, NoInfiniteNoZeroDoubleWrapper<CotOperator>>);
 }
 
 //===--------------------------------------------------------------------===//
@@ -1182,7 +1200,9 @@ struct FactorialOperator {
 	static inline TR Operation(TA left) {
 		TR ret = 1;
 		for (TA i = 2; i <= left; i++) {
-			ret *= i;
+			if (!TryMultiplyOperator::Operation(ret, TR(i), ret)) {
+				throw OutOfRangeException("Value out of range");
+			}
 		}
 		return ret;
 	}

package/src/duckdb/src/core_functions/scalar/operators/bitwise.cpp

@@ -36,6 +36,9 @@ static scalar_function_t GetScalarIntegerUnaryFunction(const LogicalType &type)
 	case LogicalTypeId::HUGEINT:
 		function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
 		break;
+	case LogicalTypeId::UHUGEINT:
+		function = &ScalarFunction::UnaryFunction<uhugeint_t, uhugeint_t, OP>;
+		break;
 	default:
 		throw NotImplementedException("Unimplemented type for GetScalarIntegerUnaryFunction");
 	}
@@ -73,6 +76,9 @@ static scalar_function_t GetScalarIntegerBinaryFunction(const LogicalType &type)
 	case LogicalTypeId::HUGEINT:
 		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
 		break;
+	case LogicalTypeId::UHUGEINT:
+		function = &ScalarFunction::BinaryFunction<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
+		break;
 	default:
 		throw NotImplementedException("Unimplemented type for GetScalarIntegerBinaryFunction");
 	}

package/src/duckdb/src/core_functions/scalar/random/random.cpp

@@ -36,7 +36,7 @@ static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &stat
 ScalarFunction RandomFun::GetFunction() {
 	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
 	                      RandomInitLocalState);
-	random.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	random.stability = FunctionStability::VOLATILE;
 	return random;
 }
 
@@ -56,7 +56,7 @@ ScalarFunction UUIDFun::GetFunction() {
 	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, nullptr, nullptr, nullptr,
 	                             RandomInitLocalState);
 	// generate a random uuid
-	uuid_function.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	uuid_function.stability = FunctionStability::VOLATILE;
 	return uuid_function;
 }