duckdb 0.8.2-dev2399.0 → 0.8.2-dev2509.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2399.0",
+  "version": "0.8.2-dev2509.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/http_state.cpp

@@ -0,0 +1,78 @@
+#include "duckdb/common/http_state.hpp"
+
+namespace duckdb {
+
+CachedFileHandle::CachedFileHandle(shared_ptr<CachedFile> &file_p) {
+	// If the file was not yet initialized, we need to grab a lock.
+	if (!file_p->initialized) {
+		lock = make_uniq<lock_guard<mutex>>(file_p->lock);
+	}
+	file = file_p;
+}
+
+void CachedFileHandle::SetInitialized() {
+	if (file->initialized) {
+		throw InternalException("Cannot set initialized on cached file that was already initialized");
+	}
+	if (!lock) {
+		throw InternalException("Cannot set initialized on cached file without lock");
+	}
+	file->initialized = true;
+	lock = nullptr;
+}
+
+void CachedFileHandle::AllocateBuffer(idx_t size) {
+	if (file->initialized) {
+		throw InternalException("Cannot allocate a buffer for a cached file that was already initialized");
+	}
+	file->data = std::shared_ptr<char>(new char[size], std::default_delete<char[]>());
+	file->capacity = size;
+}
+
+void CachedFileHandle::GrowBuffer(idx_t new_capacity, idx_t bytes_to_copy) {
+	// copy shared ptr to old data
+	auto old_data = file->data;
+	// allocate new buffer that can hold the new capacity
+	AllocateBuffer(new_capacity);
+	// copy the old data
+	Write(old_data.get(), bytes_to_copy);
+}
+
+void CachedFileHandle::Write(const char *buffer, idx_t length, idx_t offset) {
+	//! Only write to non-initialized files with a lock;
+	D_ASSERT(!file->initialized && lock);
+	memcpy(file->data.get() + offset, buffer, length);
+}
+
+void HTTPState::Reset() {
+	// Reset Counters
+	head_count = 0;
+	get_count = 0;
+	put_count = 0;
+	post_count = 0;
+	total_bytes_received = 0;
+	total_bytes_sent = 0;
+
+	// Reset cached files
+	cached_files.clear();
+}
+
+shared_ptr<HTTPState> HTTPState::TryGetState(FileOpener *opener) {
+	auto client_context = FileOpener::TryGetClientContext(opener);
+	if (client_context) {
+		return client_context->client_data->http_state;
+	}
+	return nullptr;
+}
+
+//! Get cache entry, create if not exists
+shared_ptr<CachedFile> &HTTPState::GetCachedFile(const string &path) {
+	lock_guard<mutex> lock(cached_files_mutex);
+	auto &cache_entry_ref = cached_files[path];
+	if (!cache_entry_ref) {
+		cache_entry_ref = make_shared<CachedFile>();
+	}
+	return cache_entry_ref;
+}
+
+} // namespace duckdb

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

@@ -73,7 +73,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayDistinctFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayFilterFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArraySliceFun),
+	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySliceFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySortFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayTransformFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayUniqueFun),
@@ -200,7 +200,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(ListFilterFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ListPackFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION(ListSliceFun),
+	DUCKDB_SCALAR_FUNCTION_SET(ListSliceFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListSortFun),
 	DUCKDB_SCALAR_FUNCTION(ListTransformFun),
 	DUCKDB_SCALAR_FUNCTION(ListUniqueFun),

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

@@ -1,14 +1,62 @@
 #include "duckdb/core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/swap.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
 
+struct ListSliceBindData : public FunctionData {
+	ListSliceBindData(const LogicalType &return_type_p, bool begin_is_empty_p, bool end_is_empty_p)
+	    : return_type(return_type_p), begin_is_empty(begin_is_empty_p), end_is_empty(end_is_empty_p) {
+	}
+	~ListSliceBindData() override;
+
+	LogicalType return_type;
+
+	bool begin_is_empty;
+	bool end_is_empty;
+
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
+};
+
+ListSliceBindData::~ListSliceBindData() {
+}
+
+bool ListSliceBindData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ListSliceBindData>();
+	return return_type == other.return_type && begin_is_empty == other.begin_is_empty &&
+	       end_is_empty == other.end_is_empty;
+}
+
+unique_ptr<FunctionData> ListSliceBindData::Copy() const {
+	return make_uniq<ListSliceBindData>(return_type, begin_is_empty, end_is_empty);
+}
+
+template <typename INDEX_TYPE>
+static int CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
+	if (step < 0) {
+		step = abs(step);
+	}
+	if (step == 0 && svalid) {
+		throw InvalidInputException("Slice step cannot be zero");
+	}
+	if (step == 1) {
+		return end - begin;
+	} else if (static_cast<idx_t>(step) >= (end - begin)) {
+		return 1;
+	}
+	if ((end - begin) % step != 0) {
+		return (end - begin) / step + 1;
+	}
+	return (end - begin) / step;
+}
+
 template <typename INPUT_TYPE, typename INDEX_TYPE>
 INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
 	return 0;
@@ -20,33 +68,44 @@ int64_t ValueLength(const list_entry_t &value) {
 }
 
 template <>
-int32_t ValueLength(const string_t &value) {
-	return LengthFun::Length<string_t, int32_t>(value);
+int64_t ValueLength(const string_t &value) {
+	return LengthFun::Length<string_t, int64_t>(value);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
-	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
+static void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
 	if (index < 0) {
-		if (index < -length) {
-			return false;
-		}
+		index = (!is_min) ? index + 1 : index;
 		index = length + index;
+		return;
 	} else if (index > length) {
 		index = length;
 	}
-	return true;
+	return;
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end, bool begin_valid, bool end_valid) {
+static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
 	// Clamp offsets
-	begin = begin_valid ? begin : 0;
-	begin = (begin > 0) ? begin - 1 : begin;
-	end = end_valid ? end : ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (!ClampIndex(begin, value) || !ClampIndex(end, value)) {
-		return false;
+	begin = (begin != 0 && begin != (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) ? begin - 1 : begin;
+
+	bool is_min = false;
+	if (begin == (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) {
+		begin++;
+		is_min = true;
+	}
+
+	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
+	if (begin < 0 && -begin > length && end < 0 && -end > length) {
+		begin = 0;
+		end = 0;
+		return true;
+	}
+	if (begin < 0 && -begin > length) {
+		begin = 0;
 	}
+	ClampIndex(begin, value, length, is_min);
+	ClampIndex(end, value, length, false);
 	end = MaxValue<INDEX_TYPE>(begin, end);
 
 	return true;
@@ -65,108 +124,262 @@ list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64
 }
 
 template <>
-string_t SliceValue(Vector &result, string_t input, int32_t begin, int32_t end) {
+string_t SliceValue(Vector &result, string_t input, int64_t begin, int64_t end) {
 	// one-based - zero has strange semantics
 	return SubstringFun::SubstringUnicode(result, input, begin + 1, end - begin);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const idx_t count) {
-	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto rdata = ConstantVector::GetData<INPUT_TYPE>(result);
-		auto sdata = ConstantVector::GetData<INPUT_TYPE>(s);
-		auto bdata = ConstantVector::GetData<INDEX_TYPE>(b);
-		auto edata = ConstantVector::GetData<INDEX_TYPE>(e);
-
-		auto sliced = sdata[0];
-		auto begin = bdata[0];
-		auto end = edata[0];
-
-		auto svalid = !ConstantVector::IsNull(s);
-		auto bvalid = !ConstantVector::IsNull(b);
-		auto evalid = !ConstantVector::IsNull(e);
-
-		// Try to slice
-		if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			rdata[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-		}
+INPUT_TYPE SliceValueWithSteps(Vector &result, SelectionVector &sel, INPUT_TYPE input, INDEX_TYPE begin, INDEX_TYPE end,
+                               INDEX_TYPE step, idx_t &sel_idx) {
+	return input;
+}
+
+template <>
+list_entry_t SliceValueWithSteps(Vector &result, SelectionVector &sel, list_entry_t input, int64_t begin, int64_t end,
+                                 int64_t step, idx_t &sel_idx) {
+	if (end - begin == 0) {
+		input.length = 0;
+		input.offset = sel_idx;
+		return input;
+	}
+	input.length = CalculateSliceLength(begin, end, step, true);
+	idx_t child_idx = input.offset + begin;
+	if (step < 0) {
+		child_idx = input.offset + end - 1;
+	}
+	input.offset = sel_idx;
+	for (idx_t i = 0; i < input.length; i++) {
+		sel.set_index(sel_idx, child_idx);
+		child_idx += step;
+		sel_idx++;
+	}
+	return input;
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
+                                 optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
+                                 idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
+                                 bool end_is_empty) {
+	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
+	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
+	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
+	auto end_data = ConstantVector::GetData<INDEX_TYPE>(end_vector);
+	auto step_data = step_vector ? ConstantVector::GetData<INDEX_TYPE>(*step_vector) : nullptr;
+
+	auto str = str_data[0];
+	auto begin = begin_is_empty ? 0 : begin_data[0];
+	auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end_data[0];
+	auto step = step_data ? step_data[0] : 1;
+
+	if (step < 0) {
+		swap(begin, end);
+		begin = end_is_empty ? 0 : begin;
+		end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end;
+	}
+
+	auto str_valid = !ConstantVector::IsNull(str_vector);
+	auto begin_valid = !ConstantVector::IsNull(begin_vector);
+	auto end_valid = !ConstantVector::IsNull(end_vector);
+	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
+
+	// Clamp offsets
+	bool clamp_result = false;
+	if (str_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+		clamp_result = ClampSlice(str, begin, end);
+	}
+
+	auto sel_length = 0;
+	if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) {
+		sel_length = CalculateSliceLength(begin, end, step, step_valid);
+		sel.Initialize(sel_length);
+	}
+
+	// Try to slice
+	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+		ConstantVector::SetNull(result, true);
+	} else if (step == 1) {
+		result_data[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, str, begin, end);
 	} else {
-		UnifiedVectorFormat sdata, bdata, edata;
+		result_data[0] = SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, str, begin, end, step, sel_idx);
+	}
+
+	if (step_vector && step != 0 && end - begin > 0) {
+		result_child_vector->Slice(sel, sel_length);
+	}
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
+                             optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
+                             optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
+	UnifiedVectorFormat list_data, begin_data, end_data, step_data;
+	idx_t sel_length = 0;
 
-		s.ToUnifiedFormat(count, sdata);
-		b.ToUnifiedFormat(count, bdata);
-		e.ToUnifiedFormat(count, edata);
+	list_vector.ToUnifiedFormat(count, list_data);
+	begin_vector.ToUnifiedFormat(count, begin_data);
+	end_vector.ToUnifiedFormat(count, end_data);
+	if (step_vector) {
+		step_vector->ToUnifiedFormat(count, step_data);
+		sel.Initialize(ListVector::GetListSize(list_vector));
+	}
 
-		auto rdata = FlatVector::GetData<INPUT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
+	auto result_data = FlatVector::GetData<INPUT_TYPE>(result);
+	auto &result_mask = FlatVector::Validity(result);
 
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = sdata.sel->get_index(i);
-			auto bidx = bdata.sel->get_index(i);
-			auto eidx = edata.sel->get_index(i);
+	for (idx_t i = 0; i < count; ++i) {
+		auto list_idx = list_data.sel->get_index(i);
+		auto begin_idx = begin_data.sel->get_index(i);
+		auto end_idx = end_data.sel->get_index(i);
+		auto step_idx = step_vector ? step_data.sel->get_index(i) : 0;
 
-			auto sliced = (UnifiedVectorFormat::GetData<INPUT_TYPE>(sdata))[sidx];
-			auto begin = (UnifiedVectorFormat::GetData<INDEX_TYPE>(bdata))[bidx];
-			auto end = (UnifiedVectorFormat::GetData<INDEX_TYPE>(edata))[eidx];
+		auto sliced = reinterpret_cast<INPUT_TYPE *>(list_data.data)[list_idx];
+		auto begin = begin_is_empty ? 0 : reinterpret_cast<INDEX_TYPE *>(begin_data.data)[begin_idx];
+		auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced)
+		                        : reinterpret_cast<INDEX_TYPE *>(end_data.data)[end_idx];
+		auto step = step_vector ? reinterpret_cast<INDEX_TYPE *>(step_data.data)[step_idx] : 1;
 
-			auto svalid = sdata.validity.RowIsValid(sidx);
-			auto bvalid = bdata.validity.RowIsValid(bidx);
-			auto evalid = edata.validity.RowIsValid(eidx);
+		if (step < 0) {
+			swap(begin, end);
+			begin = end_is_empty ? 0 : begin;
+			end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced) : end;
+		}
+		auto list_valid = list_data.validity.RowIsValid(list_idx);
+		auto begin_valid = begin_data.validity.RowIsValid(begin_idx);
+		auto end_valid = end_data.validity.RowIsValid(end_idx);
+		auto step_valid = step_vector && step_data.validity.RowIsValid(step_idx);
 
-			// Try to slice
-			if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-				rmask.SetInvalid(i);
-			} else {
-				rdata[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-			}
+		bool clamp_result = false;
+		if (list_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+			clamp_result = ClampSlice(sliced, begin, end);
 		}
+
+		auto length = 0;
+		if (step_vector && step_valid && list_valid && begin_valid && end_valid && end - begin > 0) {
+			length = CalculateSliceLength(begin, end, step, step_valid);
+		}
+		sel_length += length;
+
+		if (!list_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+			result_mask.SetInvalid(i);
+		} else if (!step_vector) {
+			result_data[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
+		} else {
+			result_data[i] =
+			    SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, sliced, begin, end, step, sel_idx);
+		}
+	}
+	if (step_vector) {
+		SelectionVector new_sel(sel_length);
+		for (idx_t i = 0; i < sel_length; ++i) {
+			new_sel.set_index(i, sel.get_index(i));
+		}
+		result_child_vector->Slice(new_sel, sel_length);
+	}
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
+                         optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
+	optional_ptr<Vector> result_child_vector;
+	if (step_vector) {
+		result_child_vector = &ListVector::GetEntry(result);
 	}
 
+	SelectionVector sel;
+	idx_t sel_idx = 0;
+
+	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		ExecuteConstantSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                             count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                             end_is_empty);
+	} else {
+		ExecuteFlatSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                         count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                         end_is_empty);
+	}
 	result.Verify(count);
 }
 
 static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	D_ASSERT(args.data.size() == 3);
+	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
+	D_ASSERT(args.data.size() == 3 || args.data.size() == 4);
 	auto count = args.size();
 
-	Vector &s = args.data[0];
-	Vector &b = args.data[1];
-	Vector &e = args.data[2];
+	Vector &list_or_str_vector = args.data[0];
+	Vector &begin_vector = args.data[1];
+	Vector &end_vector = args.data[2];
+
+	optional_ptr<Vector> step_vector;
+	if (args.ColumnCount() == 4) {
+		step_vector = &args.data[3];
+	}
+
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListSliceBindData>();
+	auto begin_is_empty = info.begin_is_empty;
+	auto end_is_empty = info.end_is_empty;
 
 	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
 	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST:
+	case LogicalTypeId::LIST: {
 		// Share the value dictionary as we are just going to slice it
-		if (s.GetVectorType() != VectorType::FLAT_VECTOR && s.GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			s.Flatten(count);
+		if (list_or_str_vector.GetVectorType() != VectorType::FLAT_VECTOR &&
+		    list_or_str_vector.GetVectorType() != VectorType::CONSTANT_VECTOR) {
+			list_or_str_vector.Flatten(count);
 		}
-		ListVector::ReferenceEntry(result, s);
-		ExecuteSlice<list_entry_t, int64_t>(result, s, b, e, count);
+		ListVector::ReferenceEntry(result, list_or_str_vector);
+		ExecuteSlice<list_entry_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                    begin_is_empty, end_is_empty);
 		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteSlice<string_t, int32_t>(result, s, b, e, count);
+	}
+	case LogicalTypeId::VARCHAR: {
+		ExecuteSlice<string_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                begin_is_empty, end_is_empty);
 		break;
+	}
 	default:
 		throw NotImplementedException("Specifier type not implemented");
 	}
 }
 
+static bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
+	bool is_empty = false;
+	if (param->return_type.id() == LogicalTypeId::LIST) {
+		auto empty_list = make_uniq<BoundConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+		is_empty = param->Equals(*empty_list);
+		if (!is_empty) {
+			// if the param is not empty, the user has entered a list instead of a BIGINT
+			throw BinderException("The upper and lower bounds of the slice must be a BIGINT");
+		}
+	}
+	return is_empty;
+}
+
 static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 3);
+	D_ASSERT(arguments.size() == 3 || arguments.size() == 4);
+	D_ASSERT(bound_function.arguments.size() == 3 || bound_function.arguments.size() == 4);
+
 	switch (arguments[0]->return_type.id()) {
 	case LogicalTypeId::LIST:
 		// The result is the same type
 		bound_function.return_type = arguments[0]->return_type;
 		break;
 	case LogicalTypeId::VARCHAR:
-		// string slice returns a string, but can only accept 32 bit integers
+		// string slice returns a string
+		if (bound_function.arguments.size() == 4) {
+			throw NotImplementedException(
+			    "Slice with steps has not been implemented for string types, you can consider rewriting your query as "
+			    "follows:\n SELECT array_to_string((str_split(string, '')[begin:end:step], '');");
+		}
 		bound_function.return_type = arguments[0]->return_type;
-		bound_function.arguments[1] = LogicalType::INTEGER;
-		bound_function.arguments[2] = LogicalType::INTEGER;
+		for (idx_t i = 1; i < 3; i++) {
+			if (arguments[i]->return_type.id() != LogicalTypeId::LIST) {
+				bound_function.arguments[i] = LogicalType::BIGINT;
+			}
+		}
 		break;
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::UNKNOWN:
@@ -177,16 +390,29 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
 	}
 
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	bool begin_is_empty = CheckIfParamIsEmpty(arguments[1]);
+	if (!begin_is_empty) {
+		bound_function.arguments[1] = LogicalType::BIGINT;
+	}
+	bool end_is_empty = CheckIfParamIsEmpty(arguments[2]);
+	if (!end_is_empty) {
+		bound_function.arguments[2] = LogicalType::BIGINT;
+	}
+
+	return make_uniq<ListSliceBindData>(bound_function.return_type, begin_is_empty, end_is_empty);
 }
 
-ScalarFunction ListSliceFun::GetFunction() {
+ScalarFunctionSet ListSliceFun::GetFunctions() {
 	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
-	                   ArraySliceFunction, ArraySliceBind);
-	fun.varargs = LogicalType::ANY;
+	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
+	                   ArraySliceBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
+
+	ScalarFunctionSet set;
+	set.AddFunction(fun);
+	fun.arguments.push_back(LogicalType::BIGINT);
+	set.AddFunction(fun);
+	return set;
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2399"
+#define DUCKDB_VERSION "0.8.2-dev2509"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "20ad35b3fa"
+#define DUCKDB_SOURCE_ID "785b11edd5"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"