duckdb 0.10.2 → 0.10.3-dev10.0

package/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
+#include "duckdb/common/multi_file_list.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/union_by_name.hpp"
@@ -47,6 +48,33 @@ struct MultiFileReaderBindData {
 	DUCKDB_API static MultiFileReaderBindData Deserialize(Deserializer &deserializer);
 };
 
+//! Global state for MultiFileReads
+struct MultiFileReaderGlobalState {
+	MultiFileReaderGlobalState(vector<LogicalType> extra_columns_p, optional_ptr<const MultiFileList> file_list_p)
+	    : extra_columns(std::move(extra_columns_p)), file_list(file_list_p) {};
+
+	//! extra columns that will be produced during scanning
+	const vector<LogicalType> extra_columns;
+	// the file list driving the current scan
+	const optional_ptr<const MultiFileList> file_list;
+
+	//! Indicates that the MultiFileReader has added columns to be scanned that are not in the projection
+	bool RequiresExtraColumns() {
+		return !extra_columns.empty();
+	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
 struct MultiFileFilterEntry {
 	idx_t index = DConstants::INVALID_INDEX;
 	bool is_constant = false;
@@ -55,7 +83,6 @@ struct MultiFileFilterEntry {
 struct MultiFileConstantEntry {
 	MultiFileConstantEntry(idx_t column_id, Value value_p) : column_id(column_id), value(std::move(value_p)) {
 	}
-
 	//! The column id to apply the constant value to
 	idx_t column_id;
 	//! The constant value
@@ -80,63 +107,105 @@ struct MultiFileReaderData {
 	//! Map of column_id -> cast, used when reading multiple files when files have diverging types
 	//! for the same column
 	unordered_map<column_t, LogicalType> cast_map;
+	//! (Optionally) The MultiFileReader-generated metadata corresponding to the currently read file
+	optional_idx file_list_idx;
 };
 
+//! The MultiFileReader class provides a set of helper methods to handle scanning from multiple files
 struct MultiFileReader {
+	virtual ~MultiFileReader();
+
+	//! Create a MultiFileReader for a specific TableFunction, using its function name for errors
+	DUCKDB_API static unique_ptr<MultiFileReader> Create(const TableFunction &table_function);
+	//! Create a default MultiFileReader, function_name is used for errors
+	DUCKDB_API static unique_ptr<MultiFileReader> CreateDefault(const string &function_name = "");
+
 	//! Add the parameters for multi-file readers (e.g. union_by_name, filename) to a table function
 	DUCKDB_API static void AddParameters(TableFunction &table_function);
-	//! Performs any globbing for the multi-file reader and returns a list of files to be read
-	DUCKDB_API static vector<string> GetFileList(ClientContext &context, const Value &input, const string &name,
-	                                             FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
+	//! Creates a table function set from a single reader function (including e.g. list parameters, etc)
+	DUCKDB_API static TableFunctionSet CreateFunctionSet(TableFunction table_function);
+
+	//! Parse a Value containing 1 or more paths into a vector of paths. Note: no expansion is performed here
+	DUCKDB_API virtual vector<string> ParsePaths(const Value &input);
+	//! Create a MultiFileList from a vector of paths. Any globs will be expanded using the default filesystem
+	DUCKDB_API virtual unique_ptr<MultiFileList>
+	CreateFileList(ClientContext &context, const vector<string> &paths,
+	               FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
+	//! Shorthand for ParsePaths + CreateFileList
+	DUCKDB_API unique_ptr<MultiFileList> CreateFileList(ClientContext &context, const Value &input,
+	                                                    FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
+
 	//! Parse the named parameters of a multi-file reader
-	DUCKDB_API static bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options,
-	                                   ClientContext &context);
-	//! Perform complex filter pushdown into the multi-file reader, potentially filtering out files that should be read
-	//! If "true" the first file has been eliminated
-	DUCKDB_API static bool ComplexFilterPushdown(ClientContext &context, vector<string> &files,
-	                                             const MultiFileReaderOptions &options, LogicalGet &get,
-	                                             vector<unique_ptr<Expression>> &filters);
+	DUCKDB_API virtual bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options,
+	                                    ClientContext &context);
+	//! Perform filter pushdown into the MultiFileList. Returns a new MultiFileList if filters were pushed down
+	DUCKDB_API virtual unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, MultiFileList &files,
+	                                                                   const MultiFileReaderOptions &options,
+	                                                                   LogicalGet &get,
+	                                                                   vector<unique_ptr<Expression>> &filters);
+	//! Try to use the MultiFileReader for binding. Returns true if a bind could be made, returns false if the
+	//! MultiFileReader can not perform the bind and binding should be performed on 1 or more files in the MultiFileList
+	//! directly.
+	DUCKDB_API virtual bool Bind(MultiFileReaderOptions &options, MultiFileList &files,
+	                             vector<LogicalType> &return_types, vector<string> &names,
+	                             MultiFileReaderBindData &bind_data);
 	//! Bind the options of the multi-file reader, potentially emitting any extra columns that are required
-	DUCKDB_API static MultiFileReaderBindData BindOptions(MultiFileReaderOptions &options, const vector<string> &files,
-	                                                      vector<LogicalType> &return_types, vector<string> &names);
+	DUCKDB_API virtual void BindOptions(MultiFileReaderOptions &options, MultiFileList &files,
+	                                    vector<LogicalType> &return_types, vector<string> &names,
+	                                    MultiFileReaderBindData &bind_data);
+
+	//! Initialize global state used by the MultiFileReader
+	DUCKDB_API virtual unique_ptr<MultiFileReaderGlobalState>
+	InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options,
+	                      const MultiFileReaderBindData &bind_data, const MultiFileList &file_list,
+	                      const vector<LogicalType> &global_types, const vector<string> &global_names,
+	                      const vector<column_t> &global_column_ids);
+
 	//! Finalize the bind phase of the multi-file reader after we know (1) the required (output) columns, and (2) the
 	//! pushed down table filters
-	DUCKDB_API static void FinalizeBind(const MultiFileReaderOptions &file_options,
-	                                    const MultiFileReaderBindData &options, const string &filename,
-	                                    const vector<string> &local_names, const vector<LogicalType> &global_types,
-	                                    const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                                    MultiFileReaderData &reader_data, ClientContext &context);
-	//! Create all required mappings from the global types/names to the file-local types/names
-	DUCKDB_API static void CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
+	DUCKDB_API virtual void FinalizeBind(const MultiFileReaderOptions &file_options,
+	                                     const MultiFileReaderBindData &options, const string &filename,
 	                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
 	                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                                     optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
-	                                     const string &initial_file);
+	                                     MultiFileReaderData &reader_data, ClientContext &context,
+	                                     optional_ptr<MultiFileReaderGlobalState> global_state);
+
+	//! Create all required mappings from the global types/names to the file-local types/names
+	DUCKDB_API virtual void CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
+	                                      const vector<string> &local_names, const vector<LogicalType> &global_types,
+	                                      const vector<string> &global_names, const vector<column_t> &global_column_ids,
+	                                      optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+	                                      const string &initial_file, const MultiFileReaderBindData &options,
+	                                      optional_ptr<MultiFileReaderGlobalState> global_state);
 	//! Populated the filter_map
-	DUCKDB_API static void CreateFilterMap(const vector<LogicalType> &global_types,
-	                                       optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data);
+	DUCKDB_API virtual void CreateFilterMap(const vector<LogicalType> &global_types,
+	                                        optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+	                                        optional_ptr<MultiFileReaderGlobalState> global_state);
+
 	//! Finalize the reading of a chunk - applying any constants that are required
-	DUCKDB_API static void FinalizeChunk(const MultiFileReaderBindData &bind_data,
-	                                     const MultiFileReaderData &reader_data, DataChunk &chunk);
-	//! Creates a table function set from a single reader function (including e.g. list parameters, etc)
-	DUCKDB_API static TableFunctionSet CreateFunctionSet(TableFunction table_function);
+	DUCKDB_API virtual void FinalizeChunk(ClientContext &context, const MultiFileReaderBindData &bind_data,
+	                                      const MultiFileReaderData &reader_data, DataChunk &chunk,
+	                                      optional_ptr<MultiFileReaderGlobalState> global_state);
 
 	template <class READER_CLASS, class RESULT_CLASS, class OPTIONS_CLASS>
-	static MultiFileReaderBindData BindUnionReader(ClientContext &context, vector<LogicalType> &return_types,
-	                                               vector<string> &names, RESULT_CLASS &result,
-	                                               OPTIONS_CLASS &options) {
+	MultiFileReaderBindData BindUnionReader(ClientContext &context, vector<LogicalType> &return_types,
+	                                        vector<string> &names, MultiFileList &files, RESULT_CLASS &result,
+	                                        OPTIONS_CLASS &options) {
 		D_ASSERT(options.file_options.union_by_name);
 		vector<string> union_col_names;
 		vector<LogicalType> union_col_types;
+
 		// obtain the set of union column names + types by unifying the types of all of the files
 		// note that this requires opening readers for each file and reading the metadata of each file
-		auto union_readers =
-		    UnionByName::UnionCols<READER_CLASS>(context, result.files, union_col_types, union_col_names, options);
+		// note also that it requires fully expanding the MultiFileList
+		auto materialized_file_list = files.GetAllFiles();
+		auto union_readers = UnionByName::UnionCols<READER_CLASS>(context, materialized_file_list, union_col_types,
+		                                                          union_col_names, options);
 
 		std::move(union_readers.begin(), union_readers.end(), std::back_inserter(result.union_readers));
 		// perform the binding on the obtained set of names + types
-		auto bind_data =
-		    MultiFileReader::BindOptions(options.file_options, result.files, union_col_types, union_col_names);
+		MultiFileReaderBindData bind_data;
+		BindOptions(options.file_options, files, union_col_types, union_col_names, bind_data);
 		names = union_col_names;
 		return_types = union_col_types;
 		result.Initialize(result.union_readers[0]);
@@ -145,37 +214,40 @@ struct MultiFileReader {
 	}
 
 	template <class READER_CLASS, class RESULT_CLASS, class OPTIONS_CLASS>
-	static MultiFileReaderBindData BindReader(ClientContext &context, vector<LogicalType> &return_types,
-	                                          vector<string> &names, RESULT_CLASS &result, OPTIONS_CLASS &options) {
+	MultiFileReaderBindData BindReader(ClientContext &context, vector<LogicalType> &return_types, vector<string> &names,
+	                                   MultiFileList &files, RESULT_CLASS &result, OPTIONS_CLASS &options) {
 		if (options.file_options.union_by_name) {
-			return BindUnionReader<READER_CLASS>(context, return_types, names, result, options);
+			return BindUnionReader<READER_CLASS>(context, return_types, names, files, result, options);
 		} else {
 			shared_ptr<READER_CLASS> reader;
-			reader = make_shared<READER_CLASS>(context, result.files[0], options);
+			reader = make_shared_ptr<READER_CLASS>(context, files.GetFirstFile(), options);
 			return_types = reader->return_types;
 			names = reader->names;
 			result.Initialize(std::move(reader));
-			return MultiFileReader::BindOptions(options.file_options, result.files, return_types, names);
+			MultiFileReaderBindData bind_data;
+			BindOptions(options.file_options, files, return_types, names, bind_data);
+			return bind_data;
 		}
 	}
 
 	template <class READER_CLASS>
-	static void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options,
-	                             const MultiFileReaderBindData &bind_data, const vector<LogicalType> &global_types,
-	                             const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                             optional_ptr<TableFilterSet> table_filters, const string &initial_file,
-	                             ClientContext &context) {
+	void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options,
+	                      const MultiFileReaderBindData &bind_data, const vector<LogicalType> &global_types,
+	                      const vector<string> &global_names, const vector<column_t> &global_column_ids,
+	                      optional_ptr<TableFilterSet> table_filters, const string &initial_file,
+	                      ClientContext &context, optional_ptr<MultiFileReaderGlobalState> global_state) {
 		FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetNames(), global_types, global_names,
-		             global_column_ids, reader.reader_data, context);
+		             global_column_ids, reader.reader_data, context, global_state);
 		CreateMapping(reader.GetFileName(), reader.GetTypes(), reader.GetNames(), global_types, global_names,
-		              global_column_ids, table_filters, reader.reader_data, initial_file);
+		              global_column_ids, table_filters, reader.reader_data, initial_file, bind_data, global_state);
 		reader.reader_data.filters = table_filters;
 	}
 
 	template <class BIND_DATA>
-	static void PruneReaders(BIND_DATA &data) {
+	static void PruneReaders(BIND_DATA &data, MultiFileList &file_list) {
 		unordered_set<string> file_set;
-		for (auto &file : data.files) {
+
+		for (const auto &file : file_list.Files()) {
 			file_set.insert(file);
 		}
 
@@ -188,25 +260,29 @@ struct MultiFileReader {
 		}
 		for (idx_t r = 0; r < data.union_readers.size(); r++) {
 			if (!data.union_readers[r]) {
-				data.union_readers.erase(data.union_readers.begin() + r);
+				data.union_readers.erase_at(r);
 				r--;
 				continue;
 			}
 			// check if the union reader should still be read or not
 			auto entry = file_set.find(data.union_readers[r]->GetFileName());
 			if (entry == file_set.end()) {
-				data.union_readers.erase(data.union_readers.begin() + r);
+				data.union_readers.erase_at(r);
 				r--;
 				continue;
 			}
 		}
 	}
 
-private:
-	static void CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
-	                              const vector<string> &local_names, const vector<LogicalType> &global_types,
-	                              const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                              MultiFileReaderData &reader_data, const string &initial_file);
+protected:
+	virtual void CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
+	                               const vector<string> &local_names, const vector<LogicalType> &global_types,
+	                               const vector<string> &global_names, const vector<column_t> &global_column_ids,
+	                               MultiFileReaderData &reader_data, const string &initial_file,
+	                               optional_ptr<MultiFileReaderGlobalState> global_state);
+
+	//! Used in errors to report which function is using this MultiFileReader
+	string function_name;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp

@@ -15,6 +15,7 @@
 
 namespace duckdb {
 struct BindInfo;
+class MultiFileList;
 
 struct MultiFileReaderOptions {
 	bool filename = false;
@@ -24,12 +25,15 @@ struct MultiFileReaderOptions {
 	bool hive_types_autocast = true;
 	case_insensitive_map_t<LogicalType> hive_types_schema;
 
+	// These are used to pass options through custom multifilereaders
+	case_insensitive_map_t<Value> custom_options;
+
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
-	DUCKDB_API void AutoDetectHivePartitioning(const vector<string> &files, ClientContext &context);
-	DUCKDB_API static bool AutoDetectHivePartitioningInternal(const vector<string> &files, ClientContext &context);
-	DUCKDB_API void AutoDetectHiveTypesInternal(const vector<string> &file, ClientContext &context);
+	DUCKDB_API void AutoDetectHivePartitioning(MultiFileList &files, ClientContext &context);
+	DUCKDB_API static bool AutoDetectHivePartitioningInternal(MultiFileList &files, ClientContext &context);
+	DUCKDB_API void AutoDetectHiveTypesInternal(MultiFileList &files, ClientContext &context);
 	DUCKDB_API void VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const;
 	DUCKDB_API LogicalType GetHiveLogicalType(const string &hive_partition_column) const;
 	DUCKDB_API Value GetHivePartitionValue(const string &base, const string &entry, ClientContext &context) const;

package/src/duckdb/src/include/duckdb/common/numeric_utils.hpp

@@ -68,6 +68,9 @@ static void ThrowNumericCastError(FROM in, TO minval, TO maxval) {
 
 template <class TO, class FROM>
 TO NumericCast(FROM val) {
+	if (std::is_same<TO, FROM>::value) {
+		return static_cast<TO>(val);
+	}
 	// some dance around signed-unsigned integer comparison below
 	auto minval = NumericLimits<TO>::Minimum();
 	auto maxval = NumericLimits<TO>::Maximum();

package/src/duckdb/src/include/duckdb/common/operator/add.hpp

@@ -64,6 +64,8 @@ template <>
 bool TryAddOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
 template <>
 bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
+template <>
+bool TryAddOperator::Operation(date_t left, int32_t right, date_t &result);
 
 template <>
 bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result);

package/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/operator/integer_cast_operator.hpp"
 
 namespace duckdb {
 
@@ -457,4 +459,235 @@ string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t
 template <>
 string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result);
 
+//===--------------------------------------------------------------------===//
+// Cast VARCHAR <-> Decimal
+//===--------------------------------------------------------------------===//
+enum class ExponentType : uint8_t { NONE, POSITIVE, NEGATIVE };
+
+template <class T>
+struct DecimalCastData {
+	using StoreType = T;
+	StoreType result;
+	uint8_t width;
+	uint8_t scale;
+	uint8_t digit_count;
+	uint8_t decimal_count;
+	//! Whether we have determined if the result should be rounded
+	bool round_set;
+	//! If the result should be rounded
+	bool should_round;
+	//! Only set when ALLOW_EXPONENT is enabled
+	uint8_t excessive_decimals;
+	ExponentType exponent_type;
+};
+
+struct DecimalCastOperation {
+	template <class T, bool NEGATIVE>
+	static bool HandleDigit(T &state, uint8_t digit) {
+		if (state.result == 0 && digit == 0) {
+			// leading zero's don't count towards the digit count
+			return true;
+		}
+		if (state.digit_count == state.width - state.scale) {
+			// width of decimal type is exceeded!
+			return false;
+		}
+		state.digit_count++;
+		if (NEGATIVE) {
+			if (state.result < (NumericLimits<typename T::StoreType>::Minimum() / 10)) {
+				return false;
+			}
+			state.result = state.result * 10 - digit;
+		} else {
+			if (state.result > (NumericLimits<typename T::StoreType>::Maximum() / 10)) {
+				return false;
+			}
+			state.result = state.result * 10 + digit;
+		}
+		return true;
+	}
+
+	template <class T, bool NEGATIVE>
+	static bool HandleHexDigit(T &state, uint8_t digit) {
+		return false;
+	}
+
+	template <class T, bool NEGATIVE>
+	static bool HandleBinaryDigit(T &state, uint8_t digit) {
+		return false;
+	}
+
+	template <class T, bool NEGATIVE>
+	static void RoundUpResult(T &state) {
+		if (NEGATIVE) {
+			state.result -= 1;
+		} else {
+			state.result += 1;
+		}
+	}
+
+	template <class T, bool NEGATIVE>
+	static bool HandleExponent(T &state, int32_t exponent) {
+		auto decimal_excess = (state.decimal_count > state.scale) ? state.decimal_count - state.scale : 0;
+		if (exponent > 0) {
+			state.exponent_type = ExponentType::POSITIVE;
+			// Positive exponents need up to 'exponent' amount of digits
+			// Everything beyond that amount needs to be truncated
+			if (decimal_excess > exponent) {
+				// We've allowed too many decimals
+				state.excessive_decimals = UnsafeNumericCast<uint8_t>(decimal_excess - exponent);
+				exponent = 0;
+			} else {
+				exponent -= decimal_excess;
+			}
+			D_ASSERT(exponent >= 0);
+		} else if (exponent < 0) {
+			state.exponent_type = ExponentType::NEGATIVE;
+		}
+		if (!Finalize<T, NEGATIVE>(state)) {
+			return false;
+		}
+		if (exponent < 0) {
+			bool round_up = false;
+			for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
+				auto mod = state.result % 10;
+				round_up = NEGATIVE ? mod <= -5 : mod >= 5;
+				state.result /= 10;
+				if (state.result == 0) {
+					break;
+				}
+			}
+			if (round_up) {
+				RoundUpResult<T, NEGATIVE>(state);
+			}
+			return true;
+		} else {
+			// positive exponent: append 0's
+			for (idx_t i = 0; i < idx_t(exponent); i++) {
+				if (!HandleDigit<T, NEGATIVE>(state, 0)) {
+					return false;
+				}
+			}
+			return true;
+		}
+	}
+
+	template <class T, bool NEGATIVE, bool ALLOW_EXPONENT>
+	static bool HandleDecimal(T &state, uint8_t digit) {
+		if (state.decimal_count == state.scale && !state.round_set) {
+			// Determine whether the last registered decimal should be rounded or not
+			state.round_set = true;
+			state.should_round = digit >= 5;
+		}
+		if (!ALLOW_EXPONENT && state.decimal_count == state.scale) {
+			// we exceeded the amount of supported decimals
+			// however, we don't throw an error here
+			// we just truncate the decimal
+			return true;
+		}
+		//! If we expect an exponent, we need to preserve the decimals
+		//! But we don't want to overflow, so we prevent overflowing the result with this check
+		if (state.digit_count + state.decimal_count >= DecimalWidth<decltype(state.result)>::max) {
+			return true;
+		}
+		state.decimal_count++;
+		if (NEGATIVE) {
+			state.result = state.result * 10 - digit;
+		} else {
+			state.result = state.result * 10 + digit;
+		}
+		return true;
+	}
+
+	template <class T, bool NEGATIVE>
+	static bool TruncateExcessiveDecimals(T &state) {
+		D_ASSERT(state.excessive_decimals);
+		bool round_up = false;
+		for (idx_t i = 0; i < state.excessive_decimals; i++) {
+			auto mod = state.result % 10;
+			round_up = NEGATIVE ? mod <= -5 : mod >= 5;
+			state.result /= static_cast<typename T::StoreType>(10.0);
+		}
+		//! Only round up when exponents are involved
+		if (state.exponent_type == ExponentType::POSITIVE && round_up) {
+			RoundUpResult<T, NEGATIVE>(state);
+		}
+		D_ASSERT(state.decimal_count > state.scale);
+		state.decimal_count = state.scale;
+		return true;
+	}
+
+	template <class T, bool NEGATIVE>
+	static bool Finalize(T &state) {
+		if (state.exponent_type != ExponentType::POSITIVE && state.decimal_count > state.scale) {
+			//! Did not encounter an exponent, but ALLOW_EXPONENT was on
+			state.excessive_decimals = state.decimal_count - state.scale;
+		}
+		if (state.excessive_decimals && !TruncateExcessiveDecimals<T, NEGATIVE>(state)) {
+			return false;
+		}
+		if (state.exponent_type == ExponentType::NONE && state.round_set && state.should_round) {
+			RoundUpResult<T, NEGATIVE>(state);
+		}
+		//  if we have not gotten exactly "scale" decimals, we need to multiply the result
+		//  e.g. if we have a string "1.0" that is cast to a DECIMAL(9,3), the value needs to be 1000
+		//  but we have only gotten the value "10" so far, so we multiply by 1000
+		for (uint8_t i = state.decimal_count; i < state.scale; i++) {
+			state.result *= 10;
+		}
+		return true;
+	}
+};
+
+template <class T, char decimal_separator = '.'>
+bool TryDecimalStringCast(string_t input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
+	return TryDecimalStringCast<T, decimal_separator>(input.GetData(), input.GetSize(), result, parameters, width,
+	                                                  scale);
+}
+
+template <class T, char decimal_separator = '.'>
+bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result, CastParameters &parameters,
+                          uint8_t width, uint8_t scale) {
+	DecimalCastData<T> state;
+	state.result = 0;
+	state.width = width;
+	state.scale = scale;
+	state.digit_count = 0;
+	state.decimal_count = 0;
+	state.excessive_decimals = 0;
+	state.exponent_type = ExponentType::NONE;
+	state.round_set = false;
+	state.should_round = false;
+	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
+	        string_ptr, string_size, state, false)) {
+		string_t value(string_ptr, (uint32_t)string_size);
+		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", value.GetString(),
+		                                  (int)width, (int)scale);
+		HandleCastError::AssignError(error, parameters);
+		return false;
+	}
+	result = state.result;
+	return true;
+}
+
+template <class T, char decimal_separator = '.'>
+bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result, uint8_t width, uint8_t scale) {
+	DecimalCastData<T> state;
+	state.result = 0;
+	state.width = width;
+	state.scale = scale;
+	state.digit_count = 0;
+	state.decimal_count = 0;
+	state.excessive_decimals = 0;
+	state.exponent_type = ExponentType::NONE;
+	state.round_set = false;
+	state.should_round = false;
+	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
+	        string_ptr, string_size, state, false)) {
+		return false;
+	}
+	result = state.result;
+	return true;
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp

@@ -234,7 +234,8 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 					if (!StringUtil::CharacterIsDigit(buf[pos])) {
 						break;
 					}
-					if (!OP::template HandleDecimal<T, NEGATIVE, ALLOW_EXPONENT>(result, buf[pos] - '0')) {
+					if (!OP::template HandleDecimal<T, NEGATIVE, ALLOW_EXPONENT>(
+					        result, UnsafeNumericCast<uint8_t>(buf[pos] - '0'))) {
 						return false;
 					}
 					pos++;
@@ -296,7 +297,7 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 			}
 			return false;
 		}
-		uint8_t digit = buf[pos++] - '0';
+		auto digit = UnsafeNumericCast<uint8_t>(buf[pos++] - '0');
 		if (!OP::template HandleDigit<T, NEGATIVE>(result, digit)) {
 			return false;
 		}
@@ -330,9 +331,9 @@ static bool IntegerHexCastLoop(const char *buf, idx_t len, T &result, bool stric
 		}
 		uint8_t digit;
 		if (current_char >= 'a') {
-			digit = current_char - 'a' + 10;
+			digit = UnsafeNumericCast<uint8_t>(current_char - 'a' + 10);
 		} else {
-			digit = current_char - '0';
+			digit = UnsafeNumericCast<uint8_t>(current_char - '0');
 		}
 		pos++;
 

package/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp

@@ -75,7 +75,7 @@ bool TryCastWithOverflowCheckFloat(SRC value, T &result, SRC min, SRC max) {
 		return false;
 	}
 	// PG FLOAT => INT casts use statistical rounding.
-	result = std::nearbyint(value);
+	result = static_cast<T>(std::nearbyint(value));
 	return true;
 }
 
@@ -182,7 +182,7 @@ bool TryCastWithOverflowCheck(double input, float &result) {
 		return true;
 	}
 	auto res = float(input);
-	if (!Value::FloatIsFinite(input)) {
+	if (!Value::FloatIsFinite(res)) {
 		return false;
 	}
 	result = res;

package/src/duckdb/src/include/duckdb/common/optional_ptr.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
 
@@ -20,8 +21,12 @@ public:
 	}
 	optional_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
 	}
+	optional_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference
+	}
 	optional_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
 	}
+	optional_ptr(const shared_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer
+	}
 
 	void CheckValid() const {
 		if (!ptr) {