duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/http_util.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+
+namespace duckdb {
+
+class HTTPUtil {
+public:
+	static void ParseHTTPProxyHost(string &proxy_value, string &hostname_out, idx_t &port_out, idx_t default_port = 80);
+};
+} // namespace duckdb

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

@@ -8,13 +8,13 @@
 
 #pragma once
 
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/string.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/helper.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/helper.hpp"
 #include "duckdb/common/pair.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
 
@@ -59,6 +59,14 @@ public:
 		return map.end();
 	}
 
+	typename VECTOR_TYPE::reverse_iterator rbegin() { // NOLINT: match stl API
+		return map.rbegin();
+	}
+
+	typename VECTOR_TYPE::reverse_iterator rend() { // NOLINT: match stl API
+		return map.rend();
+	}
+
 	typename VECTOR_TYPE::iterator find(const string &key) { // NOLINT: match stl API
 		auto entry = map_idx.find(key);
 		if (entry == map_idx.end()) {
@@ -92,9 +100,14 @@ public:
 		map_idx[key] = map.size() - 1;
 	}
 
+	void insert(const string &key, V &&value) { // NOLINT: match stl API
+		map.push_back(make_pair(key, std::move(value)));
+		map_idx[key] = map.size() - 1;
+	}
+
 	void insert(pair<string, V> &&value) { // NOLINT: match stl API
+		map_idx[value.first] = map.size();
 		map.push_back(std::move(value));
-		map_idx[value.first] = map.size() - 1;
 	}
 
 	void erase(typename VECTOR_TYPE::iterator it) { // NOLINT: match stl API

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

@@ -32,6 +32,9 @@ struct NumericLimits {
 	static constexpr bool IsSigned() {
 		return std::is_signed<T>::value;
 	}
+	static constexpr bool IsIntegral() {
+		return std::is_integral<T>::value || std::is_enum<T>::value;
+	}
 	static constexpr idx_t Digits();
 };
 
@@ -46,7 +49,9 @@ struct NumericLimits<hugeint_t> {
 	static constexpr bool IsSigned() {
 		return true;
 	}
-
+	static constexpr bool IsIntegral() {
+		return true;
+	}
 	static constexpr idx_t Digits() {
 		return 39;
 	}
@@ -63,7 +68,9 @@ struct NumericLimits<uhugeint_t> {
 	static constexpr bool IsSigned() {
 		return false;
 	}
-
+	static constexpr bool IsIntegral() {
+		return true;
+	}
 	static constexpr idx_t Digits() {
 		return 39;
 	}

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/multi_file_reader_options.hpp"
+#include "duckdb/common/extra_operator_info.hpp"
 
 namespace duckdb {
 class MultiFileList;
@@ -51,6 +52,17 @@ public:
 	MultiFileListIterator end();   // NOLINT: match stl API
 };
 
+struct MultiFilePushdownInfo {
+	explicit MultiFilePushdownInfo(LogicalGet &get);
+	MultiFilePushdownInfo(idx_t table_index, const vector<string> &column_names, const vector<column_t> &column_ids,
+	                      ExtraOperatorInfo &extra_info);
+
+	idx_t table_index;
+	const vector<string> &column_names;
+	const vector<column_t> &column_ids;
+	ExtraOperatorInfo &extra_info;
+};
+
 //! Abstract class for lazily generated list of file paths/globs
 //! NOTE: subclasses are responsible for ensuring thread-safety
 class MultiFileList {
@@ -77,12 +89,20 @@ public:
 	//! Virtual functions for subclasses
 public:
 	virtual unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context,
-	                                                        const MultiFileReaderOptions &options, LogicalGet &get,
+	                                                        const MultiFileReaderOptions &options,
+	                                                        MultiFilePushdownInfo &info,
 	                                                        vector<unique_ptr<Expression>> &filters);
+	virtual unique_ptr<MultiFileList>
+	DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options, const vector<string> &names,
+	                      const vector<LogicalType> &types, const vector<column_t> &column_ids,
+	                      TableFilterSet &filters) const;
+
 	virtual vector<string> GetAllFiles() = 0;
 	virtual FileExpandResult GetExpandResult() = 0;
 	virtual idx_t GetTotalFileCount() = 0;
 
+	virtual unique_ptr<NodeStatistics> GetCardinality(ClientContext &context);
+
 protected:
 	//! Get the i-th expanded file
 	virtual string GetFile(idx_t i) = 0;
@@ -102,7 +122,12 @@ public:
 	explicit SimpleMultiFileList(vector<string> paths);
 	//! Copy `paths` to `filtered_files` and apply the filters
 	unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                LogicalGet &get, vector<unique_ptr<Expression>> &filters) override;
+	                                                MultiFilePushdownInfo &info,
+	                                                vector<unique_ptr<Expression>> &filters) override;
+	unique_ptr<MultiFileList> DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
+	                                                const vector<string> &names, const vector<LogicalType> &types,
+	                                                const vector<column_t> &column_ids,
+	                                                TableFilterSet &filters) const override;
 
 	//! Main MultiFileList API
 	vector<string> GetAllFiles() override;
@@ -120,7 +145,12 @@ public:
 	GlobMultiFileList(ClientContext &context, vector<string> paths, FileGlobOptions options);
 	//! Calls ExpandAll, then prunes the expanded_files using the hive/filename filters
 	unique_ptr<MultiFileList> ComplexFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
-	                                                LogicalGet &get, vector<unique_ptr<Expression>> &filters) override;
+	                                                MultiFilePushdownInfo &info,
+	                                                vector<unique_ptr<Expression>> &filters) override;
+	unique_ptr<MultiFileList> DynamicFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options,
+	                                                const vector<string> &names, const vector<LogicalType> &types,
+	                                                const vector<column_t> &column_ids,
+	                                                TableFilterSet &filters) const override;
 
 	//! Main MultiFileList API
 	vector<string> GetAllFiles() override;
@@ -134,9 +164,11 @@ protected:
 	//! Get the i-th expanded file
 	string GetFileInternal(idx_t i);
 	//! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand
-	bool ExpandPathInternal();
+	bool ExpandNextPath();
+	//! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand
+	bool ExpandPathInternal(idx_t &current_path, vector<string> &result) const;
 	//! Whether all files have been expanded
-	bool IsFullyExpanded();
+	bool IsFullyExpanded() const;
 
 	//! The ClientContext for globbing
 	ClientContext &context;
@@ -145,7 +177,7 @@ protected:
 	//! The expanded files
 	vector<string> expanded_files;
 
-	mutex lock;
+	mutable mutex lock;
 };
 
 } // namespace duckdb

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

@@ -121,6 +121,9 @@ struct MultiFileReader {
 	//! Create a default MultiFileReader, function_name is used for errors
 	DUCKDB_API static unique_ptr<MultiFileReader> CreateDefault(const string &function_name = "");
 
+	//! Create a LIST Value from a vector of strings (list of file paths)
+	static Value CreateValueFromFileList(const vector<string> &files);
+
 	//! 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);
 	//! Creates a table function set from a single reader function (including e.g. list parameters, etc)
@@ -142,8 +145,12 @@ struct MultiFileReader {
 	//! 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,
+	                                                                   MultiFilePushdownInfo &info,
 	                                                                   vector<unique_ptr<Expression>> &filters);
+	DUCKDB_API virtual unique_ptr<MultiFileList>
+	DynamicFilterPushdown(ClientContext &context, const MultiFileList &files, const MultiFileReaderOptions &options,
+	                      const vector<string> &names, const vector<LogicalType> &types,
+	                      const vector<column_t> &column_ids, TableFilterSet &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.
@@ -209,7 +216,7 @@ struct MultiFileReader {
 		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]);
+		result.Initialize(context, result.union_readers[0]);
 		D_ASSERT(names.size() == return_types.size());
 		return bind_data;
 	}

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

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "duckdb/common/types.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/hive_partitioning.hpp"
+#include "duckdb/common/types.hpp"
 #include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
@@ -25,6 +25,9 @@ struct MultiFileReaderOptions {
 	bool hive_types_autocast = true;
 	case_insensitive_map_t<LogicalType> hive_types_schema;
 
+	// Default/configurable name of the column containing the file names
+	static constexpr const char *DEFAULT_FILENAME_COLUMN = "filename";
+	string filename_column = DEFAULT_FILENAME_COLUMN;
 	// These are used to pass options through custom multifilereaders
 	case_insensitive_map_t<Value> custom_options;
 
@@ -37,6 +40,7 @@ struct MultiFileReaderOptions {
 	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;
+	DUCKDB_API bool AnySet();
 };
 
 } // namespace duckdb

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

@@ -45,84 +45,116 @@ struct MakeUnsigned<uhugeint_t> {
 	using type = uhugeint_t;
 };
 
-template <class T>
-struct IsIntegral {
-	static constexpr bool value = std::is_integral<T>::value;
-};
-
-template <>
-struct IsIntegral<hugeint_t> {
-	static constexpr bool value = true;
-};
-
-template <>
-struct IsIntegral<uhugeint_t> {
-	static constexpr bool value = true;
-};
-
 template <class TO, class FROM>
 static void ThrowNumericCastError(FROM in, TO minval, TO maxval) {
 	throw InternalException("Information loss on integer cast: value %d outside of target range [%d, %d]", in, minval,
 	                        maxval);
 }
 
+template <class TO, class FROM, bool are_same_type>
+struct NumericCastImpl;
+
 template <class TO, class FROM>
-TO NumericCast(FROM val) {
-	if (std::is_same<TO, FROM>::value) {
+struct NumericCastImpl<TO, FROM, true> {
+	static TO Convert(FROM val) {
 		return static_cast<TO>(val);
 	}
-	// some dance around signed-unsigned integer comparison below
-	auto minval = NumericLimits<TO>::Minimum();
-	auto maxval = NumericLimits<TO>::Maximum();
-	auto unsigned_in = static_cast<typename MakeUnsigned<FROM>::type>(val);
-	auto unsigned_min = static_cast<typename MakeUnsigned<TO>::type>(minval);
-	auto unsigned_max = static_cast<typename MakeUnsigned<TO>::type>(maxval);
-	auto signed_in = static_cast<typename MakeSigned<FROM>::type>(val);
-	auto signed_min = static_cast<typename MakeSigned<TO>::type>(minval);
-	auto signed_max = static_cast<typename MakeSigned<TO>::type>(maxval);
-
-	if (std::is_unsigned<FROM>() && std::is_unsigned<TO>() &&
-	    (unsigned_in < unsigned_min || unsigned_in > unsigned_max)) {
-		ThrowNumericCastError(val, minval, maxval);
-	}
+};
 
-	if (std::is_signed<FROM>() && std::is_signed<TO>() && (signed_in < signed_min || signed_in > signed_max)) {
-		ThrowNumericCastError(val, minval, maxval);
-	}
+template <class TO, class FROM>
+struct NumericCastImpl<TO, FROM, false> {
+	static TO Convert(FROM val) {
+		// some dance around signed-unsigned integer comparison below
+		auto minval = NumericLimits<TO>::Minimum();
+		auto maxval = NumericLimits<TO>::Maximum();
+		auto unsigned_in = static_cast<typename MakeUnsigned<FROM>::type>(val);
+		auto unsigned_min = static_cast<typename MakeUnsigned<TO>::type>(minval);
+		auto unsigned_max = static_cast<typename MakeUnsigned<TO>::type>(maxval);
+		auto signed_in = static_cast<typename MakeSigned<FROM>::type>(val);
+		auto signed_min = static_cast<typename MakeSigned<TO>::type>(minval);
+		auto signed_max = static_cast<typename MakeSigned<TO>::type>(maxval);
+
+		if (!NumericLimits<FROM>::IsSigned() && !NumericLimits<TO>::IsSigned() &&
+		    (unsigned_in < unsigned_min || unsigned_in > unsigned_max)) {
+			ThrowNumericCastError(val, minval, maxval);
+		}
+
+		if (NumericLimits<FROM>::IsSigned() && NumericLimits<TO>::IsSigned() &&
+		    (signed_in < signed_min || signed_in > signed_max)) {
+			ThrowNumericCastError(val, minval, maxval);
+		}
+
+		if (NumericLimits<FROM>::IsSigned() != NumericLimits<TO>::IsSigned() &&
+		    (signed_in < signed_min || unsigned_in > unsigned_max)) {
+			ThrowNumericCastError(val, minval, maxval);
+		}
 
-	if (std::is_signed<FROM>() != std::is_signed<TO>() && (signed_in < signed_min || unsigned_in > unsigned_max)) {
-		ThrowNumericCastError(val, minval, maxval);
+		return static_cast<TO>(val);
 	}
+};
 
-	return static_cast<TO>(val);
+// NumericCast
+// When: between same types, or when both types are integral
+// Checks: perform checked casts on range
+template <class TO, class FROM,
+          class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) ||
+                                          std::is_same<TO, FROM>::value>::type>
+TO NumericCast(FROM val) {
+	return NumericCastImpl<TO, FROM, std::is_same<TO, FROM>::value>::Convert(val);
 }
 
+// UnsafeNumericCast
+// When: between same types, or when both types are integral
+// Checks: perform checked casts on range (in DEBUG) otherwise no checks
+template <class TO, class FROM,
+          class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) ||
+                                          std::is_same<TO, FROM>::value>::type>
+TO UnsafeNumericCast(FROM in) {
+#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
+	return NumericCast<TO, FROM>(in);
+#endif
+	return static_cast<TO>(in);
+}
+
+// LossyNumericCast
+// When: between double/float to other convertible types
+// Checks: no checks performed (at the moment, to be improved adding range checks)
 template <class TO>
-TO NumericCast(double val) {
+TO LossyNumericCast(double val) {
 	return static_cast<TO>(val);
 }
 
 template <class TO>
-TO NumericCast(float val) {
+TO LossyNumericCast(float val) {
 	return static_cast<TO>(val);
 }
 
-template <class TO, class FROM>
-TO UnsafeNumericCast(FROM in) {
-#ifdef DEBUG
-	return NumericCast<TO, FROM>(in);
-#endif
-	return static_cast<TO>(in);
-}
+// ExactNumericCast
+// When: between double/float to other convertible types
+// Checks: perform checks that casts are invertible (in DEBUG) otherwise no checks
 
 template <class TO>
-TO UnsafeNumericCast(double val) {
-	return NumericCast<TO>(val);
+TO ExactNumericCast(double val) {
+	auto res = LossyNumericCast<TO>(val);
+#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
+	if (val != double(res)) {
+		throw InternalException("Information loss on double cast: value %lf outside of target range [%lf, %lf]", val,
+		                        double(res), double(res));
+	}
+#endif
+	return res;
 }
 
 template <class TO>
-TO UnsafeNumericCast(float val) {
-	return NumericCast<TO>(val);
+TO ExactNumericCast(float val) {
+	auto res = LossyNumericCast<TO>(val);
+#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
+	if (val != float(res)) {
+		throw InternalException("Information loss on float cast: value %f outside of target range [%f, %f]", val,
+		                        float(res), float(res));
+	}
+#endif
+	return res;
 }
 
 } // namespace duckdb

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/limits.hpp"
+#include <cmath>
 
 namespace duckdb {
 
@@ -21,6 +22,16 @@ struct AbsOperator {
 	}
 };
 
+template <>
+inline float AbsOperator::Operation(float input) {
+	return std::fabs(input);
+}
+
+template <>
+inline double AbsOperator::Operation(double input) {
+	return std::fabs(input);
+}
+
 template <>
 inline hugeint_t AbsOperator::Operation(hugeint_t input) {
 	const hugeint_t zero(0);

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

@@ -596,7 +596,11 @@ DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &resu
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, timestamp_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(string_t input, timestamp_ns_t &result, bool strict);
+template <>
 timestamp_t Cast::Operation(string_t input);
+template <>
+timestamp_ns_t Cast::Operation(string_t input);
 //===--------------------------------------------------------------------===//
 // String -> Interval Casts
 //===--------------------------------------------------------------------===//
@@ -628,14 +632,14 @@ struct TryCastToTimestampSec {
 };
 
 template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool strict);
+DUCKDB_API bool TryCastToTimestampNS::Operation(string_t input, timestamp_ns_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict);
 
 template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict);
+DUCKDB_API bool TryCastToTimestampNS::Operation(date_t input, timestamp_ns_t &result, bool strict);
 template <>
 DUCKDB_API bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict);
 template <>
@@ -799,7 +803,7 @@ template <>
 duckdb::timestamp_t CastTimestampSecToNs::Operation(duckdb::timestamp_t input);
 
 template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result);
+duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_ns_t input, Vector &result);
 template <>
 duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result);
 template <>

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

@@ -464,6 +464,21 @@ string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_
 //===--------------------------------------------------------------------===//
 enum class ExponentType : uint8_t { NONE, POSITIVE, NEGATIVE };
 
+template <typename T>
+struct DecimalCastTraits {
+	using POWERS_OF_TEN_CLASS = NumericHelper;
+};
+
+template <>
+struct DecimalCastTraits<hugeint_t> {
+	using POWERS_OF_TEN_CLASS = Hugeint;
+};
+
+template <>
+struct DecimalCastTraits<uhugeint_t> {
+	using POWERS_OF_TEN_CLASS = Uhugeint;
+};
+
 template <class T>
 struct DecimalCastData {
 	using StoreType = T;
@@ -479,6 +494,7 @@ struct DecimalCastData {
 	//! Only set when ALLOW_EXPONENT is enabled
 	uint8_t excessive_decimals;
 	ExponentType exponent_type;
+	StoreType limit;
 };
 
 struct DecimalCastOperation {
@@ -635,7 +651,11 @@ struct DecimalCastOperation {
 		for (uint8_t i = state.decimal_count; i < state.scale; i++) {
 			state.result *= 10;
 		}
-		return true;
+		if (NEGATIVE) {
+			return state.result > -state.limit;
+		} else {
+			return state.result < state.limit;
+		}
 	}
 };
 
@@ -658,6 +678,7 @@ bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result,
 	state.exponent_type = ExponentType::NONE;
 	state.round_set = false;
 	state.should_round = false;
+	state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
 	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);
@@ -682,6 +703,7 @@ bool TryDecimalStringCast(const char *string_ptr, idx_t string_size, T &result,
 	state.exponent_type = ExponentType::NONE;
 	state.round_set = false;
 	state.should_round = false;
+	state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
 	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
 	        string_ptr, string_size, state, false)) {
 		return false;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb.h"
 #include "fast_float/fast_float.h"
+#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 template <class T>
@@ -37,7 +38,7 @@ static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict, ch
 		}
 	}
 	auto endptr = buf + len;
-	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result, decimal_separator);
+	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result, strict, decimal_separator);
 	if (parse_result.ec != std::errc()) {
 		return false;
 	}

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

@@ -302,7 +302,7 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 			return false;
 		}
 
-		if (pos != len && buf[pos] == '_') {
+		if (pos != len && buf[pos] == '_' && !strict) {
 			// Skip one underscore if it is not the last character and followed by a digit
 			pos++;
 			if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {

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

@@ -19,6 +19,10 @@
 
 namespace duckdb {
 
+//! Note: this should not be included directly, when these methods are required
+//! They should be used through the TryCast:: methods defined in 'cast_operators.hpp'
+//! This file produces 'unused static method' warnings/errors when included
+
 template <class SRC, class DST>
 static bool TryCastWithOverflowCheck(SRC value, DST &result) {
 	if (!Value::IsFinite<SRC>(value)) {

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

@@ -61,6 +61,8 @@ template <>
 DUCKDB_API duckdb::string_t StringCast::Operation(dtime_t input, Vector &result);
 template <>
 DUCKDB_API duckdb::string_t StringCast::Operation(timestamp_t input, Vector &result);
+template <>
+DUCKDB_API duckdb::string_t StringCast::Operation(timestamp_ns_t input, Vector &result);
 
 //! Temporary casting for Time Zone types. TODO: turn casting into functions.
 struct StringCastTZ {

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

@@ -9,15 +9,15 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/unique_ptr.hpp"
 #include "duckdb/common/shared_ptr.hpp"
+#include "duckdb/common/unique_ptr.hpp"
 
 namespace duckdb {
 
-template <class T>
+template <class T, bool SAFE = true>
 class optional_ptr { // NOLINT: mimic std casing
 public:
-	optional_ptr() : ptr(nullptr) {
+	optional_ptr() noexcept : ptr(nullptr) {
 	}
 	optional_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
 	}
@@ -29,8 +29,10 @@ public:
 	}
 
 	void CheckValid() const {
-		if (!ptr) {
-			throw InternalException("Attempting to dereference an optional pointer that is not set");
+		if (MemorySafety<SAFE>::ENABLED) {
+			if (!ptr) {
+				throw InternalException("Attempting to dereference an optional pointer that is not set");
+			}
 		}
 	}
 
@@ -79,4 +81,7 @@ private:
 	T *ptr;
 };
 
+template <typename T>
+using unsafe_optional_ptr = optional_ptr<T, false>;
+
 } // namespace duckdb

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/unique_ptr.hpp"
 
 namespace duckdb {