duckdb 0.8.2-dev3989.0 → 0.8.2-dev4025.0

package/binding.gyp

@@ -249,18 +249,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-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-datepart.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-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu_extension.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.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", 

package/package.json

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

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -21,6 +21,8 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/function/table_function.hpp"
@@ -35,8 +37,6 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/storage/table/row_group.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
 
 #endif
 
@@ -78,6 +78,8 @@ struct ParquetReadLocalState : public LocalTableFunctionState {
 	DataChunk all_columns;
 };
 
+enum class ParquetFileState : uint8_t { UNOPENED, OPENING, OPEN, CLOSED };
+
 struct ParquetReadGlobalState : public GlobalTableFunctionState {
 	mutex lock;
 
@@ -86,7 +88,7 @@ struct ParquetReadGlobalState : public GlobalTableFunctionState {
 	//! Currently opened readers
 	vector<shared_ptr<ParquetReader>> readers;
 	//! Flag to indicate a file is being opened
-	vector<bool> file_opening;
+	vector<ParquetFileState> file_states;
 	//! Mutexes to wait for a file that is currently being opened
 	unique_ptr<mutex[]> file_mutexes;
 	//! Signal to other threads that a file failed to open, letting every thread abort.
@@ -359,7 +361,7 @@ public:
 		auto &bind_data = input.bind_data->CastNoConst<ParquetReadBindData>();
 		auto result = make_uniq<ParquetReadGlobalState>();
 
-		result->file_opening = vector<bool>(bind_data.files.size(), false);
+		result->file_states = vector<ParquetFileState>(bind_data.files.size(), ParquetFileState::UNOPENED);
 		result->file_mutexes = unique_ptr<mutex[]>(new mutex[bind_data.files.size()]);
 		if (bind_data.files.empty()) {
 			result->initial_reader = nullptr;
@@ -367,6 +369,8 @@ public:
 			result->readers = std::move(bind_data.union_readers);
 			if (result->readers.size() != bind_data.files.size()) {
 				result->readers = vector<shared_ptr<ParquetReader>>(bind_data.files.size(), nullptr);
+			} else {
+				std::fill(result->file_states.begin(), result->file_states.end(), ParquetFileState::OPEN);
 			}
 			if (bind_data.initial_reader) {
 				result->initial_reader = std::move(bind_data.initial_reader);
@@ -378,6 +382,7 @@ public:
 				    make_shared<ParquetReader>(context, bind_data.files[0], bind_data.parquet_options);
 				result->readers[0] = result->initial_reader;
 			}
+			result->file_states[0] = ParquetFileState::OPEN;
 		}
 		for (auto &reader : result->readers) {
 			if (!reader) {
@@ -511,7 +516,7 @@ public:
 
 			D_ASSERT(parallel_state.initial_reader);
 
-			if (parallel_state.readers[parallel_state.file_index]) {
+			if (parallel_state.file_states[parallel_state.file_index] == ParquetFileState::OPEN) {
 				if (parallel_state.row_group_index <
 				    parallel_state.readers[parallel_state.file_index]->NumRowGroups()) {
 					// The current reader has rowgroups left to be scanned
@@ -523,12 +528,14 @@ public:
 					parallel_state.row_group_index++;
 					return true;
 				} else {
+					// Close current file
+					parallel_state.file_states[parallel_state.file_index] = ParquetFileState::CLOSED;
+					parallel_state.readers[parallel_state.file_index] = nullptr;
+
 					// Set state to the next file
 					parallel_state.file_index++;
 					parallel_state.row_group_index = 0;
 
-					parallel_state.readers[parallel_state.file_index - 1] = nullptr;
-
 					if (parallel_state.file_index >= bind_data.files.size()) {
 						return false;
 					}
@@ -541,8 +548,7 @@ public:
 			}
 
 			// Check if the current file is being opened, in that case we need to wait for it.
-			if (!parallel_state.readers[parallel_state.file_index] &&
-			    parallel_state.file_opening[parallel_state.file_index]) {
+			if (parallel_state.file_states[parallel_state.file_index] == ParquetFileState::OPENING) {
 				WaitForFile(parallel_state.file_index, parallel_state, parallel_lock);
 			}
 		}
@@ -573,7 +579,8 @@ public:
 			// - the thread opening the file has failed
 			// - the file was somehow scanned till the end while we were waiting
 			if (parallel_state.file_index >= parallel_state.readers.size() ||
-			    parallel_state.readers[parallel_state.file_index] || parallel_state.error_opening_file) {
+			    parallel_state.file_states[parallel_state.file_index] != ParquetFileState::OPENING ||
+			    parallel_state.error_opening_file) {
 				return;
 			}
 		}
@@ -583,10 +590,12 @@ public:
 	static bool TryOpenNextFile(ClientContext &context, const ParquetReadBindData &bind_data,
 	                            ParquetReadLocalState &scan_data, ParquetReadGlobalState &parallel_state,
 	                            unique_lock<mutex> &parallel_lock) {
-		for (idx_t i = parallel_state.file_index; i < bind_data.files.size(); i++) {
-			if (!parallel_state.readers[i] && parallel_state.file_opening[i] == false) {
+		const auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+		const auto file_index_limit = MinValue<idx_t>(parallel_state.file_index + num_threads, bind_data.files.size());
+		for (idx_t i = parallel_state.file_index; i < file_index_limit; i++) {
+			if (parallel_state.file_states[i] == ParquetFileState::UNOPENED) {
 				string file = bind_data.files[i];
-				parallel_state.file_opening[i] = true;
+				parallel_state.file_states[i] = ParquetFileState::OPENING;
 				auto pq_options = parallel_state.initial_reader->parquet_options;
 
 				// Now we switch which lock we are holding, instead of locking the global state, we grab the lock on
@@ -611,6 +620,7 @@ public:
 				// Now re-lock the state and add the reader
 				parallel_lock.lock();
 				parallel_state.readers[i] = reader;
+				parallel_state.file_states[i] = ParquetFileState::OPEN;
 
 				return true;
 			}

package/src/duckdb/src/common/crypto/md5.cpp

@@ -20,6 +20,7 @@
  * will fill a supplied 16-byte array with the digest.
  */
 #include "duckdb/common/crypto/md5.hpp"
+#include "mbedtls_wrapper.hpp"
 
 namespace duckdb {
 
@@ -236,21 +237,10 @@ void MD5Context::Finish(data_ptr_t out_digest) {
 	memcpy(out_digest, buf, 16);
 }
 
-void MD5Context::DigestToBase16(const_data_ptr_t digest, char *zbuf) {
-	static char const HEX_CODES[] = "0123456789abcdef";
-	int i, j;
-
-	for (j = i = 0; i < 16; i++) {
-		int a = digest[i];
-		zbuf[j++] = HEX_CODES[(a >> 4) & 0xf];
-		zbuf[j++] = HEX_CODES[a & 0xf];
-	}
-}
-
 void MD5Context::FinishHex(char *out_digest) {
 	data_t digest[MD5_HASH_LENGTH_BINARY];
 	Finish(digest);
-	DigestToBase16(digest, out_digest);
+	duckdb_mbedtls::MbedTlsWrapper::ToBase16(reinterpret_cast<char *>(digest), out_digest, MD5_HASH_LENGTH_BINARY);
 }
 
 string MD5Context::FinishHex() {

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

@@ -281,6 +281,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION(StandardErrorOfTheMeanFun),
 	DUCKDB_SCALAR_FUNCTION(SetBitFun),
 	DUCKDB_SCALAR_FUNCTION(SetseedFun),
+	DUCKDB_SCALAR_FUNCTION(SHA256Fun),
 	DUCKDB_SCALAR_FUNCTION_SET(SignFun),
 	DUCKDB_SCALAR_FUNCTION_SET(SignBitFun),
 	DUCKDB_SCALAR_FUNCTION(SinFun),

package/src/duckdb/src/core_functions/scalar/string/sha256.cpp

@@ -0,0 +1,32 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "mbedtls_wrapper.hpp"
+
+namespace duckdb {
+
+struct SHA256Operator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		auto hash = StringVector::EmptyString(result, duckdb_mbedtls::MbedTlsWrapper::SHA256_HASH_LENGTH_TEXT);
+
+		duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
+		state.AddString(input.GetString());
+		state.FinishHex(hash.GetDataWriteable());
+
+		hash.Finalize();
+		return hash;
+	}
+};
+
+static void SHA256Function(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+
+	UnaryExecutor::ExecuteString<string_t, string_t, SHA256Operator>(input, result, args.size());
+}
+
+ScalarFunction SHA256Fun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, SHA256Function);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/string/suffix.cpp

@@ -41,7 +41,7 @@ ScalarFunction SuffixFun::GetFunction() {
 }
 
 void SuffixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
+	set.AddFunction({"suffix", "ends_with"}, GetFunction());
 }
 
 } // 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-dev3989"
+#define DUCKDB_VERSION "0.8.2-dev4025"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a7a88cb691"
+#define DUCKDB_SOURCE_ID "9698e9e6a8"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -342,6 +342,15 @@ struct RtrimFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct SHA256Fun {
+	static constexpr const char *Name = "sha256";
+	static constexpr const char *Parameters = "value";
+	static constexpr const char *Description = "Returns the SHA256 hash of the value";
+	static constexpr const char *Example = "sha256('hello')";
+
+	static ScalarFunction GetFunction();
+};
+
 struct StringSplitFun {
 	static constexpr const char *Name = "string_split";
 	static constexpr const char *Parameters = "string,separator";

package/src/duckdb/src/include/duckdb/planner/operator/logical_join.hpp

@@ -30,7 +30,7 @@ public:
 	//! The type of the join (INNER, OUTER, etc...)
 	JoinType join_type;
 	//! Table index used to refer to the MARK column (in case of a MARK join)
-	idx_t mark_index;
+	idx_t mark_index {};
 	//! The columns of the LHS that are output by the join
 	vector<idx_t> left_projection_map;
 	//! The columns of the RHS that are output by the join

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -12,6 +12,10 @@
 #define DUCKDB_EXTENSION_ICU_LINKED false
 #endif
 
+#ifndef DUCKDB_EXTENSION_EXCEL_LINKED
+#define DUCKDB_EXTENSION_EXCEL_LINKED false
+#endif
+
 #ifndef DUCKDB_EXTENSION_PARQUET_LINKED
 #define DUCKDB_EXTENSION_PARQUET_LINKED false
 #endif
@@ -54,6 +58,10 @@
 #include "icu_extension.hpp"
 #endif
 
+#if DUCKDB_EXTENSION_EXCEL_LINKED
+#include "excel_extension.hpp"
+#endif
+
 #if DUCKDB_EXTENSION_PARQUET_LINKED
 #include "parquet_extension.hpp"
 #endif
@@ -94,6 +102,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 static DefaultExtension internal_extensions[] = {
     {"icu", "Adds support for time zones and collations using the ICU library", DUCKDB_EXTENSION_ICU_LINKED},
+    {"excel", "Adds support for Excel-like format strings", DUCKDB_EXTENSION_EXCEL_LINKED},
     {"parquet", "Adds support for reading and writing parquet files", DUCKDB_EXTENSION_PARQUET_LINKED},
     {"tpch", "Adds TPC-H data generation and query support", DUCKDB_EXTENSION_TPCH_LINKED},
     {"tpcds", "Adds TPC-DS data generation and query support", DUCKDB_EXTENSION_TPCDS_LINKED},
@@ -101,12 +110,17 @@ static DefaultExtension internal_extensions[] = {
     {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", DUCKDB_EXTENSION_HTTPFS_LINKED},
     {"json", "Adds support for JSON operations", DUCKDB_EXTENSION_JSON_LINKED},
     {"jemalloc", "Overwrites system allocator with JEMalloc", DUCKDB_EXTENSION_JEMALLOC_LINKED},
-    {"autocomplete", "Add supports for autocomplete in the shell", DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED},
+    {"autocomplete", "Adds support for autocomplete in the shell", DUCKDB_EXTENSION_AUTOCOMPLETE_LINKED},
     {"motherduck", "Enables motherduck integration with the system", false},
     {"sqlite_scanner", "Adds support for reading SQLite database files", false},
     {"postgres_scanner", "Adds support for reading from a Postgres database", false},
     {"inet", "Adds support for IP-related data types and functions", false},
     {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
+    {"substrait", "Adds support for the Substrait integration", false},
+    {"aws", "Provides features that depend on the AWS SDK", false},
+    {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
+    {"iceberg", "Adds support for Apache Iceberg", false},
+    {"visualizer", "Creates an HTML-based visualization of the query plan", false},
     {nullptr, nullptr, false}};
 
 idx_t ExtensionHelper::DefaultExtensionCount() {

package/src/duckdb/src/storage/standard_buffer_manager.cpp

@@ -3,11 +3,11 @@
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/set.hpp"
-#include "duckdb/storage/in_memory_block_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/storage/buffer/buffer_pool.hpp"
+#include "duckdb/storage/in_memory_block_manager.hpp"
+#include "duckdb/storage/storage_manager.hpp"
 
 namespace duckdb {
 
@@ -329,12 +329,13 @@ private:
 };
 
 class TemporaryFileHandle {
-	constexpr static idx_t MAX_ALLOWED_INDEX = 4000;
+	constexpr static idx_t MAX_ALLOWED_INDEX_BASE = 4000;
 
 public:
-	TemporaryFileHandle(DatabaseInstance &db, const string &temp_directory, idx_t index)
-	    : db(db), file_index(index), path(FileSystem::GetFileSystem(db).JoinPath(
-	                                     temp_directory, "duckdb_temp_storage-" + to_string(index) + ".tmp")) {
+	TemporaryFileHandle(idx_t temp_file_count, DatabaseInstance &db, const string &temp_directory, idx_t index)
+	    : max_allowed_index((1 << temp_file_count) * MAX_ALLOWED_INDEX_BASE), db(db), file_index(index),
+	      path(FileSystem::GetFileSystem(db).JoinPath(temp_directory,
+	                                                  "duckdb_temp_storage-" + to_string(index) + ".tmp")) {
 	}
 
 public:
@@ -348,7 +349,7 @@ public:
 public:
 	TemporaryFileIndex TryGetBlockIndex() {
 		TemporaryFileLock lock(file_lock);
-		if (index_manager.GetMaxIndex() >= MAX_ALLOWED_INDEX && index_manager.HasFreeBlocks()) {
+		if (index_manager.GetMaxIndex() >= max_allowed_index && index_manager.HasFreeBlocks()) {
 			// file is at capacity
 			return TemporaryFileIndex();
 		}
@@ -426,6 +427,7 @@ private:
 	}
 
 private:
+	const idx_t max_allowed_index;
 	DatabaseInstance &db;
 	unique_ptr<FileHandle> handle;
 	idx_t file_index;
@@ -467,7 +469,7 @@ public:
 			if (!handle) {
 				// no existing handle to write to; we need to create & open a new file
 				auto new_file_index = index_manager.GetNewBlockIndex();
-				auto new_file = make_uniq<TemporaryFileHandle>(db, temp_directory, new_file_index);
+				auto new_file = make_uniq<TemporaryFileHandle>(files.size(), db, temp_directory, new_file_index);
 				handle = new_file.get();
 				files[new_file_index] = std::move(new_file);
 

package/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp

@@ -17,8 +17,10 @@ public:
 	static std::string ComputeSha256Hash(const std::string& file_content);
 	static bool IsValidSha256Signature(const std::string& pubkey, const std::string& signature, const std::string& sha256_hash);
 	static void Hmac256(const char* key, size_t key_len, const char* message, size_t message_len, char* out);
+	static void ToBase16(char *in, char *out, size_t len);
 
-	static constexpr size_t SHA256_HASH_BYTES = 32;
+	static constexpr size_t SHA256_HASH_LENGTH_BYTES = 32;
+	static constexpr size_t SHA256_HASH_LENGTH_TEXT = 64;
 
 	class SHA256State {
 	public:
@@ -26,6 +28,7 @@ public:
 		~SHA256State();
 		void AddString(const std::string & str);
 		std::string Finalize();
+		void FinishHex(char *out);
 	private:
 		void *sha_context;
 	};

package/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp

@@ -38,7 +38,7 @@ void MbedTlsWrapper::ComputeSha256Hash(const char* in, size_t in_len, char* out)
 
 string MbedTlsWrapper::ComputeSha256Hash(const string& file_content) {
 	string hash;
-	hash.resize(MbedTlsWrapper::SHA256_HASH_BYTES);
+	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
 	ComputeSha256Hash(file_content.data(), file_content.size(), (char*)hash.data());
 	return hash;
 }
@@ -83,6 +83,17 @@ void MbedTlsWrapper::Hmac256(const char* key, size_t key_len, const char* messag
 	mbedtls_md_free(&hmac_ctx);
 }
 
+void MbedTlsWrapper::ToBase16(char *in, char *out, size_t len) {
+	static char const HEX_CODES[] = "0123456789abcdef";
+	size_t i, j;
+
+	for (j = i = 0; i < len; i++) {
+		int a = in[i];
+		out[j++] = HEX_CODES[(a >> 4) & 0xf];
+		out[j++] = HEX_CODES[a & 0xf];
+	}
+}
+
 MbedTlsWrapper::SHA256State::SHA256State() : sha_context(new mbedtls_sha256_context()) {
 	mbedtls_sha256_init((mbedtls_sha256_context*)sha_context);
 
@@ -104,7 +115,7 @@ void MbedTlsWrapper::SHA256State::AddString(const std::string & str) {
 
 std::string MbedTlsWrapper::SHA256State::Finalize() {
 	string hash;
-	hash.resize(MbedTlsWrapper::SHA256_HASH_BYTES);
+	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
 
 	if (mbedtls_sha256_finish((mbedtls_sha256_context*)sha_context, (unsigned char*)hash.data())) {
 		throw std::runtime_error("SHA256 Error");
@@ -112,3 +123,14 @@ std::string MbedTlsWrapper::SHA256State::Finalize() {
 
 	return hash;
 }
+
+void MbedTlsWrapper::SHA256State::FinishHex(char *out) {
+	string hash;
+	hash.resize(MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
+
+	if (mbedtls_sha256_finish((mbedtls_sha256_context *)sha_context, (unsigned char *)hash.data())) {
+		throw std::runtime_error("SHA256 Error");
+	}
+
+	MbedTlsWrapper::ToBase16(const_cast<char *>(hash.c_str()), out, MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES);
+}

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -348,9 +348,11 @@
 
 #include "extension/icu/third_party/icu/i18n/wintzimpl.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
+
+#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
 
@@ -358,7 +360,5 @@
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
-
-#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 

package/src/duckdb/ub_src_core_functions_scalar_string.cpp

@@ -34,6 +34,8 @@
 
 #include "src/core_functions/scalar/string/reverse.cpp"
 
+#include "src/core_functions/scalar/string/sha256.cpp"
+
 #include "src/core_functions/scalar/string/starts_with.cpp"
 
 #include "src/core_functions/scalar/string/string_split.cpp"