duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -7,43 +7,26 @@ namespace duckdb {
 
 template <class SRC_TYPE, class RES_TYPE>
 bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
-	auto str_vec_ptr = FlatVector::GetData<string_t>(str_vec);
-
+	auto &enum_dictionary = EnumType::GetValuesInsertOrder(source.GetType());
+	auto dictionary_data = FlatVector::GetData<string_t>(enum_dictionary);
 	auto res_enum_type = result.GetType();
 
-	UnifiedVectorFormat vdata;
-	source.ToUnifiedFormat(count, vdata);
-
-	auto source_data = UnifiedVectorFormat::GetData<SRC_TYPE>(vdata);
-	auto source_sel = vdata.sel;
-	auto source_mask = vdata.validity;
-
-	auto result_data = FlatVector::GetData<RES_TYPE>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
 	VectorTryCastData vector_cast_data(result, parameters);
-	for (idx_t i = 0; i < count; i++) {
-		auto src_idx = source_sel->get_index(i);
-		if (!source_mask.RowIsValid(src_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		auto key = EnumType::GetPos(res_enum_type, str_vec_ptr[source_data[src_idx]]);
-		if (key == -1) {
-			// key doesn't exist on result enum
-			if (!parameters.error_message) {
-				result_data[i] = HandleVectorCastError::Operation<RES_TYPE>(
-				    CastExceptionText<SRC_TYPE, RES_TYPE>(source_data[src_idx]), result_mask, i, vector_cast_data);
-			} else {
-				result_mask.SetInvalid(i);
-			}
-			continue;
-		}
-		result_data[i] = UnsafeNumericCast<RES_TYPE>(key);
-	}
+	UnaryExecutor::ExecuteWithNulls<SRC_TYPE, RES_TYPE>(
+	    source, result, count, [&](SRC_TYPE value, ValidityMask &mask, idx_t row_idx) {
+		    auto key = EnumType::GetPos(res_enum_type, dictionary_data[value]);
+		    if (key == -1) {
+			    if (!parameters.error_message) {
+				    return HandleVectorCastError::Operation<RES_TYPE>(CastExceptionText<SRC_TYPE, RES_TYPE>(value),
+				                                                      mask, row_idx, vector_cast_data);
+			    } else {
+				    mask.SetInvalid(row_idx);
+			    }
+			    return RES_TYPE();
+		    } else {
+			    return UnsafeNumericCast<RES_TYPE>(key);
+		    }
+	    });
 	return vector_cast_data.all_converted;
 }
 
@@ -65,27 +48,9 @@ template <class SRC>
 static bool EnumToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &enum_dictionary = EnumType::GetValuesInsertOrder(source.GetType());
 	auto dictionary_data = FlatVector::GetData<string_t>(enum_dictionary);
-	auto result_data = FlatVector::GetData<string_t>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
-	UnifiedVectorFormat vdata;
-	source.ToUnifiedFormat(count, vdata);
-
-	auto source_data = UnifiedVectorFormat::GetData<SRC>(vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto source_idx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(source_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		auto enum_idx = source_data[source_idx];
-		result_data[i] = dictionary_data[enum_idx];
-	}
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	} else {
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-	}
+
+	UnaryExecutor::Execute<SRC, string_t>(source, result, count,
+	                                      [&](SRC enum_idx) { return dictionary_data[enum_idx]; });
 	return true;
 }
 

package/src/duckdb/src/function/cast/vector_cast_helpers.cpp

@@ -39,25 +39,26 @@ static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
 static bool SkipToClose(idx_t &idx, const char *buf, idx_t &len, idx_t &lvl, char close_bracket) {
 	idx++;
 
+	vector<char> brackets;
+	brackets.push_back(close_bracket);
 	while (idx < len) {
 		if (buf[idx] == '"' || buf[idx] == '\'') {
 			if (!SkipToCloseQuotes(idx, buf, len)) {
 				return false;
 			}
 		} else if (buf[idx] == '{') {
-			if (!SkipToClose(idx, buf, len, lvl, '}')) {
-				return false;
-			}
+			brackets.push_back('}');
 		} else if (buf[idx] == '[') {
-			if (!SkipToClose(idx, buf, len, lvl, ']')) {
-				return false;
-			}
+			brackets.push_back(']');
 			lvl++;
-		} else if (buf[idx] == close_bracket) {
-			if (close_bracket == ']') {
+		} else if (buf[idx] == brackets.back()) {
+			if (buf[idx] == ']') {
 				lvl--;
 			}
-			return true;
+			brackets.pop_back();
+			if (brackets.empty()) {
+				return true;
+			}
 		}
 		idx++;
 	}

package/src/duckdb/src/function/cast_rules.cpp

@@ -24,6 +24,8 @@ static int64_t TargetTypeCost(const LogicalType &type) {
 		return 121;
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return 122;
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return 123;
 	case LogicalTypeId::VARCHAR:
 		return 149;
 	case LogicalTypeId::STRUCT:
@@ -259,6 +261,8 @@ static int64_t ImplicitCastTimestamp(const LogicalType &to) {
 	switch (to.id()) {
 	case LogicalTypeId::TIMESTAMP_NS:
 		return TargetTypeCost(to);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return TargetTypeCost(to);
 	default:
 		return -1;
 	}
@@ -382,8 +386,12 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 	}
 	if (from.id() == LogicalTypeId::ARRAY && to.id() == LogicalTypeId::LIST) {
 		// Arrays can be cast to lists for the cost of casting the child type
+		auto child_cost = ImplicitCast(ArrayType::GetChildType(from), ListType::GetChildType(to));
+		if (child_cost < 0) {
+			return -1;
+		}
 		// add 1 because we prefer ARRAY->ARRAY casts over ARRAY->LIST casts
-		return ImplicitCast(ArrayType::GetChildType(from), ListType::GetChildType(to)) + 1;
+		return child_cost + 1;
 	}
 	if (from.id() == LogicalTypeId::LIST && (to.id() == LogicalTypeId::ARRAY && !ArrayType::IsAnySize(to))) {
 		// Lists can be cast to arrays for the cost of casting the child type, if the target size is known

package/src/duckdb/src/function/compression_config.cpp

@@ -14,7 +14,7 @@ struct DefaultCompressionMethod {
 	compression_supports_type_t supports_type;
 };
 
-static DefaultCompressionMethod internal_compression_methods[] = {
+static const DefaultCompressionMethod internal_compression_methods[] = {
     {CompressionType::COMPRESSION_CONSTANT, ConstantFun::GetFunction, ConstantFun::TypeIsSupported},
     {CompressionType::COMPRESSION_UNCOMPRESSED, UncompressedFun::GetFunction, UncompressedFun::TypeIsSupported},
     {CompressionType::COMPRESSION_RLE, RLEFun::GetFunction, RLEFun::TypeIsSupported},

package/src/duckdb/src/function/function_binder.cpp

@@ -18,12 +18,12 @@ namespace duckdb {
 FunctionBinder::FunctionBinder(ClientContext &context) : context(context) {
 }
 
-int64_t FunctionBinder::BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
+optional_idx FunctionBinder::BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
 	if (arguments.size() < func.arguments.size()) {
 		// not enough arguments to fulfill the non-vararg part of the function
-		return -1;
+		return optional_idx();
 	}
-	int64_t cost = 0;
+	idx_t cost = 0;
 	for (idx_t i = 0; i < arguments.size(); i++) {
 		LogicalType arg_type = i < func.arguments.size() ? func.arguments[i] : func.varargs;
 		if (arguments[i] == arg_type) {
@@ -33,25 +33,25 @@ int64_t FunctionBinder::BindVarArgsFunctionCost(const SimpleFunction &func, cons
 		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], arg_type);
 		if (cast_cost >= 0) {
 			// we can implicitly cast, add the cost to the total cost
-			cost += cast_cost;
+			cost += idx_t(cast_cost);
 		} else {
 			// we can't implicitly cast: throw an error
-			return -1;
+			return optional_idx();
 		}
 	}
 	return cost;
 }
 
-int64_t FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
+optional_idx FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments) {
 	if (func.HasVarArgs()) {
 		// special case varargs function
 		return BindVarArgsFunctionCost(func, arguments);
 	}
 	if (func.arguments.size() != arguments.size()) {
 		// invalid argument count: check the next function
-		return -1;
+		return optional_idx();
 	}
-	int64_t cost = 0;
+	idx_t cost = 0;
 	bool has_parameter = false;
 	for (idx_t i = 0; i < arguments.size(); i++) {
 		if (arguments[i].id() == LogicalTypeId::UNKNOWN) {
@@ -61,10 +61,10 @@ int64_t FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vecto
 		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], func.arguments[i]);
 		if (cast_cost >= 0) {
 			// we can implicitly cast, add the cost to the total cost
-			cost += cast_cost;
+			cost += idx_t(cast_cost);
 		} else {
 			// we can't implicitly cast: throw an error
-			return -1;
+			return optional_idx();
 		}
 	}
 	if (has_parameter) {
@@ -77,17 +77,18 @@ int64_t FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vecto
 template <class T>
 vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
                                                          const vector<LogicalType> &arguments, ErrorData &error) {
-	idx_t best_function = DConstants::INVALID_INDEX;
-	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
+	optional_idx best_function;
+	idx_t lowest_cost = NumericLimits<idx_t>::Maximum();
 	vector<idx_t> candidate_functions;
 	for (idx_t f_idx = 0; f_idx < functions.functions.size(); f_idx++) {
 		auto &func = functions.functions[f_idx];
 		// check the arguments of the function
-		int64_t cost = BindFunctionCost(func, arguments);
-		if (cost < 0) {
+		auto bind_cost = BindFunctionCost(func, arguments);
+		if (!bind_cost.IsValid()) {
 			// auto casting was not possible
 			continue;
 		}
+		auto cost = bind_cost.GetIndex();
 		if (cost == lowest_cost) {
 			candidate_functions.push_back(f_idx);
 			continue;
@@ -99,7 +100,7 @@ vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, Fun
 		lowest_cost = cost;
 		best_function = f_idx;
 	}
-	if (best_function == DConstants::INVALID_INDEX) {
+	if (!best_function.IsValid()) {
 		// no matching function was found, throw an error
 		vector<string> candidates;
 		for (auto &f : functions.functions) {
@@ -108,14 +109,14 @@ vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, Fun
 		error = ErrorData(BinderException::NoMatchingFunction(name, arguments, candidates));
 		return candidate_functions;
 	}
-	candidate_functions.push_back(best_function);
+	candidate_functions.push_back(best_function.GetIndex());
 	return candidate_functions;
 }
 
 template <class T>
-idx_t FunctionBinder::MultipleCandidateException(const string &name, FunctionSet<T> &functions,
-                                                 vector<idx_t> &candidate_functions,
-                                                 const vector<LogicalType> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::MultipleCandidateException(const string &name, FunctionSet<T> &functions,
+                                                        vector<idx_t> &candidate_functions,
+                                                        const vector<LogicalType> &arguments, ErrorData &error) {
 	D_ASSERT(functions.functions.size() > 1);
 	// there are multiple possible function definitions
 	// throw an exception explaining which overloads are there
@@ -130,16 +131,16 @@ idx_t FunctionBinder::MultipleCandidateException(const string &name, FunctionSet
 	    StringUtil::Format("Could not choose a best candidate function for the function call \"%s\". In order to "
 	                       "select one, please add explicit type casts.\n\tCandidate functions:\n%s",
 	                       call_str, candidate_str));
-	return DConstants::INVALID_INDEX;
+	return optional_idx();
 }
 
 template <class T>
-idx_t FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
-                                                const vector<LogicalType> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
+                                                       const vector<LogicalType> &arguments, ErrorData &error) {
 	auto candidate_functions = BindFunctionsFromArguments<T>(name, functions, arguments, error);
 	if (candidate_functions.empty()) {
 		// no candidates
-		return DConstants::INVALID_INDEX;
+		return optional_idx();
 	}
 	if (candidate_functions.size() > 1) {
 		// multiple candidates, check if there are any unknown arguments
@@ -157,32 +158,32 @@ idx_t FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<
 	return candidate_functions[0];
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
+                                          const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
+                                          const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
+                                          const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
-                                   ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
+                                          ErrorData &error) {
 	vector<LogicalType> types;
 	for (auto &value : parameters) {
 		types.push_back(value.type());
 	}
-	idx_t entry = BindFunctionFromArguments(name, functions, types, error);
-	if (entry == DConstants::INVALID_INDEX) {
+	auto entry = BindFunctionFromArguments(name, functions, types, error);
+	if (!entry.IsValid()) {
 		error.Throw();
 	}
-	auto candidate_function = functions.GetFunctionByOffset(entry);
+	auto candidate_function = functions.GetFunctionByOffset(entry.GetIndex());
 	// cast the input parameters
 	for (idx_t i = 0; i < parameters.size(); i++) {
 		auto target_type =
@@ -201,25 +202,25 @@ vector<LogicalType> FunctionBinder::GetLogicalTypesFromExpressions(vector<unique
 	return types;
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
+                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
+                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
+optional_idx FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
+                                          vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
 
-enum class LogicalTypeComparisonResult { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
+enum class LogicalTypeComparisonResult : uint8_t { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
 
 LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
 	if (target_type.id() == LogicalTypeId::ANY) {
@@ -291,13 +292,13 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
                                                           vector<unique_ptr<Expression>> children, ErrorData &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
-	idx_t best_function = BindFunction(func.name, func.functions, children, error);
-	if (best_function == DConstants::INVALID_INDEX) {
+	auto best_function = BindFunction(func.name, func.functions, children, error);
+	if (!best_function.IsValid()) {
 		return nullptr;
 	}
 
 	// found a matching function!
-	auto bound_function = func.functions.GetFunctionByOffset(best_function);
+	auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
 
 	// If any of the parameters are NULL, the function will just be replaced with a NULL constant
 	// But this NULL constant needs to have to correct type, because we use LogicalType::SQLNULL for binding macro's

package/src/duckdb/src/function/function_set.cpp

@@ -16,12 +16,12 @@ ScalarFunctionSet::ScalarFunctionSet(ScalarFunction fun) : FunctionSet(std::move
 ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	ErrorData error;
 	FunctionBinder binder(context);
-	idx_t index = binder.BindFunction(name, *this, arguments, error);
-	if (index == DConstants::INVALID_INDEX) {
+	auto index = binder.BindFunction(name, *this, arguments, error);
+	if (!index.IsValid()) {
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
 		                        error.Message());
 	}
-	return GetFunctionByOffset(index);
+	return GetFunctionByOffset(index.GetIndex());
 }
 
 AggregateFunctionSet::AggregateFunctionSet() : FunctionSet("") {
@@ -38,8 +38,8 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
                                                                const vector<LogicalType> &arguments) {
 	ErrorData error;
 	FunctionBinder binder(context);
-	idx_t index = binder.BindFunction(name, *this, arguments, error);
-	if (index == DConstants::INVALID_INDEX) {
+	auto index = binder.BindFunction(name, *this, arguments, error);
+	if (!index.IsValid()) {
 		// check if the arguments are a prefix of any of the arguments
 		// this is used for functions such as quantile or string_agg that delete part of their arguments during bind
 		// FIXME: we should come up with a better solution here
@@ -61,7 +61,7 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
 		                        error.Message());
 	}
-	return GetFunctionByOffset(index);
+	return GetFunctionByOffset(index.GetIndex());
 }
 
 TableFunctionSet::TableFunctionSet(string name) : FunctionSet(std::move(name)) {
@@ -74,12 +74,12 @@ TableFunctionSet::TableFunctionSet(TableFunction fun) : FunctionSet(std::move(fu
 TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	ErrorData error;
 	FunctionBinder binder(context);
-	idx_t index = binder.BindFunction(name, *this, arguments, error);
-	if (index == DConstants::INVALID_INDEX) {
+	auto index = binder.BindFunction(name, *this, arguments, error);
+	if (!index.IsValid()) {
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
 		                        error.Message());
 	}
-	return GetFunctionByOffset(index);
+	return GetFunctionByOffset(index.GetIndex());
 }
 
 PragmaFunctionSet::PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -139,8 +139,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	vector<string> files = {"schema.sql", "load.sql"};
 	for (auto &file : files) {
 		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);
-		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
-		                          FileSystem::DEFAULT_COMPRESSION);
+		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ);
 		auto fsize = fs.GetFileSize(*handle);
 		auto buffer = make_unsafe_uniq_array<char>(fsize);
 		fs.Read(*handle, buffer.get(), fsize);

package/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/scalar/compressed_materialization_functions.hpp"
 
@@ -97,9 +97,25 @@ static string IntegralDecompressFunctionName(const LogicalType &result_type) {
 }
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-static inline RESULT_TYPE TemplatedIntegralDecompress(const INPUT_TYPE &input, const RESULT_TYPE &min_val) {
-	return UnsafeNumericCast<RESULT_TYPE>(min_val + input);
-}
+struct TemplatedIntegralDecompress {
+	static inline RESULT_TYPE Operation(const INPUT_TYPE &input, const RESULT_TYPE &min_val) {
+		return min_val + UnsafeNumericCast<RESULT_TYPE, INPUT_TYPE>(input);
+	}
+};
+
+template <class INPUT_TYPE>
+struct TemplatedIntegralDecompress<INPUT_TYPE, hugeint_t> {
+	static inline hugeint_t Operation(const INPUT_TYPE &input, const hugeint_t &min_val) {
+		return min_val + hugeint_t(0, input);
+	}
+};
+
+template <class INPUT_TYPE>
+struct TemplatedIntegralDecompress<INPUT_TYPE, uhugeint_t> {
+	static inline uhugeint_t Operation(const INPUT_TYPE &input, const uhugeint_t &min_val) {
+		return min_val + uhugeint_t(0, input);
+	}
+};
 
 template <class INPUT_TYPE, class RESULT_TYPE>
 static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -108,7 +124,7 @@ static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state,
 	D_ASSERT(args.data[1].GetType() == result.GetType());
 	const auto min_val = ConstantVector::GetData<RESULT_TYPE>(args.data[1])[0];
 	UnaryExecutor::Execute<INPUT_TYPE, RESULT_TYPE>(args.data[0], result, args.size(), [&](const INPUT_TYPE &input) {
-		return TemplatedIntegralDecompress<INPUT_TYPE, RESULT_TYPE>(input, min_val);
+		return TemplatedIntegralDecompress<INPUT_TYPE, RESULT_TYPE>::Operation(input, min_val);
 	});
 }
 

package/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp

@@ -11,13 +11,13 @@ static string StringCompressFunctionName(const LogicalType &result_type) {
 }
 
 template <idx_t LENGTH>
-static inline void TemplatedReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src) {
+static inline void TemplatedReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src) {
 	for (idx_t i = 0; i < LENGTH; i++) {
 		dest[i] = src[LENGTH - 1 - i];
 	}
 }
 
-static inline void ReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src,
+static inline void ReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src,
                                  const idx_t &length) {
 	for (idx_t i = 0; i < length; i++) {
 		dest[i] = src[length - 1 - i];

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

@@ -3,6 +3,7 @@
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -140,6 +141,10 @@ static void ListSelectFunction(DataChunk &args, ExpressionState &state, Vector &
 static unique_ptr<FunctionData> ListSelectBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
+
+	// If the first argument is an array, cast it to a list
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
 	LogicalType child_type;
 	if (arguments[0]->return_type == LogicalTypeId::UNKNOWN || arguments[1]->return_type == LogicalTypeId::UNKNOWN) {
 		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
@@ -149,8 +154,6 @@ static unique_ptr<FunctionData> ListSelectBind(ClientContext &context, ScalarFun
 
 	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);

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

@@ -31,13 +31,14 @@ static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &res
 	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];
+			auto &flag_vec = input_lists.back();
+			idx_t flag_idx = flag_vec.sel->get_index(j);
+			if (flag_vec.validity.RowIsValid(flag_idx)) {
+				truncate_to_shortest = UnifiedVectorFormat::GetData<bool>(flag_vec)[flag_idx];
+			}
 		}
 
 		// Calculation of the outgoing list size