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

package/src/duckdb/src/common/vector_operations/vector_hash.cpp

@@ -3,12 +3,11 @@
 // Description: This file contains the vectorized hash implementations
 //===--------------------------------------------------------------------===//
 
-#include "duckdb/common/uhugeint.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 
 namespace duckdb {
 
@@ -91,6 +90,8 @@ static inline void StructLoopHash(Vector &input, Vector &hashes, const Selection
 
 template <bool HAS_RSEL, bool FIRST_HASH>
 static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
+	// FIXME: if we want to be more efficient we shouldn't flatten, but the logic here currently requires it
+	hashes.Flatten(count);
 	auto hdata = FlatVector::GetData<hash_t>(hashes);
 
 	UnifiedVectorFormat idata;
@@ -180,40 +181,68 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 
 template <bool HAS_RSEL, bool FIRST_HASH>
 static inline void ArrayLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
+	hashes.Flatten(count);
 	auto hdata = FlatVector::GetData<hash_t>(hashes);
 
-	if (input.GetVectorType() != VectorType::CONSTANT_VECTOR || input.GetVectorType() != VectorType::FLAT_VECTOR) {
-		input.Flatten(count);
-	}
-
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
 	// Hash the children into a temporary
 	auto &child = ArrayVector::GetEntry(input);
 	auto array_size = ArrayType::GetSize(input.GetType());
+
+	auto is_flat = input.GetVectorType() == VectorType::FLAT_VECTOR;
 	auto is_constant = input.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	auto child_count = array_size * (is_constant ? 1 : count);
 
-	Vector child_hashes(LogicalType::HASH, child_count);
-	if (child_count > 0) {
-		child_hashes.Flatten(child_count);
+	if (!HAS_RSEL && (is_flat || is_constant)) {
+		// Fast path for contiguous vectors with no selection vector
+		auto child_count = array_size * (is_constant ? 1 : count);
+
+		Vector child_hashes(LogicalType::HASH, child_count);
 		VectorOperations::Hash(child, child_hashes, child_count);
-	}
-	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
+		child_hashes.Flatten(child_count);
+		auto chdata = FlatVector::GetData<hash_t>(child_hashes);
 
-	for (idx_t i = 0; i < count; ++i) {
-		const auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-		const auto lidx = idata.sel->get_index(ridx);
-		const auto offset = lidx * array_size;
-		if (idata.validity.RowIsValid(lidx)) {
-			for (idx_t j = 0; j < array_size; j++) {
-				hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[offset + j]);
+		for (idx_t i = 0; i < count; i++) {
+			auto lidx = idata.sel->get_index(i);
+			if (idata.validity.RowIsValid(lidx)) {
+				for (idx_t j = 0; j < array_size; j++) {
+					auto offset = lidx * array_size + j;
+					hdata[i] = CombineHashScalar(hdata[i], chdata[offset]);
+				}
+			} else if (FIRST_HASH) {
+				hdata[i] = HashOp::NULL_HASH;
+			}
+		}
+	} else {
+		// Hash the arrays one-by-one
+		SelectionVector array_sel(array_size);
+		Vector array_hashes(LogicalType::HASH, array_size);
+		for (idx_t i = 0; i < count; i++) {
+			const auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
+			const auto lidx = idata.sel->get_index(ridx);
+
+			if (idata.validity.RowIsValid(lidx)) {
+				// Create a selection vector for the array
+				for (idx_t j = 0; j < array_size; j++) {
+					array_sel.set_index(j, lidx * array_size + j);
+				}
+
+				// Hash the array slice
+				Vector dict_vec(child, array_sel, array_size);
+				VectorOperations::Hash(dict_vec, array_hashes, array_size);
+				auto ahdata = FlatVector::GetData<hash_t>(array_hashes);
+
+				// Combine the hashes of the array
+				for (idx_t j = 0; j < array_size; j++) {
+					hdata[ridx] = CombineHashScalar(hdata[ridx], ahdata[j]);
+					// Clear the hash for the next iteration
+					ahdata[j] = 0;
+				}
+			} else if (FIRST_HASH) {
+				hdata[ridx] = HashOp::NULL_HASH;
 			}
-		} else if (FIRST_HASH) {
-			hdata[ridx] = HashOp::NULL_HASH;
 		}
-		// Empty or NULL non-first elements have no effect.
 	}
 }
 

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -9,8 +9,9 @@ VirtualFileSystem::VirtualFileSystem() : default_fs(FileSystem::CreateLocal()) {
 	VirtualFileSystem::RegisterSubSystem(FileCompressionType::GZIP, make_uniq<GZipFileSystem>());
 }
 
-unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock,
-                                                   FileCompressionType compression, FileOpener *opener) {
+unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, FileOpenFlags flags,
+                                                   optional_ptr<FileOpener> opener) {
+	auto compression = flags.Compression();
 	if (compression == FileCompressionType::AUTO_DETECT) {
 		// auto detect compression settings based on file name
 		auto lower_path = StringUtil::Lower(path);
@@ -26,8 +27,12 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 			compression = FileCompressionType::UNCOMPRESSED;
 		}
 	}
-	// open the base file handle
-	auto file_handle = FindFileSystem(path).OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
+	// open the base file handle in UNCOMPRESSED mode
+	flags.SetCompression(FileCompressionType::UNCOMPRESSED);
+	auto file_handle = FindFileSystem(path).OpenFile(path, flags, opener);
+	if (!file_handle) {
+		return nullptr;
+	}
 	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
 		file_handle = PipeFileSystem::OpenPipe(std::move(file_handle));
 	} else if (compression != FileCompressionType::UNCOMPRESSED) {
@@ -36,7 +41,7 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 			throw NotImplementedException(
 			    "Attempting to open a compressed file, but the compression type is not supported");
 		}
-		file_handle = entry->second->OpenCompressedFile(std::move(file_handle), flags & FileFlags::FILE_FLAGS_WRITE);
+		file_handle = entry->second->OpenCompressedFile(std::move(file_handle), flags.OpenForWriting());
 	}
 	return file_handle;
 }
@@ -76,15 +81,15 @@ void VirtualFileSystem::FileSync(FileHandle &handle) {
 }
 
 // need to look up correct fs for this
-bool VirtualFileSystem::DirectoryExists(const string &directory) {
-	return FindFileSystem(directory).DirectoryExists(directory);
+bool VirtualFileSystem::DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) {
+	return FindFileSystem(directory).DirectoryExists(directory, opener);
 }
-void VirtualFileSystem::CreateDirectory(const string &directory) {
-	FindFileSystem(directory).CreateDirectory(directory);
+void VirtualFileSystem::CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) {
+	FindFileSystem(directory).CreateDirectory(directory, opener);
 }
 
-void VirtualFileSystem::RemoveDirectory(const string &directory) {
-	FindFileSystem(directory).RemoveDirectory(directory);
+void VirtualFileSystem::RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) {
+	FindFileSystem(directory).RemoveDirectory(directory, opener);
 }
 
 bool VirtualFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
@@ -92,19 +97,20 @@ bool VirtualFileSystem::ListFiles(const string &directory, const std::function<v
 	return FindFileSystem(directory).ListFiles(directory, callback, opener);
 }
 
-void VirtualFileSystem::MoveFile(const string &source, const string &target) {
-	FindFileSystem(source).MoveFile(source, target);
+void VirtualFileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
+	FindFileSystem(source).MoveFile(source, target, opener);
 }
 
-bool VirtualFileSystem::FileExists(const string &filename) {
-	return FindFileSystem(filename).FileExists(filename);
+bool VirtualFileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
+	return FindFileSystem(filename).FileExists(filename, opener);
 }
 
-bool VirtualFileSystem::IsPipe(const string &filename) {
-	return FindFileSystem(filename).IsPipe(filename);
+bool VirtualFileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
+	return FindFileSystem(filename).IsPipe(filename, opener);
 }
-void VirtualFileSystem::RemoveFile(const string &filename) {
-	FindFileSystem(filename).RemoveFile(filename);
+
+void VirtualFileSystem::RemoveFile(const string &filename, optional_ptr<FileOpener> opener) {
+	FindFileSystem(filename).RemoveFile(filename, opener);
 }
 
 string VirtualFileSystem::PathSeparator(const string &path) {
@@ -174,11 +180,18 @@ FileSystem &VirtualFileSystem::FindFileSystem(const string &path) {
 }
 
 FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
+	FileSystem *fs = nullptr;
 	for (auto &sub_system : sub_systems) {
 		if (sub_system->CanHandleFile(path)) {
-			return *sub_system;
+			if (sub_system->IsManuallySet()) {
+				return *sub_system;
+			}
+			fs = sub_system.get();
 		}
 	}
+	if (fs) {
+		return *fs;
+	}
 	return *default_fs;
 }
 

package/src/duckdb/src/core_functions/aggregate/algebraic/avg.cpp

@@ -93,7 +93,7 @@ struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, Re
 	}
 };
 
-struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
+struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, AddToHugeint> {
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (state.count == 0) {
@@ -105,7 +105,7 @@ struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperat
 	}
 };
 
-struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
+struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (state.count == 0) {

package/src/duckdb/src/core_functions/aggregate/distributive/minmax.cpp

@@ -607,12 +607,12 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
 			FunctionBinder function_binder(context);
 			vector<LogicalType> types {arguments[0]->return_type, arguments[0]->return_type};
 			ErrorData error;
-			idx_t best_function = function_binder.BindFunction(func_entry.name, func_entry.functions, types, error);
-			if (best_function == DConstants::INVALID_INDEX) {
+			auto best_function = function_binder.BindFunction(func_entry.name, func_entry.functions, types, error);
+			if (!best_function.IsValid()) {
 				throw BinderException(string("Fail to find corresponding function for collation min/max: ") +
 				                      error.Message());
 			}
-			function = func_entry.functions.GetFunctionByOffset(best_function);
+			function = func_entry.functions.GetFunctionByOffset(best_function.GetIndex());
 
 			// Create a copied child and PushCollation for it.
 			arguments.push_back(arguments[0]->Copy());

package/src/duckdb/src/core_functions/aggregate/distributive/sum.cpp

@@ -32,7 +32,7 @@ struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 	}
 };
 
-struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
+struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, AddToHugeint> {
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (!state.isset) {
@@ -58,7 +58,7 @@ struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATO
 using NumericSumOperation = DoubleSumOperation<RegularAdd>;
 using KahanSumOperation = DoubleSumOperation<KahanAdd>;
 
-struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
+struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (!state.isset) {
@@ -69,6 +69,20 @@ struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 	}
 };
 
+unique_ptr<FunctionData> SumNoOverflowBind(ClientContext &context, AggregateFunction &function,
+                                           vector<unique_ptr<Expression>> &arguments) {
+	throw BinderException("sum_no_overflow is for internal use only!");
+}
+
+void SumNoOverflowSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                            const AggregateFunction &function) {
+	return;
+}
+
+unique_ptr<FunctionData> SumNoOverflowDeserialize(Deserializer &deserializer, AggregateFunction &function) {
+	return nullptr;
+}
+
 AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT32: {
@@ -76,6 +90,9 @@ AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
 		    LogicalType::INTEGER, LogicalType::HUGEINT);
 		function.name = "sum_no_overflow";
 		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
+		function.bind = SumNoOverflowBind;
+		function.serialize = SumNoOverflowSerialize;
+		function.deserialize = SumNoOverflowDeserialize;
 		return function;
 	}
 	case PhysicalType::INT64: {
@@ -83,6 +100,9 @@ AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
 		    LogicalType::BIGINT, LogicalType::HUGEINT);
 		function.name = "sum_no_overflow";
 		function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
+		function.bind = SumNoOverflowBind;
+		function.serialize = SumNoOverflowSerialize;
+		function.deserialize = SumNoOverflowDeserialize;
 		return function;
 	}
 	default:
@@ -90,6 +110,14 @@ AggregateFunction GetSumAggregateNoOverflow(PhysicalType type) {
 	}
 }
 
+AggregateFunction GetSumAggregateNoOverflowDecimal() {
+	AggregateFunction aggr({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr, nullptr,
+	                       nullptr, FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr, SumNoOverflowBind);
+	aggr.serialize = SumNoOverflowSerialize;
+	aggr.deserialize = SumNoOverflowDeserialize;
+	return aggr;
+}
+
 unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
                                              AggregateStatisticsInput &input) {
 	if (input.node_stats && input.node_stats->has_max_cardinality) {
@@ -173,17 +201,6 @@ unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunctio
 	return nullptr;
 }
 
-unique_ptr<FunctionData> BindDecimalSumNoOverflow(ClientContext &context, AggregateFunction &function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = GetSumAggregateNoOverflow(decimal_type.InternalType());
-	function.name = "sum_no_overflow";
-	function.arguments[0] = decimal_type;
-	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
-	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return nullptr;
-}
-
 AggregateFunctionSet SumFun::GetFunctions() {
 	AggregateFunctionSet sum;
 	// decimal
@@ -203,9 +220,7 @@ AggregateFunctionSet SumNoOverflowFun::GetFunctions() {
 	AggregateFunctionSet sum_no_overflow;
 	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT32));
 	sum_no_overflow.AddFunction(GetSumAggregateNoOverflow(PhysicalType::INT64));
-	sum_no_overflow.AddFunction(
-	    AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                      FunctionNullHandling::DEFAULT_NULL_HANDLING, nullptr, BindDecimalSumNoOverflow));
+	sum_no_overflow.AddFunction(GetSumAggregateNoOverflowDecimal());
 	return sum_no_overflow;
 }
 

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -1502,6 +1502,9 @@ unique_ptr<FunctionData> BindQuantile(ClientContext &context, AggregateFunction
 		throw BinderException("QUANTILE can only take constant parameters");
 	}
 	Value quantile_val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+	if (quantile_val.IsNull()) {
+		throw BinderException("QUANTILE argument must not be NULL");
+	}
 	vector<Value> quantiles;
 	if (quantile_val.type().id() != LogicalTypeId::LIST) {
 		quantiles.push_back(CheckQuantile(quantile_val));

package/src/duckdb/src/core_functions/aggregate/nested/list.cpp

@@ -63,6 +63,7 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 
 	for (idx_t i = 0; i < count; i++) {
 		auto &state = *states[states_data.sel->get_index(i)];
+		aggr_input_data.allocator.AlignNext();
 		list_bind_data.functions.AppendRow(aggr_input_data.allocator, state.linked_list, input_data, i);
 	}
 }
@@ -178,6 +179,7 @@ static void ListCombineFunction(Vector &states_vector, Vector &combined, Aggrega
 		Vector::RecursiveToUnifiedFormat(input, entry_count, input_data);
 
 		for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
+			aggr_input_data.allocator.AlignNext();
 			list_bind_data.functions.AppendRow(aggr_input_data.allocator, target.linked_list, input_data, entry_idx);
 		}
 	}

package/src/duckdb/src/core_functions/core_functions.cpp

@@ -6,7 +6,7 @@
 namespace duckdb {
 
 template <class T>
-void FillExtraInfo(StaticFunctionDefinition &function, T &info) {
+void FillExtraInfo(const StaticFunctionDefinition &function, T &info) {
 	info.internal = true;
 	info.description = function.description;
 	info.parameter_names = StringUtil::Split(function.parameters, ",");

package/src/duckdb/src/core_functions/function_list.cpp

@@ -47,7 +47,7 @@ namespace duckdb {
 	{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }
 
 // this list is generated by scripts/generate_functions.py
-static StaticFunctionDefinition internal_functions[] = {
+static const StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(FactorialOperatorFun),
 	DUCKDB_SCALAR_FUNCTION_SET(BitwiseAndFun),
 	DUCKDB_SCALAR_FUNCTION(PowOperatorFun),
@@ -394,7 +394,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	FINAL_FUNCTION
 };
 
-StaticFunctionDefinition *StaticFunctionDefinition::GetFunctionList() {
+const StaticFunctionDefinition *StaticFunctionDefinition::GetFunctionList() {
 	return internal_functions;
 }
 

package/src/duckdb/src/core_functions/scalar/date/time_bucket.cpp

@@ -22,7 +22,7 @@ struct TimeBucket {
 	// There are 360 months between 1970-01-01 and 2000-01-01
 	constexpr static const int32_t DEFAULT_ORIGIN_MONTHS = 360;
 
-	enum struct BucketWidthType { CONVERTIBLE_TO_MICROS, CONVERTIBLE_TO_MONTHS, UNCLASSIFIED };
+	enum struct BucketWidthType : uint8_t { CONVERTIBLE_TO_MICROS, CONVERTIBLE_TO_MONTHS, UNCLASSIFIED };
 
 	static inline BucketWidthType ClassifyBucketWidth(const interval_t bucket_width) {
 		if (bucket_width.months == 0 && Interval::GetMicro(bucket_width) > 0) {

package/src/duckdb/src/core_functions/scalar/generic/system_functions.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
@@ -28,25 +29,52 @@ static void CurrentDatabaseFunction(DataChunk &input, ExpressionState &state, Ve
 	result.Reference(val);
 }
 
-// current_schemas
-static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	if (!input.AllConstant()) {
+struct CurrentSchemasBindData : public FunctionData {
+	explicit CurrentSchemasBindData(Value result_value) : result(std::move(result_value)) {
+	}
+
+	Value result;
+
+public:
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<CurrentSchemasBindData>(result);
+	}
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<CurrentSchemasBindData>();
+		return Value::NotDistinctFrom(result, other.result);
+	}
+};
+
+static unique_ptr<FunctionData> CurrentSchemasBind(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->return_type.id() != LogicalTypeId::BOOLEAN) {
+		throw BinderException("current_schemas requires a boolean input");
+	}
+	if (!arguments[0]->IsFoldable()) {
 		throw NotImplementedException("current_schemas requires a constant input");
 	}
-	if (ConstantVector::IsNull(input.data[0])) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
+	Value schema_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
+	Value result_val;
+	if (schema_value.IsNull()) {
+		// null
+		result_val = Value(LogicalType::LIST(LogicalType::VARCHAR));
+	} else {
+		auto implicit_schemas = BooleanValue::Get(schema_value);
+		vector<Value> schema_list;
+		auto &catalog_search_path = ClientData::Get(context).catalog_search_path;
+		auto &search_path = implicit_schemas ? catalog_search_path->Get() : catalog_search_path->GetSetPaths();
+		std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
+		               [](const CatalogSearchEntry &s) -> Value { return Value(s.schema); });
+		result_val = Value::LIST(LogicalType::VARCHAR, schema_list);
 	}
-	auto implicit_schemas = *ConstantVector::GetData<bool>(input.data[0]);
-	vector<Value> schema_list;
-	auto &catalog_search_path = ClientData::Get(state.GetContext()).catalog_search_path;
-	auto &search_path = implicit_schemas ? catalog_search_path->Get() : catalog_search_path->GetSetPaths();
-	std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
-	               [](const CatalogSearchEntry &s) -> Value { return Value(s.schema); });
-
-	auto val = Value::LIST(LogicalType::VARCHAR, schema_list);
-	result.Reference(val);
+	return make_uniq<CurrentSchemasBindData>(std::move(result_val));
+}
+
+// current_schemas
+static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<CurrentSchemasBindData>();
+	result.Reference(info.result);
 }
 
 // in_search_path
@@ -94,7 +122,8 @@ ScalarFunction CurrentDatabaseFun::GetFunction() {
 
 ScalarFunction CurrentSchemasFun::GetFunction() {
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	ScalarFunction current_schemas({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction);
+	ScalarFunction current_schemas({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction,
+	                               CurrentSchemasBind);
 	current_schemas.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
 	return current_schemas;
 }

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

@@ -97,7 +97,7 @@ static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &e
 	}
 
 	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (begin < 0 && -begin > length && end < 0 && -end > length) {
+	if (begin < 0 && -begin > length && end < 0 && end < -length) {
 		begin = 0;
 		end = 0;
 		return true;