duckdb 0.8.2-dev37.0 → 0.8.2-dev3949.0

package/README.md

@@ -100,6 +100,13 @@ var stmt = con.prepare('select ?::INTEGER as fortytwo', function(err, stmt) {
 });
 ```
 
+## Supported Node versions
+We actively support only LTS and In-Support Node versions, as per July 2023, they are: Node 16, Node 18 and Node 20.
+Release schedule for Node.js can be checked here: https://github.com/nodejs/release#release-schedule.
+
+We currently bundle and test DuckDB also for Node 10, 12, 14, 17 and 19. We plan of going so going forward as long as the tooling supports it.
+As per July 2023, Node 15 has been removed from the supported versions.
+
 ## Development
 
 ### First install:

package/binding.gyp

@@ -13,7 +13,9 @@
                 "src/duckdb/ub_src_catalog_catalog_entry.cpp", 
                 "src/duckdb/ub_src_catalog_default.cpp", 
                 "src/duckdb/ub_src_common_adbc.cpp", 
+                "src/duckdb/ub_src_common_adbc_nanoarrow.cpp", 
                 "src/duckdb/ub_src_common.cpp", 
+                "src/duckdb/ub_src_common_arrow_appender.cpp", 
                 "src/duckdb/ub_src_common_arrow.cpp", 
                 "src/duckdb/ub_src_common_crypto.cpp", 
                 "src/duckdb/ub_src_common_enums.cpp", 
@@ -45,6 +47,7 @@
                 "src/duckdb/ub_src_core_functions_scalar_bit.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_blob.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_date.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_debug.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_enum.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_generic.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_list.cpp", 
@@ -60,6 +63,8 @@
                 "src/duckdb/ub_src_execution_index_art.cpp", 
                 "src/duckdb/ub_src_execution_nested_loop_join.cpp", 
                 "src/duckdb/ub_src_execution_operator_aggregate.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp", 
                 "src/duckdb/ub_src_execution_operator_filter.cpp", 
                 "src/duckdb/ub_src_execution_operator_helper.cpp", 
                 "src/duckdb/ub_src_execution_operator_join.cpp", 
@@ -75,8 +80,9 @@
                 "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_generic.cpp", 
+                "src/duckdb/ub_src_function_scalar_compressed_materialization.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
+                "src/duckdb/ub_src_function_scalar_generic.cpp", 
                 "src/duckdb/ub_src_function_scalar_list.cpp", 
                 "src/duckdb/ub_src_function_scalar_operators.cpp", 
                 "src/duckdb/ub_src_function_scalar_sequence.cpp", 
@@ -84,16 +90,19 @@
                 "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_table_arrow.cpp", 
                 "src/duckdb/ub_src_function_table.cpp", 
                 "src/duckdb/ub_src_function_table_system.cpp", 
                 "src/duckdb/ub_src_function_table_version.cpp", 
                 "src/duckdb/ub_src_main.cpp", 
                 "src/duckdb/ub_src_main_capi.cpp", 
                 "src/duckdb/ub_src_main_capi_cast.cpp", 
+                "src/duckdb/ub_src_main_chunk_scan_state.cpp", 
                 "src/duckdb/ub_src_main_extension.cpp", 
                 "src/duckdb/ub_src_main_relation.cpp", 
                 "src/duckdb/ub_src_main_settings.cpp", 
                 "src/duckdb/ub_src_optimizer.cpp", 
+                "src/duckdb/ub_src_optimizer_compressed_materialization.cpp", 
                 "src/duckdb/ub_src_optimizer_join_order.cpp", 
                 "src/duckdb/ub_src_optimizer_matcher.cpp", 
                 "src/duckdb/ub_src_optimizer_pullup.cpp", 
@@ -130,6 +139,8 @@
                 "src/duckdb/ub_src_storage_checkpoint.cpp", 
                 "src/duckdb/ub_src_storage_compression.cpp", 
                 "src/duckdb/ub_src_storage_compression_chimp.cpp", 
+                "src/duckdb/ub_src_storage_metadata.cpp", 
+                "src/duckdb/ub_src_storage_serialization.cpp", 
                 "src/duckdb/ub_src_storage_statistics.cpp", 
                 "src/duckdb/ub_src_storage_table.cpp", 
                 "src/duckdb/ub_src_transaction.cpp", 
@@ -202,6 +213,7 @@
                 "src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp", 
                 "src/duckdb/extension/parquet/parquet_extension.cpp", 
                 "src/duckdb/extension/parquet/column_writer.cpp", 
+                "src/duckdb/extension/parquet/serialize_parquet.cpp", 
                 "src/duckdb/extension/parquet/parquet_reader.cpp", 
                 "src/duckdb/extension/parquet/parquet_timestamp.cpp", 
                 "src/duckdb/extension/parquet/parquet_writer.cpp", 
@@ -237,28 +249,30 @@
                 "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_extension.cpp", 
-                "src/duckdb/extension/icu/./icu-list-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/extension/icu/./icu-datepart.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-strptime.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu_extension.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.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", 
                 "src/duckdb/extension/json/buffered_json_reader.cpp", 
+                "src/duckdb/extension/json/json_enums.cpp", 
                 "src/duckdb/extension/json/json_extension.cpp", 
                 "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/extension/json/json_deserializer.cpp", 
+                "src/duckdb/extension/json/serialize_json.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 
@@ -298,10 +312,12 @@
             ], 
             "defines": [
                 "NAPI_DISABLE_CPP_EXCEPTIONS=1", 
-                "NAPI_VERSION=5", 
-                "BUILD_PARQUET_EXTENSION", 
-                "BUILD_ICU_EXTENSION", 
-                "BUILD_JSON_EXTENSION"
+                "NAPI_VERSION=6", 
+                "DUCKDB_EXTENSION_PARQUET_LINKED", 
+                "DUCKDB_EXTENSION_ICU_LINKED", 
+                "DUCKDB_EXTENSION_JSON_LINKED", 
+                "DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1", 
+                "DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1"
             ], 
             "cflags_cc": [
                 "-frtti", 

package/binding.gyp.in

@@ -17,7 +17,7 @@
             ],
             "defines": [
                 "NAPI_DISABLE_CPP_EXCEPTIONS=1",
-                "NAPI_VERSION=5",
+                "NAPI_VERSION=6",
                 "${DEFINES}"
             ],
             "cflags_cc": [

package/configure.py

@@ -20,7 +20,10 @@ scripts_dir = 'scripts'
 sys.path.append(scripts_dir)
 import package_build
 
-defines = ['BUILD_{}_EXTENSION'.format(ext.upper()) for ext in extensions]
+defines = ['DUCKDB_EXTENSION_{}_LINKED'.format(ext.upper()) for ext in extensions]
+
+# Autoloading is on by default for node distributions
+defines.extend(['DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1', 'DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1'])
 
 if os.environ.get('DUCKDB_NODE_BUILD_CACHE') == '1' and os.path.isfile(cache_file):
     with open(cache_file, 'rb') as f:
@@ -31,6 +34,7 @@ if os.environ.get('DUCKDB_NODE_BUILD_CACHE') == '1' and os.path.isfile(cache_fil
     windows_options = cache['windows_options']
     cflags = cache['cflags']
 elif 'DUCKDB_NODE_BINDIR' in os.environ:
+
     def find_library_path(libdir, libname):
         flist = os.listdir(libdir)
         for fname in flist:
@@ -38,6 +42,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             if os.path.isfile(fpath) and package_build.file_is_lib(fname, libname):
                 return fpath
         raise Exception(f"Failed to find library {libname} in {libdir}")
+
     # existing build
     existing_duckdb_dir = os.environ['DUCKDB_NODE_BINDIR']
     cflags = os.environ['DUCKDB_NODE_CFLAGS']
@@ -48,7 +53,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
 
     result_libraries = package_build.get_libraries(existing_duckdb_dir, libraries, extensions)
     libraries = []
-    for (libdir, libname) in result_libraries:
+    for libdir, libname in result_libraries:
         if libdir is None:
             continue
         libraries.append(find_library_path(libdir, libname))
@@ -72,7 +77,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             'include_list': include_list,
             'libraries': libraries,
             'cflags': cflags,
-            'windows_options': windows_options
+            'windows_options': windows_options,
         }
         with open(cache_file, 'wb+') as f:
             pickle.dump(cache, f)
@@ -90,9 +95,11 @@ else:
     windows_options = ['/GR']
     cflags = ['-frtti']
 
+
 def sanitize_path(x):
     return x.replace('\\', '/')
 
+
 source_list = [sanitize_path(x) for x in source_list]
 include_list = [sanitize_path(x) for x in include_list]
 libraries = [sanitize_path(x) for x in libraries]
@@ -100,6 +107,7 @@ libraries = [sanitize_path(x) for x in libraries]
 with open(gyp_in, 'r') as f:
     input_json = json.load(f)
 
+
 def replace_entries(node, replacement_map):
     if type(node) == type([]):
         for key in replacement_map.keys():

package/duckdb_extension_config.cmake

@@ -0,0 +1,10 @@
+################################################################################
+# NodeJS DuckDB extension config
+################################################################################
+#
+# This is the default extension configuration for NodeJS builds. Basically it means that all these extensions are
+# "baked in" to the NodeJS binaries Note that the configuration here is only when building Node using the main
+# CMakeLists.txt file with the `BUILD_R` variable.
+# TODO: unify this by making setup.py also use this configuration, making this the config for all Node builds
+duckdb_extension_load(json)
+duckdb_extension_load(icu)

package/package.json

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

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

@@ -198,7 +198,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 1);
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BindData &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindData>();
 		CalendarPtr calendar(info.calendar->clone());
 
 		auto end_date = Timestamp::GetCurrentTimestamp();
@@ -218,7 +218,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 2);
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BindData &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindData>();
 		CalendarPtr calendar(info.calendar->clone());
 
 		BinaryExecutor::Execute<TA, TB, TR>(args.data[0], args.data[1], result, args.size(), [&](TA left, TB right) {

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

@@ -5,6 +5,8 @@
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 
+#include "unicode/ucal.h"
+
 namespace duckdb {
 
 ICUDateFunc::BindData::BindData(const BindData &other)
@@ -34,10 +36,17 @@ ICUDateFunc::BindData::BindData(ClientContext &context) {
 	if (U_FAILURE(success)) {
 		throw Exception("Unable to create ICU calendar.");
 	}
+
+	//	Postgres always assumes times are given in the proleptic Gregorian calendar.
+	//	ICU defaults to the Gregorian change in 1582, so we reset the change to the minimum date
+	//	so that all dates are proleptic Gregorian.
+	//	The only error here is if we have a non-Gregorian calendar,
+	//	and we just ignore that and hope for the best...
+	ucal_setGregorianChange((UCalendar *)calendar.get(), U_DATE_MIN, &success); // NOLINT
 }
 
 bool ICUDateFunc::BindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const ICUDateFunc::BindData &)other_p;
+	auto &other = other_p.Cast<const BindData>();
 	return *calendar == *other.calendar;
 }
 

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

@@ -14,7 +14,8 @@
 namespace duckdb {
 
 struct ICUDatePart : public ICUDateFunc {
-	typedef int64_t (*part_adapter_t)(icu::Calendar *calendar, const uint64_t micros);
+	typedef int64_t (*part_bigint_t)(icu::Calendar *calendar, const uint64_t micros);
+	typedef double (*part_double_t)(icu::Calendar *calendar, const uint64_t micros);
 
 	// Date part adapters
 	static int64_t ExtractEra(icu::Calendar *calendar, const uint64_t micros) {
@@ -54,13 +55,13 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	static int64_t ExtractDayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_SUNDAY);
+		// [Sun(0), Sat(6)]
 		return ExtractField(calendar, UCAL_DAY_OF_WEEK) - UCAL_SUNDAY;
 	}
 
 	static int64_t ExtractISODayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_MONDAY);
-		return ExtractField(calendar, UCAL_DAY_OF_WEEK);
+		// [Mon(1), Sun(7)]
+		return 1 + (ExtractField(calendar, UCAL_DAY_OF_WEEK) + 7 - UCAL_MONDAY) % 7;
 	}
 
 	static int64_t ExtractWeek(icu::Calendar *calendar, const uint64_t micros) {
@@ -109,11 +110,8 @@ struct ICUDatePart : public ICUDateFunc {
 
 	static int64_t ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
 		UErrorCode status = U_ZERO_ERROR;
-		auto millis = calendar->getTime(status);
-		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
-		millis += ExtractField(calendar, UCAL_DST_OFFSET);
 		//	Truncate
-		return millis / Interval::MSECS_PER_SEC;
+		return calendar->getTime(status) / Interval::MSECS_PER_SEC;
 	}
 
 	static int64_t ExtractTimezone(icu::Calendar *calendar, const uint64_t micros) {
@@ -132,7 +130,26 @@ struct ICUDatePart : public ICUDateFunc {
 		return (secs % Interval::SECS_PER_HOUR) / Interval::SECS_PER_MINUTE;
 	}
 
-	static part_adapter_t PartCodeAdapterFactory(DatePartSpecifier part) {
+	//	PG uses doubles for JDs so we can only use them with other double types
+	static double ExtractJulianDay(icu::Calendar *calendar, const uint64_t micros) {
+		//	We need days + fraction
+		auto days = ExtractField(calendar, UCAL_JULIAN_DAY);
+		auto frac = ExtractHour(calendar, micros);
+
+		frac *= Interval::MINS_PER_HOUR;
+		frac += ExtractMinute(calendar, micros);
+
+		frac *= Interval::MICROS_PER_MINUTE;
+		frac += ExtractMicrosecond(calendar, micros);
+
+		double result = frac;
+		result /= Interval::MICROS_PER_DAY;
+		result += days;
+
+		return result;
+	}
+
+	static part_bigint_t PartCodeBigintFactory(DatePartSpecifier part) {
 		switch (part) {
 		case DatePartSpecifier::YEAR:
 			return ExtractYear;
@@ -181,7 +198,16 @@ struct ICUDatePart : public ICUDateFunc {
 		case DatePartSpecifier::TIMEZONE_MINUTE:
 			return ExtractTimezoneMinute;
 		default:
-			throw Exception("Unsupported ICU extract adapter");
+			throw Exception("Unsupported ICU BIGINT extractor");
+		}
+	}
+
+	static part_double_t PartCodeDoubleFactory(DatePartSpecifier part) {
+		switch (part) {
+		case DatePartSpecifier::JULIAN_DAY:
+			return ExtractJulianDay;
+		default:
+			throw Exception("Unsupported ICU DOUBLE extractor");
 		}
 	}
 
@@ -200,13 +226,18 @@ struct ICUDatePart : public ICUDateFunc {
 
 		calendar->set(UCAL_DATE, dd);
 
-		return Date::EpochToDate(ExtractEpoch(calendar, 0));
+		//	Offset to UTC
+		auto millis = calendar->getTime(status);
+		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
+		millis += ExtractField(calendar, UCAL_DST_OFFSET);
+
+		return Date::EpochToDate(millis / Interval::MSECS_PER_SEC);
 	}
 
 	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
 		const auto mm = ExtractMonth(calendar, micros) - 1;
 		if (mm == 12) {
-			return "Undecember";
+			return "Undecimber";
 		}
 		return Date::MONTH_NAMES[mm];
 	}
@@ -271,7 +302,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &date_arg = args.data[1];
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BIND_TYPE>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -280,7 +311,7 @@ struct ICUDatePart : public ICUDateFunc {
 		    [&](string_t specifier, INPUT_TYPE input, ValidityMask &mask, idx_t idx) {
 			    if (Timestamp::IsFinite(input)) {
 				    const auto micros = SetTime(calendar, input);
-				    auto adapter = PartCodeAdapterFactory(GetDatePartSpecifier(specifier.GetString()));
+				    auto adapter = PartCodeBigintFactory(GetDatePartSpecifier(specifier.GetString()));
 				    return adapter(calendar, micros);
 			    } else {
 				    mask.SetInvalid(idx);
@@ -289,11 +320,37 @@ struct ICUDatePart : public ICUDateFunc {
 		    });
 	}
 
+	struct BindStructData : public BindData {
+		using part_codes_t = vector<DatePartSpecifier>;
+		using bigints_t = vector<part_bigint_t>;
+		using doubles_t = vector<part_double_t>;
+
+		BindStructData(ClientContext &context, part_codes_t &part_codes_p, bigints_t &bigints_p, doubles_t &doubles_p)
+		    : BindData(context), part_codes(part_codes_p), bigints(bigints_p), doubles(doubles_p) {
+		}
+		BindStructData(const BindStructData &other)
+		    : BindData(other), part_codes(other.part_codes), bigints(other.bigints), doubles(other.doubles) {
+		}
+
+		part_codes_t part_codes;
+		bigints_t bigints;
+		doubles_t doubles;
+
+		bool Equals(const FunctionData &other_p) const override {
+			const auto &other = other_p.Cast<BindStructData>();
+			return BindData::Equals(other_p) && part_codes == other.part_codes && bigints == other.bigints &&
+			       doubles == other.doubles;
+		}
+
+		duckdb::unique_ptr<FunctionData> Copy() const override {
+			return make_uniq<BindStructData>(*this);
+		}
+	};
+
 	template <typename INPUT_TYPE>
 	static void StructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-		using BIND_TYPE = BindAdapterData<int64_t>;
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindStructData>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -316,9 +373,15 @@ struct ICUDatePart : public ICUDateFunc {
 					auto &child_entry = child_entries[col];
 					if (is_finite) {
 						ConstantVector::SetNull(*child_entry, false);
-						auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
-						auto adapter = info.adapters[col];
-						pdata[0] = adapter(calendar, micros);
+						if (IsBigintDatepart(info.part_codes[col])) {
+							auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
+							auto adapter = info.bigints[col];
+							pdata[0] = adapter(calendar, micros);
+						} else {
+							auto pdata = ConstantVector::GetData<double>(*child_entry);
+							auto adapter = info.doubles[col];
+							pdata[0] = adapter(calendar, micros);
+						}
 					} else {
 						ConstantVector::SetNull(*child_entry, true);
 					}
@@ -348,9 +411,15 @@ struct ICUDatePart : public ICUDateFunc {
 						auto &child_entry = child_entries[col];
 						if (is_finite) {
 							FlatVector::Validity(*child_entry).SetValid(i);
-							auto pdata = FlatVector::GetData<int64_t>(*child_entry);
-							auto adapter = info.adapters[col];
-							pdata[i] = adapter(calendar, micros);
+							if (IsBigintDatepart(info.part_codes[col])) {
+								auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
+								auto adapter = info.bigints[col];
+								pdata[i] = adapter(calendar, micros);
+							} else {
+								auto pdata = ConstantVector::GetData<double>(*child_entry);
+								auto adapter = info.doubles[col];
+								pdata[i] = adapter(calendar, micros);
+							}
 						} else {
 							FlatVector::Validity(*child_entry).SetInvalid(i);
 						}
@@ -374,19 +443,54 @@ struct ICUDatePart : public ICUDateFunc {
 		return make_uniq<BIND_TYPE>(context, adapter);
 	}
 
-	static duckdb::unique_ptr<FunctionData> BindDatePart(ClientContext &context, ScalarFunction &bound_function,
-	                                                     vector<duckdb::unique_ptr<Expression>> &arguments) {
+	static duckdb::unique_ptr<FunctionData> BindUnaryDatePart(ClientContext &context, ScalarFunction &bound_function,
+	                                                          vector<duckdb::unique_ptr<Expression>> &arguments) {
+		const auto part_code = GetDatePartSpecifier(bound_function.name);
+		if (IsBigintDatepart(part_code)) {
+			using data_t = BindAdapterData<int64_t>;
+			auto adapter = PartCodeBigintFactory(part_code);
+			return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		} else {
+			using data_t = BindAdapterData<double>;
+			auto adapter = PartCodeDoubleFactory(part_code);
+			return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		}
+	}
+
+	static duckdb::unique_ptr<FunctionData> BindBinaryDatePart(ClientContext &context, ScalarFunction &bound_function,
+	                                                           vector<duckdb::unique_ptr<Expression>> &arguments) {
+		//	If we are only looking for Julian Days, then patch in the unary function.
+		do {
+			if (arguments[0]->HasParameter() || !arguments[0]->IsFoldable()) {
+				break;
+			}
+
+			Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
+			if (part_value.IsNull()) {
+				break;
+			}
+
+			const auto part_name = part_value.ToString();
+			const auto part_code = GetDatePartSpecifier(part_name);
+			if (IsBigintDatepart(part_code)) {
+				break;
+			}
+
+			arguments.erase(arguments.begin());
+			bound_function.arguments.erase(bound_function.arguments.begin());
+			bound_function.name = part_name;
+			bound_function.return_type = LogicalType::DOUBLE;
+			bound_function.function = UnaryTimestampFunction<timestamp_t, double>;
+
+			return BindUnaryDatePart(context, bound_function, arguments);
+		} while (false);
+
 		using data_t = BindAdapterData<int64_t>;
-		auto adapter =
-		    (arguments.size() == 1) ? PartCodeAdapterFactory(GetDatePartSpecifier(bound_function.name)) : nullptr;
-		return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		return BindAdapter<data_t>(context, bound_function, arguments, nullptr);
 	}
 
 	static duckdb::unique_ptr<FunctionData> BindStruct(ClientContext &context, ScalarFunction &bound_function,
 	                                                   vector<duckdb::unique_ptr<Expression>> &arguments) {
-		using data_t = BindAdapterData<int64_t>;
-		using adapters_t = data_t::adapters_t;
-
 		// collect names and deconflict, construct return type
 		if (arguments[0]->HasParameter()) {
 			throw ParameterNotResolvedException();
@@ -397,7 +501,9 @@ struct ICUDatePart : public ICUDateFunc {
 
 		case_insensitive_set_t name_collision_set;
 		child_list_t<LogicalType> struct_children;
-		adapters_t adapters;
+		BindStructData::part_codes_t part_codes;
+		BindStructData::bigints_t bigints;
+		BindStructData::doubles_t doubles;
 
 		Value parts_list = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
 		if (parts_list.type().id() == LogicalTypeId::LIST) {
@@ -405,7 +511,11 @@ struct ICUDatePart : public ICUDateFunc {
 			if (list_children.empty()) {
 				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
 			}
-			for (const auto &part_value : list_children) {
+
+			bigints.resize(list_children.size(), nullptr);
+			doubles.resize(list_children.size(), nullptr);
+			for (size_t col = 0; col < list_children.size(); ++col) {
+				const auto &part_value = list_children[col];
 				if (part_value.IsNull()) {
 					throw BinderException("NULL struct entry name in %s", bound_function.name);
 				}
@@ -415,8 +525,14 @@ struct ICUDatePart : public ICUDateFunc {
 					throw BinderException("Duplicate struct entry name \"%s\" in %s", part_name, bound_function.name);
 				}
 				name_collision_set.insert(part_name);
-				adapters.emplace_back(PartCodeAdapterFactory(part_code));
-				struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+				part_codes.emplace_back(part_code);
+				if (IsBigintDatepart(part_code)) {
+					bigints[col] = PartCodeBigintFactory(part_code);
+					struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+				} else {
+					doubles[col] = PartCodeDoubleFactory(part_code);
+					struct_children.emplace_back(make_pair(part_name, LogicalType::DOUBLE));
+				}
 			}
 		} else {
 			throw BinderException("%s can only take constant lists of part names", bound_function.name);
@@ -424,7 +540,7 @@ struct ICUDatePart : public ICUDateFunc {
 
 		Function::EraseArgument(bound_function, arguments, 0);
 		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
-		return make_uniq<data_t>(context, adapters);
+		return make_uniq<BindStructData>(context, part_codes, bigints, doubles);
 	}
 
 	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
@@ -438,15 +554,18 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
-	static ScalarFunction GetUnaryPartCodeFunction(const LogicalType &temporal_type) {
-		return ScalarFunction({temporal_type}, LogicalType::BIGINT, UnaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>,
-		                      BindDatePart);
+	static ScalarFunction GetUnaryPartCodeFunction(const LogicalType &temporal_type,
+	                                               const LogicalType &result_type = LogicalType::BIGINT) {
+		return ScalarFunction({temporal_type}, result_type, UnaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>,
+		                      BindUnaryDatePart);
 	}
 
-	static void AddUnaryPartCodeFunctions(const string &name, ClientContext &context) {
+	template <typename RESULT_TYPE = int64_t>
+	static void AddUnaryPartCodeFunctions(const string &name, ClientContext &context,
+	                                      const LogicalType &result_type = LogicalType::BIGINT) {
 		auto &catalog = Catalog::GetSystemCatalog(context);
 		ScalarFunctionSet set(name);
-		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, int64_t>(LogicalType::TIMESTAMP_TZ));
+		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, RESULT_TYPE>(LogicalType::TIMESTAMP_TZ, result_type));
 		CreateScalarFunctionInfo func_info(set);
 		catalog.AddFunction(context, func_info);
 	}
@@ -454,7 +573,7 @@ struct ICUDatePart : public ICUDateFunc {
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static ScalarFunction GetBinaryPartCodeFunction(const LogicalType &temporal_type) {
 		return ScalarFunction({LogicalType::VARCHAR, temporal_type}, LogicalType::BIGINT,
-		                      BinaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>, BindDatePart);
+		                      BinaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>, BindBinaryDatePart);
 	}
 
 	template <typename INPUT_TYPE>
@@ -559,6 +678,8 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", context);
 
+	ICUDatePart::AddUnaryPartCodeFunctions<double>("julian", context, LogicalType::DOUBLE);
+
 	//  register combinations
 	ICUDatePart::AddUnaryPartCodeFunctions("yearweek", context); //  Note this is ISO year and week