duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

package/binding.gyp

@@ -57,6 +57,7 @@
                 "src/duckdb/ub_src_function.cpp", 
                 "src/duckdb/ub_src_function_cast.cpp", 
                 "src/duckdb/ub_src_function_pragma.cpp", 
+                "src/duckdb/ub_src_function_scalar_bit.cpp", 
                 "src/duckdb/ub_src_function_scalar_blob.cpp", 
                 "src/duckdb/ub_src_function_scalar_date.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
@@ -68,6 +69,7 @@
                 "src/duckdb/ub_src_function_scalar_operators.cpp", 
                 "src/duckdb/ub_src_function_scalar_sequence.cpp", 
                 "src/duckdb/ub_src_function_scalar_string.cpp", 
+                "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
                 "src/duckdb/ub_src_function_scalar_struct.cpp", 
                 "src/duckdb/ub_src_function_scalar_system.cpp", 
                 "src/duckdb/ub_src_function_scalar_union.cpp", 
@@ -222,16 +224,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 
-                "src/duckdb/extension/icu/./icu-extension.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 
@@ -240,6 +244,7 @@
                 "src/duckdb/extension/json/json_common.cpp", 
                 "src/duckdb/extension/json/json_functions.cpp", 
                 "src/duckdb/extension/json/json_scan.cpp", 
+                "src/duckdb/extension/json/json_serializer.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 

package/lib/duckdb.d.ts

@@ -4,14 +4,67 @@
  * on Node.JS API
  */
 
+export type ExceptionType =
+    | "Invalid"          // invalid type
+    | "Out of Range"     // value out of range error
+    | "Conversion"       // conversion/casting error
+    | "Unknown Type"     // unknown type
+    | "Decimal"          // decimal related
+    | "Mismatch Type"    // type mismatch
+    | "Divide by Zero"   // divide by 0
+    | "Object Size"      // object size exceeded
+    | "Invalid type"     // incompatible for operation
+    | "Serialization"    // serialization
+    | "TransactionContext" // transaction management
+    | "Not implemented"  // method not implemented
+    | "Expression"       // expression parsing
+    | "Catalog"          // catalog related
+    | "Parser"           // parser related
+    | "Binder"           // binder related
+    | "Planner"          // planner related
+    | "Scheduler"        // scheduler related
+    | "Executor"         // executor related
+    | "Constraint"       // constraint related
+    | "Index"            // index related
+    | "Stat"             // stat related
+    | "Connection"       // connection related
+    | "Syntax"           // syntax related
+    | "Settings"         // settings related
+    | "Optimizer"        // optimizer related
+    | "NullPointer"      // nullptr exception
+    | "IO"               // IO exception
+    | "INTERRUPT"        // interrupt
+    | "FATAL"            // Fatal exceptions are non-recoverable and render the entire DB in an unusable state
+    | "INTERNAL"         // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
+    | "Invalid Input"    // Input or arguments error
+    | "Out of Memory"    // out of memory
+    | "Permission"       // insufficient permissions
+    | "Parameter Not Resolved" // parameter types could not be resolved
+    | "Parameter Not Allowed"  // parameter types not allowed
+    | "Dependency"       // dependency
+    | "Unknown"
+    | "HTTP"
+    ;
+
 /**
  * Standard error shape for DuckDB errors
  */
-export interface DuckDbError extends Error {
+export interface _DuckDbError extends Error {
   errno: -1; // value of ERROR
   code: 'DUCKDB_NODEJS_ERROR';
+  errorType: ExceptionType;
+}
+
+export interface HttpError extends _DuckDbError {
+  errorType: 'HTTP';
+  statusCode: number;
+  response: string;
+  reason: string;
+  headers: Record<string, string>;
 }
 
+export type DuckDbError = HttpError | _DuckDbError;
+
 type Callback<T> = (err: DuckDbError | null, res: T) => void;
 
 export type RowData = {
@@ -47,7 +100,7 @@ export class Connection {
   unregister_udf(name: string, callback: Callback<any>): void;
 
   stream(sql: any, ...args: any[]): QueryResult;
-  arrowIPCStream(sql: any, ...args: any[]): IpcResultStreamIterator;
+  arrowIPCStream(sql: any, ...args: any[]): Promise<IpcResultStreamIterator>;
 
   register_buffer(name: string, array: ArrowIterable, force: boolean, callback?: Callback<void>): void;
   unregister_buffer(name: string, callback?: Callback<void>): void;

package/lib/duckdb.js

@@ -189,7 +189,7 @@ Connection.prototype.arrowIPCAll = function (sql) {
  * @arg sql
  * @param {...*} params
  * @param callback
- * @return IpcResultStreamIterator
+ * @return Promise<IpcResultStreamIterator>
  */
 Connection.prototype.arrowIPCStream = async function (sql) {
     const query = "SELECT * FROM to_arrow_ipc((" + sql + "));";
@@ -688,3 +688,22 @@ Statement.prototype.stream;
  * @returns sql contained in statement
  */
 Statement.prototype.sql;
+
+/**
+ * @typedef DuckDbError
+ * @type {object}
+ * @property {number} errno - -1 for DuckDB errors
+ * @property {string} message - Error message
+ * @property {string} code - 'DUCKDB_NODEJS_ERROR' for DuckDB errors
+ * @property {string} errorType - DuckDB error type code (eg, HTTP, IO, Catalog)
+ */
+
+/**
+ * @typedef HTTPError
+ * @type {object}
+ * @extends {DuckDbError}
+ * @property {number} statusCode - HTTP response status code
+ * @property {string} reason - HTTP response reason
+ * @property {string} response - HTTP response body
+ * @property {object} headers - HTTP headers
+ */

package/package.json

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

package/src/connection.cpp

@@ -388,8 +388,7 @@ struct ExecTask : public Task {
 	void Callback() override {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
-		callback.Value().MakeCallback(object.Value(),
-		                              {success ? env.Null() : Utils::CreateError(env, error.Message())});
+		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Utils::CreateError(env, error)});
 	};
 
 	std::string sql;

package/src/database.cpp

@@ -73,7 +73,7 @@ struct OpenTask : public Task {
 
 		std::vector<napi_value> args;
 		if (!success) {
-			args.push_back(Utils::CreateError(env, error.Message()));
+			args.push_back(Utils::CreateError(env, error));
 		} else {
 			args.push_back(env.Null());
 		}

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -13,6 +13,8 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
+#include "include/icu-list-range.hpp"
+#include "include/icu-table-range.hpp"
 #include "include/icu-strptime.hpp"
 #include "include/icu-timebucket.hpp"
 #include "include/icu-timezone.hpp"
@@ -266,6 +268,8 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateSubFunctions(*con.context);
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
+	RegisterICUTableRangeFunctions(*con.context);
+	RegisterICUListRangeFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
 	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);

package/src/duckdb/extension/icu/icu-list-range.cpp

@@ -0,0 +1,207 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/vector.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+
+namespace duckdb {
+
+struct ICUListRange : public ICUDateFunc {
+	template <bool INCLUSIVE_BOUND>
+	class RangeInfoStruct {
+	public:
+		explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
+			if (args.ColumnCount() == 3) {
+				args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
+				args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
+				args.data[2].ToUnifiedFormat(args.size(), vdata[2]);
+			} else {
+				throw InternalException("Unsupported number of parameters for range");
+			}
+		}
+
+		bool RowIsValid(idx_t row_idx) {
+			for (idx_t i = 0; i < args.ColumnCount(); i++) {
+				auto idx = vdata[i].sel->get_index(row_idx);
+				if (!vdata[i].validity.RowIsValid(idx)) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		timestamp_t StartListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[0].data;
+			auto idx = vdata[0].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		timestamp_t EndListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[1].data;
+			auto idx = vdata[1].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		interval_t ListIncrementValue(idx_t row_idx) {
+			auto data = (interval_t *)vdata[2].data;
+			auto idx = vdata[2].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		void GetListValues(idx_t row_idx, timestamp_t &start_value, timestamp_t &end_value,
+		                   interval_t &increment_value) {
+			start_value = StartListValue(row_idx);
+			end_value = EndListValue(row_idx);
+			increment_value = ListIncrementValue(row_idx);
+		}
+
+		uint64_t ListLength(idx_t row_idx, icu::Calendar *calendar) {
+			timestamp_t start_value;
+			timestamp_t end_value;
+			interval_t increment_value;
+			GetListValues(row_idx, start_value, end_value, increment_value);
+			return ListLength(start_value, end_value, increment_value, INCLUSIVE_BOUND, calendar);
+		}
+
+		void Increment(timestamp_t &input, interval_t increment, icu::Calendar *calendar) {
+			input = Add(calendar, input, increment);
+		}
+
+	private:
+		DataChunk &args;
+		UnifiedVectorFormat vdata[3];
+
+		uint64_t ListLength(timestamp_t start_value, timestamp_t end_value, interval_t increment_value,
+		                    bool inclusive_bound, icu::Calendar *calendar) {
+			bool is_positive = increment_value.months > 0 || increment_value.days > 0 || increment_value.micros > 0;
+			bool is_negative = increment_value.months < 0 || increment_value.days < 0 || increment_value.micros < 0;
+			if (!is_negative && !is_positive) {
+				// interval is 0: no result
+				return 0;
+			}
+			// We don't allow infinite bounds because they generate errors or infinite loops
+			if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
+				throw InvalidInputException("Interval infinite bounds not supported");
+			}
+
+			if (is_negative && is_positive) {
+				// we don't allow a mix of
+				throw InvalidInputException("Interval with mix of negative/positive entries not supported");
+			}
+			if (start_value > end_value && is_positive) {
+				return 0;
+			}
+			if (start_value < end_value && is_negative) {
+				return 0;
+			}
+			int64_t total_values = 0;
+			if (is_negative) {
+				// negative interval, start_value is going down
+				while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			} else {
+				// positive interval, start_value is going up
+				while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			}
+			return total_values;
+		}
+	};
+
+	template <bool INCLUSIVE_BOUND>
+	static void ICUListRangeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+		D_ASSERT(args.ColumnCount() == 3);
+
+		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &bind_info = (BindData &)*func_expr.bind_info;
+		CalendarPtr calendar_ptr(bind_info.calendar->clone());
+		auto calendar = calendar_ptr.get();
+
+		RangeInfoStruct<INCLUSIVE_BOUND> info(args);
+		idx_t args_size = 1;
+		auto result_type = VectorType::CONSTANT_VECTOR;
+		for (idx_t i = 0; i < args.ColumnCount(); i++) {
+			if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
+				args_size = args.size();
+				result_type = VectorType::FLAT_VECTOR;
+				break;
+			}
+		}
+		auto list_data = FlatVector::GetData<list_entry_t>(result);
+		auto &result_validity = FlatVector::Validity(result);
+		int64_t total_size = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			if (!info.RowIsValid(i)) {
+				result_validity.SetInvalid(i);
+				list_data[i].offset = total_size;
+				list_data[i].length = 0;
+			} else {
+				list_data[i].offset = total_size;
+				list_data[i].length = info.ListLength(i, calendar);
+				total_size += list_data[i].length;
+			}
+		}
+
+		// now construct the child vector of the list
+		ListVector::Reserve(result, total_size);
+		auto range_data = FlatVector::GetData<timestamp_t>(ListVector::GetEntry(result));
+		idx_t total_idx = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			timestamp_t start_value = info.StartListValue(i);
+			interval_t increment = info.ListIncrementValue(i);
+
+			timestamp_t range_value = start_value;
+			for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
+				if (range_idx > 0) {
+					info.Increment(range_value, increment, calendar);
+				}
+				range_data[total_idx++] = range_value;
+			}
+		}
+
+		ListVector::SetListSize(result, total_size);
+		result.SetVectorType(result_type);
+
+		result.Verify(args.size());
+	}
+
+	static void AddICUListRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		ScalarFunctionSet range("range");
+		range.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                 LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<false>,
+		                                 Bind));
+		CreateScalarFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		ScalarFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                   LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<true>, Bind));
+		CreateScalarFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUListRangeFunctions(ClientContext &context) {
+	ICUListRange::AddICUListRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/icu-table-range.cpp

@@ -0,0 +1,194 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+#include "unicode/calendar.h"
+
+namespace duckdb {
+
+struct ICUTableRange {
+	using CalendarPtr = unique_ptr<icu::Calendar>;
+
+	struct BindData : public TableFunctionData {
+		BindData(const BindData &other)
+		    : TableFunctionData(other), tz_setting(other.tz_setting), cal_setting(other.cal_setting),
+		      calendar(other.calendar->clone()), start(other.start), end(other.end), increment(other.increment),
+		      inclusive_bound(other.inclusive_bound), greater_than_check(other.greater_than_check) {
+		}
+
+		explicit BindData(ClientContext &context) {
+			Value tz_value;
+			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
+				tz_setting = tz_value.ToString();
+			}
+			auto tz = icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_setting)));
+
+			string cal_id("@calendar=");
+			Value cal_value;
+			if (context.TryGetCurrentSetting("Calendar", cal_value)) {
+				cal_setting = cal_value.ToString();
+				cal_id += cal_setting;
+			} else {
+				cal_id += "gregorian";
+			}
+
+			icu::Locale locale(cal_id.c_str());
+
+			UErrorCode success = U_ZERO_ERROR;
+			calendar.reset(icu::Calendar::createInstance(tz, locale, success));
+			if (U_FAILURE(success)) {
+				throw Exception("Unable to create ICU calendar.");
+			}
+		}
+
+		string tz_setting;
+		string cal_setting;
+		CalendarPtr calendar;
+
+		timestamp_t start;
+		timestamp_t end;
+		interval_t increment;
+		bool inclusive_bound;
+		bool greater_than_check;
+
+		bool Equals(const FunctionData &other_p) const override {
+			auto &other = (const BindData &)other_p;
+			return other.start == start && other.end == end && other.increment == increment &&
+			       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check &&
+			       *calendar == *other.calendar;
+		}
+
+		unique_ptr<FunctionData> Copy() const override {
+			return make_unique<BindData>(*this);
+		}
+
+		bool Finished(timestamp_t current_value) {
+			if (greater_than_check) {
+				if (inclusive_bound) {
+					return current_value > end;
+				} else {
+					return current_value >= end;
+				}
+			} else {
+				if (inclusive_bound) {
+					return current_value < end;
+				} else {
+					return current_value <= end;
+				}
+			}
+		}
+	};
+
+	template <bool GENERATE_SERIES>
+	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
+	                                     vector<LogicalType> &return_types, vector<string> &names) {
+		auto result = make_unique<BindData>(context);
+
+		auto &inputs = input.inputs;
+		D_ASSERT(inputs.size() == 3);
+		result->start = inputs[0].GetValue<timestamp_t>();
+		result->end = inputs[1].GetValue<timestamp_t>();
+		result->increment = inputs[2].GetValue<interval_t>();
+
+		// Infinities either cause errors or infinite loops, so just ban them
+		if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+			throw BinderException("RANGE with infinite bounds is not supported");
+		}
+
+		if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
+			throw BinderException("interval cannot be 0!");
+		}
+		// all elements should point in the same direction
+		if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
+			if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
+				throw BinderException("RANGE with composite interval that has mixed signs is not supported");
+			}
+			result->greater_than_check = true;
+			if (result->start > result->end) {
+				throw BinderException(
+				    "start is bigger than end, but increment is positive: cannot generate infinite series");
+			}
+		} else {
+			result->greater_than_check = false;
+			if (result->start < result->end) {
+				throw BinderException(
+				    "start is smaller than end, but increment is negative: cannot generate infinite series");
+			}
+		}
+		return_types.push_back(inputs[0].type());
+		if (GENERATE_SERIES) {
+			// generate_series has inclusive bounds on the RHS
+			result->inclusive_bound = true;
+			names.emplace_back("generate_series");
+		} else {
+			result->inclusive_bound = false;
+			names.emplace_back("range");
+		}
+		return std::move(result);
+	}
+
+	struct State : public GlobalTableFunctionState {
+		explicit State(timestamp_t start_p) : current_state(start_p) {
+		}
+
+		timestamp_t current_state;
+		bool finished = false;
+	};
+
+	static unique_ptr<GlobalTableFunctionState> Init(ClientContext &context, TableFunctionInitInput &input) {
+		auto &bind_data = (BindData &)*input.bind_data;
+		return make_unique<State>(bind_data.start);
+	}
+
+	static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+		auto &bind_data = (BindData &)*data_p.bind_data;
+		CalendarPtr calendar_ptr(bind_data.calendar->clone());
+		auto calendar = calendar_ptr.get();
+		auto &state = (State &)*data_p.global_state;
+		if (state.finished) {
+			return;
+		}
+
+		idx_t size = 0;
+		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+		while (true) {
+			data[size++] = state.current_state;
+			state.current_state = ICUDateFunc::Add(calendar, state.current_state, bind_data.increment);
+			if (bind_data.Finished(state.current_state)) {
+				state.finished = true;
+				break;
+			}
+			if (size >= STANDARD_VECTOR_SIZE) {
+				break;
+			}
+		}
+		output.SetCardinality(size);
+	}
+
+	static void AddICUTableRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		TableFunctionSet range("range");
+		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                ICUTableRangeFunction, Bind<false>, Init));
+		CreateTableFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		TableFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                  ICUTableRangeFunction, Bind<true>, Init));
+		CreateTableFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUTableRangeFunctions(ClientContext &context) {
+	ICUTableRange::AddICUTableRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-list-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUListRangeFunctions(ClientContext &context);
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-table-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUTableRangeFunctions(ClientContext &context);
+
+} // namespace duckdb