duckdb 0.9.3-dev2.0 → 0.10.0

package/.github/workflows/NodeJS.yml

@@ -114,7 +114,7 @@ jobs:
     strategy:
       matrix:
         target_arch: [ x64, arm64 ]
-        node: [ '12', '14', '16', '17', '18', '19', '20', '21']
+        node: [ '16', '17', '18', '19', '20', '21']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:

package/README.md

@@ -15,7 +15,7 @@ Then you can run a query:
 ```js
 db.all('SELECT 42 AS fortytwo', function(err, res) {
   if (err) {
-    throw err;
+    console.warn(err);
   }
   console.log(res[0].fortytwo)
 });
@@ -26,7 +26,7 @@ Other available methods are `each`, where the callback is invoked for each row,
 ```js
 db.all('SELECT ?::INTEGER AS fortytwo, ?::STRING as hello', 42, 'Hello, World', function(err, res) {
   if (err) {
-    throw err;
+    console.warn(err);
   }
   console.log(res[0].fortytwo)
   console.log(res[0].hello)
@@ -47,7 +47,7 @@ You can create multiple connections, each with their own transaction context.
 ```js
 con.all('SELECT 42 AS fortytwo', function(err, res) {
   if (err) {
-    throw err;
+    console.warn(err);
   }
   console.log(res[0].fortytwo)
 });
@@ -64,7 +64,7 @@ To execute this statement, you can call for example `all()` on the `stmt` object
 ```js
 stmt.all(42, function(err, res) {
   if (err) {
-    throw err;
+    console.warn(err);
   }
   console.log(res[0].fortytwo)
 });
@@ -81,7 +81,7 @@ for (var i = 0; i < 10; i++) {
 stmt.finalize();
 con.all('SELECT * FROM a', function(err, res) {
   if (err) {
-    throw err;
+    console.warn(err);
   }
   console.log(res)
 });
@@ -93,7 +93,7 @@ con.all('SELECT * FROM a', function(err, res) {
 var stmt = con.prepare('select ?::INTEGER as fortytwo', function(err, stmt) {
   stmt.all(42, function(err, res) {
     if (err) {
-      throw err;
+      console.warn(err);
     }
     console.log(res[0].fortytwo)
   });

package/binding.gyp

@@ -11,6 +11,7 @@
                 "src/utils.cpp", 
                 "src/duckdb/ub_src_catalog.cpp", 
                 "src/duckdb/ub_src_catalog_catalog_entry.cpp", 
+                "src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp", 
                 "src/duckdb/ub_src_catalog_default.cpp", 
                 "src/duckdb/ub_src_common_adbc.cpp", 
                 "src/duckdb/ub_src_common_adbc_nanoarrow.cpp", 
@@ -19,6 +20,7 @@
                 "src/duckdb/ub_src_common_arrow.cpp", 
                 "src/duckdb/ub_src_common_crypto.cpp", 
                 "src/duckdb/ub_src_common_enums.cpp", 
+                "src/duckdb/ub_src_common_exception.cpp", 
                 "src/duckdb/ub_src_common_operator.cpp", 
                 "src/duckdb/ub_src_common_progress_bar.cpp", 
                 "src/duckdb/ub_src_common_row_operations.cpp", 
@@ -44,6 +46,7 @@
                 "src/duckdb/ub_src_core_functions_aggregate_nested.cpp", 
                 "src/duckdb/ub_src_core_functions_aggregate_regression.cpp", 
                 "src/duckdb/ub_src_core_functions.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_array.cpp", 
                 "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", 
@@ -55,6 +58,7 @@
                 "src/duckdb/ub_src_core_functions_scalar_math.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_operators.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_random.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_secret.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_string.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_struct.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_union.cpp", 
@@ -64,8 +68,12 @@
                 "src/duckdb/ub_src_execution_index.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_buffer_manager.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp", 
                 "src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_util.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", 
@@ -97,11 +105,13 @@
                 "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_buffered_data.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_secret.cpp", 
                 "src/duckdb/ub_src_main_settings.cpp", 
                 "src/duckdb/ub_src_optimizer.cpp", 
                 "src/duckdb/ub_src_optimizer_compressed_materialization.cpp", 
@@ -138,6 +148,7 @@
                 "src/duckdb/ub_src_storage.cpp", 
                 "src/duckdb/ub_src_storage_buffer.cpp", 
                 "src/duckdb/ub_src_storage_checkpoint.cpp", 
+                "src/duckdb/ub_src_storage_compression_alp.cpp", 
                 "src/duckdb/ub_src_storage_compression.cpp", 
                 "src/duckdb/ub_src_storage_compression_chimp.cpp", 
                 "src/duckdb/ub_src_storage_metadata.cpp", 
@@ -148,6 +159,7 @@
                 "src/duckdb/src/verification/copied_statement_verifier.cpp", 
                 "src/duckdb/src/verification/deserialized_statement_verifier.cpp", 
                 "src/duckdb/src/verification/external_statement_verifier.cpp", 
+                "src/duckdb/src/verification/fetch_row_verifier.cpp", 
                 "src/duckdb/src/verification/no_operator_caching_verifier.cpp", 
                 "src/duckdb/src/verification/parsed_statement_verifier.cpp", 
                 "src/duckdb/src/verification/prepared_statement_verifier.cpp", 
@@ -181,6 +193,7 @@
                 "src/duckdb/third_party/re2/util/strutil.cc", 
                 "src/duckdb/third_party/hyperloglog/hyperloglog.cpp", 
                 "src/duckdb/third_party/hyperloglog/sds.cpp", 
+                "src/duckdb/third_party/skiplist/SkipList.cpp", 
                 "src/duckdb/third_party/fastpforlib/bitpacking.cpp", 
                 "src/duckdb/third_party/utf8proc/utf8proc.cpp", 
                 "src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp", 
@@ -194,10 +207,18 @@
                 "src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp", 
                 "src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp", 
                 "src/duckdb/third_party/libpg_query/src_common_keywords.cpp", 
+                "src/duckdb/third_party/mbedtls/library/aes.cpp", 
+                "src/duckdb/third_party/mbedtls/library/aria.cpp", 
                 "src/duckdb/third_party/mbedtls/library/asn1parse.cpp", 
                 "src/duckdb/third_party/mbedtls/library/base64.cpp", 
                 "src/duckdb/third_party/mbedtls/library/bignum.cpp", 
+                "src/duckdb/third_party/mbedtls/library/camellia.cpp", 
+                "src/duckdb/third_party/mbedtls/library/cipher.cpp", 
+                "src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp", 
                 "src/duckdb/third_party/mbedtls/library/constant_time.cpp", 
+                "src/duckdb/third_party/mbedtls/library/entropy.cpp", 
+                "src/duckdb/third_party/mbedtls/library/entropy_poll.cpp", 
+                "src/duckdb/third_party/mbedtls/library/gcm.cpp", 
                 "src/duckdb/third_party/mbedtls/library/md.cpp", 
                 "src/duckdb/third_party/mbedtls/library/oid.cpp", 
                 "src/duckdb/third_party/mbedtls/library/pem.cpp", 
@@ -211,15 +232,16 @@
                 "src/duckdb/third_party/mbedtls/library/sha256.cpp", 
                 "src/duckdb/third_party/mbedtls/library/sha512.cpp", 
                 "src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp", 
-                "src/duckdb/extension/parquet/parquet_extension.cpp", 
+                "src/duckdb/extension/parquet/column_reader.cpp", 
                 "src/duckdb/extension/parquet/column_writer.cpp", 
-                "src/duckdb/extension/parquet/serialize_parquet.cpp", 
+                "src/duckdb/extension/parquet/parquet_crypto.cpp", 
+                "src/duckdb/extension/parquet/parquet_extension.cpp", 
+                "src/duckdb/extension/parquet/parquet_metadata.cpp", 
                 "src/duckdb/extension/parquet/parquet_reader.cpp", 
+                "src/duckdb/extension/parquet/parquet_statistics.cpp", 
                 "src/duckdb/extension/parquet/parquet_timestamp.cpp", 
                 "src/duckdb/extension/parquet/parquet_writer.cpp", 
-                "src/duckdb/extension/parquet/column_reader.cpp", 
-                "src/duckdb/extension/parquet/parquet_statistics.cpp", 
-                "src/duckdb/extension/parquet/parquet_metadata.cpp", 
+                "src/duckdb/extension/parquet/serialize_parquet.cpp", 
                 "src/duckdb/extension/parquet/zstd_file_system.cpp", 
                 "src/duckdb/third_party/parquet/parquet_constants.cpp", 
                 "src/duckdb/third_party/parquet/parquet_types.cpp", 
@@ -286,6 +308,7 @@
                 "src/duckdb/third_party/utf8proc/include", 
                 "src/duckdb/third_party/utf8proc", 
                 "src/duckdb/third_party/hyperloglog", 
+                "src/duckdb/third_party/skiplist", 
                 "src/duckdb/third_party/fastpforlib", 
                 "src/duckdb/third_party/tdigest", 
                 "src/duckdb/third_party/libpg_query/include", 
@@ -301,9 +324,11 @@
                 "src/duckdb/third_party/jaro_winkler/details", 
                 "src/duckdb/extension/parquet/include", 
                 "src/duckdb/third_party/parquet", 
-                "src/duckdb/third_party/snappy", 
                 "src/duckdb/third_party/thrift", 
+                "src/duckdb/third_party/snappy", 
                 "src/duckdb/third_party/zstd/include", 
+                "src/duckdb/third_party/mbedtls", 
+                "src/duckdb/third_party/mbedtls/include", 
                 "src/duckdb/extension/icu/include", 
                 "src/duckdb/extension/icu/third_party/icu/common", 
                 "src/duckdb/extension/icu/third_party/icu/i18n", 

package/package.json

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

package/src/connection.cpp

@@ -109,7 +109,7 @@ struct JSArgs {
 	duckdb::DataChunk *args;
 	duckdb::Vector *result;
 	bool done;
-	duckdb::PreservedError error;
+	duckdb::ErrorData error;
 };
 
 void DuckDBNodeUDFLauncher(Napi::Env env, Napi::Function jsudf, std::nullptr_t *, JSArgs *jsargs) {
@@ -221,9 +221,9 @@ void DuckDBNodeUDFLauncher(Napi::Env env, Napi::Function jsudf, std::nullptr_t *
 		}
 		}
 	} catch (const duckdb::Exception &e) {
-		jsargs->error = duckdb::PreservedError(e);
+		jsargs->error = duckdb::ErrorData(e);
 	} catch (const std::exception &e) {
-		jsargs->error = duckdb::PreservedError(e);
+		jsargs->error = duckdb::ErrorData(e);
 	}
 	jsargs->done = true;
 }
@@ -254,7 +254,7 @@ struct RegisterUdfTask : public Task {
 			while (!jsargs.done) {
 				std::this_thread::yield();
 			}
-			if (jsargs.error) {
+			if (jsargs.error.HasError()) {
 				jsargs.error.Throw();
 			}
 			if (all_constant) {
@@ -373,7 +373,7 @@ struct ExecTask : public Task {
 			}
 		} catch (duckdb::ParserException &e) {
 			success = false;
-			error = duckdb::PreservedError(e);
+			error = duckdb::ErrorData(e);
 			return;
 		}
 	}
@@ -386,7 +386,7 @@ struct ExecTask : public Task {
 
 	std::string sql;
 	bool success;
-	duckdb::PreservedError error;
+	duckdb::ErrorData error;
 };
 
 struct ExecTaskWithCallback : public ExecTask {

package/src/database.cpp

@@ -33,6 +33,7 @@ struct OpenTask : public Task {
 	    : Task(database_, callback_), filename(filename_) {
 
 		duckdb_config.options.access_mode = access_mode_;
+		duckdb_config.SetOptionByName("duckdb_api", duckdb::Value("nodejs"));
 		Napi::Env env = database_.Env();
 		Napi::HandleScope scope(env);
 
@@ -45,7 +46,8 @@ struct OpenTask : public Task {
 				try {
 					duckdb_config.SetOptionByName(key, duckdb::Value(val));
 				} catch (std::exception &e) {
-					throw Napi::TypeError::New(env, "Failed to set configuration option " + key + ": " + e.what());
+					duckdb::ErrorData error(e);
+					throw Napi::TypeError::New(env, "Failed to set configuration option " + key + ": " + error.Message());
 				}
 			}
 		}
@@ -57,9 +59,9 @@ struct OpenTask : public Task {
 			success = true;
 
 		} catch (const duckdb::Exception &ex) {
-			error = duckdb::PreservedError(ex);
+			error = duckdb::ErrorData(ex);
 		} catch (std::exception &ex) {
-			error = duckdb::PreservedError(ex);
+			error = duckdb::ErrorData(ex);
 		}
 	}
 
@@ -81,7 +83,7 @@ struct OpenTask : public Task {
 
 	std::string filename;
 	duckdb::DBConfig duckdb_config;
-	duckdb::PreservedError error;
+	duckdb::ErrorData error;
 	bool success = false;
 };
 
@@ -269,7 +271,7 @@ struct JSRSArgs {
 	std::string function = "";
 	vector<duckdb::Value> parameters;
 	bool done = false;
-	duckdb::PreservedError error;
+	duckdb::ErrorData error;
 };
 
 struct NodeReplacementScanData : duckdb::ReplacementScanData {
@@ -292,15 +294,15 @@ void DuckDBNodeRSLauncher(Napi::Env env, Napi::Function jsrs, std::nullptr_t *,
 					jsargs->parameters.push_back(Utils::BindParameter(paramArray.Get(i)));
 				}
 			} else {
-				throw duckdb::Exception("Expected parameter array");
+				throw duckdb::InvalidInputException("Expected parameter array");
 			}
 		} else if (!result.IsNull()) {
-			throw duckdb::Exception("Invalid scan replacement result");
+			throw std::runtime_error("Invalid scan replacement result");
 		}
 	} catch (const duckdb::Exception &e) {
-		jsargs->error = duckdb::PreservedError(e);
+		jsargs->error = duckdb::ErrorData(e);
 	} catch (const std::exception &e) {
-		jsargs->error = duckdb::PreservedError(e);
+		jsargs->error = duckdb::ErrorData(e);
 	}
 	jsargs->done = true;
 }
@@ -313,7 +315,7 @@ ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, d
 	while (!jsargs.done) {
 		std::this_thread::yield();
 	}
-	if (jsargs.error) {
+	if (jsargs.error.HasError()) {
 		jsargs.error.Throw();
 	}
 	if (jsargs.function != "") {

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

@@ -4,7 +4,7 @@
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/timestamp.hpp"
-
+#include "duckdb/common/exception/conversion_exception.hpp"
 #include "unicode/ucal.h"
 
 namespace duckdb {
@@ -13,28 +13,40 @@ ICUDateFunc::BindData::BindData(const BindData &other)
     : tz_setting(other.tz_setting), cal_setting(other.cal_setting), calendar(other.calendar->clone()) {
 }
 
+ICUDateFunc::BindData::BindData(const string &tz_setting_p, const string &cal_setting_p)
+    : tz_setting(tz_setting_p), cal_setting(cal_setting_p) {
+
+	InitCalendar();
+}
+
 ICUDateFunc::BindData::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";
+		cal_setting = "gregorian";
 	}
 
+	InitCalendar();
+}
+
+void ICUDateFunc::BindData::InitCalendar() {
+	auto tz = icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_setting)));
+
+	string cal_id("@calendar=");
+	cal_id += cal_setting;
+
 	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.");
+		throw InternalException("Unable to create ICU calendar.");
 	}
 
 	//	Postgres always assumes times are given in the proleptic Gregorian calendar.
@@ -69,7 +81,7 @@ timestamp_t ICUDateFunc::GetTimeUnsafe(icu::Calendar *calendar, uint64_t micros)
 	UErrorCode status = U_ZERO_ERROR;
 	const auto millis = int64_t(calendar->getTime(status));
 	if (U_FAILURE(status)) {
-		throw Exception("Unable to get ICU calendar time.");
+		throw InternalException("Unable to get ICU calendar time.");
 	}
 	return timestamp_t(millis * Interval::MICROS_PER_MSEC + micros);
 }
@@ -118,7 +130,7 @@ uint64_t ICUDateFunc::SetTime(icu::Calendar *calendar, timestamp_t date) {
 	UErrorCode status = U_ZERO_ERROR;
 	calendar->setTime(udate, status);
 	if (U_FAILURE(status)) {
-		throw Exception("Unable to set ICU calendar time.");
+		throw InternalException("Unable to set ICU calendar time.");
 	}
 	return uint64_t(micros);
 }
@@ -127,7 +139,7 @@ int32_t ICUDateFunc::ExtractField(icu::Calendar *calendar, UCalendarDateFields f
 	UErrorCode status = U_ZERO_ERROR;
 	const auto result = calendar->get(field, status);
 	if (U_FAILURE(status)) {
-		throw Exception("Unable to extract ICU calendar part.");
+		throw InternalException("Unable to extract ICU calendar part.");
 	}
 	return result;
 }
@@ -138,7 +150,7 @@ int64_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields
 	UErrorCode status = U_ZERO_ERROR;
 	auto sub = calendar->fieldDifference(when, field, status);
 	if (U_FAILURE(status)) {
-		throw Exception("Unable to subtract ICU calendar part.");
+		throw InternalException("Unable to subtract ICU calendar part.");
 	}
 	return sub;
 }

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

@@ -198,7 +198,7 @@ struct ICUDatePart : public ICUDateFunc {
 		case DatePartSpecifier::TIMEZONE_MINUTE:
 			return ExtractTimezoneMinute;
 		default:
-			throw Exception("Unsupported ICU BIGINT extractor");
+			throw InternalException("Unsupported ICU BIGINT extractor");
 		}
 	}
 
@@ -209,7 +209,7 @@ struct ICUDatePart : public ICUDateFunc {
 		case DatePartSpecifier::JULIAN_DAY:
 			return ExtractJulianDay;
 		default:
-			throw Exception("Unsupported ICU DOUBLE extractor");
+			throw InternalException("Unsupported ICU DOUBLE extractor");
 		}
 	}
 
@@ -223,7 +223,7 @@ struct ICUDatePart : public ICUDateFunc {
 		UErrorCode status = U_ZERO_ERROR;
 		const auto dd = calendar->getActualMaximum(UCAL_DATE, status);
 		if (U_FAILURE(status)) {
-			throw Exception("Unable to extract ICU last day.");
+			throw InternalException("Unable to extract ICU last day.");
 		}
 
 		calendar->set(UCAL_DATE, dd);
@@ -327,8 +327,13 @@ struct ICUDatePart : public ICUDateFunc {
 		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(ClientContext &context, part_codes_t &&part_codes_p)
+		    : BindData(context), part_codes(part_codes_p) {
+			InitFactories();
+		}
+		BindStructData(const string &tz_setting_p, const string &cal_setting_p, part_codes_t &&part_codes_p)
+		    : BindData(tz_setting_p, cal_setting_p), part_codes(part_codes_p) {
+			InitFactories();
 		}
 		BindStructData(const BindStructData &other)
 		    : BindData(other), part_codes(other.part_codes), bigints(other.bigints), doubles(other.doubles) {
@@ -340,13 +345,27 @@ struct ICUDatePart : public ICUDateFunc {
 
 		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;
+			return BindData::Equals(other_p) && part_codes == other.part_codes;
 		}
 
 		duckdb::unique_ptr<FunctionData> Copy() const override {
 			return make_uniq<BindStructData>(*this);
 		}
+
+		void InitFactories() {
+			bigints.clear();
+			bigints.resize(part_codes.size(), nullptr);
+			doubles.clear();
+			doubles.resize(part_codes.size(), nullptr);
+			for (size_t col = 0; col < part_codes.size(); ++col) {
+				const auto part_code = part_codes[col];
+				if (IsBigintDatepart(part_code)) {
+					bigints[col] = PartCodeBigintFactory(part_code);
+				} else {
+					doubles[col] = PartCodeDoubleFactory(part_code);
+				}
+			}
+		}
 	};
 
 	template <typename INPUT_TYPE>
@@ -504,8 +523,6 @@ struct ICUDatePart : public ICUDateFunc {
 		case_insensitive_set_t name_collision_set;
 		child_list_t<LogicalType> struct_children;
 		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) {
@@ -514,8 +531,6 @@ struct ICUDatePart : public ICUDateFunc {
 				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
 			}
 
-			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()) {
@@ -529,10 +544,8 @@ struct ICUDatePart : public ICUDateFunc {
 				name_collision_set.insert(part_name);
 				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));
 				}
 			}
@@ -542,17 +555,24 @@ struct ICUDatePart : public ICUDateFunc {
 
 		Function::EraseArgument(bound_function, arguments, 0);
 		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
-		return make_uniq<BindStructData>(context, part_codes, bigints, doubles);
+		return make_uniq<BindStructData>(context, std::move(part_codes));
 	}
 
-	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-	                              const ScalarFunction &function) {
-		throw NotImplementedException("FIXME: serialize icu-datepart");
+	static void SerializeStructFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+	                                    const ScalarFunction &function) {
+		D_ASSERT(bind_data);
+		auto &info = bind_data->Cast<BindStructData>();
+		serializer.WriteProperty(100, "tz_setting", info.tz_setting);
+		serializer.WriteProperty(101, "cal_setting", info.cal_setting);
+		serializer.WriteProperty(102, "part_codes", info.part_codes);
 	}
 
-	static duckdb::unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer,
-	                                                            ScalarFunction &bound_function) {
-		throw NotImplementedException("FIXME: serialize icu-datepart");
+	static duckdb::unique_ptr<FunctionData> DeserializeStructFunction(Deserializer &deserializer,
+	                                                                  ScalarFunction &bound_function) {
+		auto tz_setting = deserializer.ReadProperty<string>(100, "tz_setting");
+		auto cal_setting = deserializer.ReadProperty<string>(101, "cal_setting");
+		auto part_codes = deserializer.ReadProperty<vector<DatePartSpecifier>>(102, "part_codes");
+		return make_uniq<BindStructData>(tz_setting, cal_setting, std::move(part_codes));
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
@@ -581,8 +601,8 @@ struct ICUDatePart : public ICUDateFunc {
 		auto part_type = LogicalType::LIST(LogicalType::VARCHAR);
 		auto result_type = LogicalType::STRUCT({});
 		ScalarFunction result({part_type, temporal_type}, result_type, StructFunction<INPUT_TYPE>, BindStruct);
-		result.serialize = SerializeFunction;
-		result.deserialize = DeserializeFunction;
+		result.serialize = SerializeStructFunction;
+		result.deserialize = DeserializeStructFunction;
 		return result;
 	}
 

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

@@ -12,26 +12,59 @@
 namespace duckdb {
 
 struct ICUDateTrunc : public ICUDateFunc {
+	static void PreserveOffsets(icu::Calendar *calendar) {
+		//	We have to extract _everything_ before setting anything
+		//	Otherwise ICU will clear the fStamp fields
+		//	This also means we must call this method first.
+
+		//	Force reuse of offsets when reassembling truncated sub-hour times.
+		const auto zone_offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
+		const auto dst_offset = ExtractField(calendar, UCAL_DST_OFFSET);
+
+		calendar->set(UCAL_ZONE_OFFSET, zone_offset);
+		calendar->set(UCAL_DST_OFFSET, dst_offset);
+	}
+
+	static void TruncMicrosecondInternal(icu::Calendar *calendar, uint64_t &micros) {
+	}
+
 	static void TruncMicrosecond(icu::Calendar *calendar, uint64_t &micros) {
+		PreserveOffsets(calendar);
+		TruncMicrosecondInternal(calendar, micros);
 	}
 
-	static void TruncMillisecond(icu::Calendar *calendar, uint64_t &micros) {
-		TruncMicrosecond(calendar, micros);
+	static void TruncMillisecondInternal(icu::Calendar *calendar, uint64_t &micros) {
+		TruncMicrosecondInternal(calendar, micros);
 		micros = 0;
 	}
 
-	static void TruncSecond(icu::Calendar *calendar, uint64_t &micros) {
-		TruncMillisecond(calendar, micros);
+	static void TruncMillisecond(icu::Calendar *calendar, uint64_t &micros) {
+		PreserveOffsets(calendar);
+		TruncMillisecondInternal(calendar, micros);
+	}
+
+	static void TruncSecondInternal(icu::Calendar *calendar, uint64_t &micros) {
+		TruncMillisecondInternal(calendar, micros);
 		calendar->set(UCAL_MILLISECOND, 0);
 	}
 
-	static void TruncMinute(icu::Calendar *calendar, uint64_t &micros) {
-		TruncSecond(calendar, micros);
+	static void TruncSecond(icu::Calendar *calendar, uint64_t &micros) {
+		PreserveOffsets(calendar);
+		TruncSecondInternal(calendar, micros);
+	}
+
+	static void TruncMinuteInternal(icu::Calendar *calendar, uint64_t &micros) {
+		TruncSecondInternal(calendar, micros);
 		calendar->set(UCAL_SECOND, 0);
 	}
 
+	static void TruncMinute(icu::Calendar *calendar, uint64_t &micros) {
+		PreserveOffsets(calendar);
+		TruncMinuteInternal(calendar, micros);
+	}
+
 	static void TruncHour(icu::Calendar *calendar, uint64_t &micros) {
-		TruncMinute(calendar, micros);
+		TruncMinuteInternal(calendar, micros);
 		calendar->set(UCAL_MINUTE, 0);
 	}