duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/include/duckdb/common/enums/prepared_statement_mode.hpp

@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/prepared_statement_mode.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class PreparedStatementMode : uint8_t {
+	PREPARE_ONLY,
+	PREPARE_AND_EXECUTE,
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -65,6 +65,8 @@ struct StatementProperties {
 	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0), always_require_rebind(false) {
 	}
 
+	//! The set of databases this statement will read from
+	unordered_set<string> read_databases;
 	//! The set of databases this statement will modify
 	unordered_set<string> modified_databases;
 	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the

package/src/duckdb/src/include/duckdb/common/exception/conversion_exception.hpp

@@ -9,12 +9,14 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/optional_idx.hpp"
 
 namespace duckdb {
 
 class ConversionException : public Exception {
 public:
 	DUCKDB_API explicit ConversionException(const string &msg);
+	DUCKDB_API explicit ConversionException(optional_idx error_location, const string &msg);
 	DUCKDB_API ConversionException(const PhysicalType origType, const PhysicalType newType);
 	DUCKDB_API ConversionException(const LogicalType &origType, const LogicalType &newType);
 
@@ -22,6 +24,10 @@ public:
 	explicit ConversionException(const string &msg, Args... params)
 	    : ConversionException(ConstructMessage(msg, params...)) {
 	}
+	template <typename... Args>
+	explicit ConversionException(optional_idx error_location, const string &msg, Args... params)
+	    : ConversionException(error_location, ConstructMessage(msg, params...)) {
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/exception/parser_exception.hpp

@@ -22,6 +22,10 @@ public:
 	template <typename... Args>
 	explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) {
 	}
+	template <typename... Args>
+	explicit ParserException(optional_idx error_location, const string &msg, Args... params)
+	    : ParserException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) {
+	}
 
 	static ParserException SyntaxError(const string &query, const string &error_message, optional_idx error_location);
 };

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

@@ -339,6 +339,8 @@ class TypeMismatchException : public Exception {
 public:
 	DUCKDB_API TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg);
 	DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
+	DUCKDB_API TypeMismatchException(optional_idx error_location, const LogicalType &type_1, const LogicalType &type_2,
+	                                 const string &msg);
 	DUCKDB_API
 	TypeMismatchException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized
 };

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

@@ -45,7 +45,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -190,8 +190,8 @@ private:
 
 struct ArrayTypeInfo : public ExtraTypeInfo {
 	LogicalType child_type;
-	idx_t size;
-	explicit ArrayTypeInfo(LogicalType child_type_p, idx_t size_p);
+	uint32_t size;
+	explicit ArrayTypeInfo(LogicalType child_type_p, uint32_t size_p);
 
 public:
 	void Serialize(Serializer &serializer) const override;

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/string.hpp"
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -27,14 +28,14 @@ public:
 	}
 	virtual ~FileOpener() {};
 
-	virtual bool TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info);
-	virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0;
+	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info);
+	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) = 0;
 	virtual ClientContext *TryGetClientContext() = 0;
 
 	DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener);
-	DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
-	DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result,
-	                                            FileOpenerInfo &info);
+	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
+	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result,
+	                                                           FileOpenerInfo &info);
 };
 
 } // namespace duckdb

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/constants.hpp"
+#include "duckdb/common/common.hpp"
 #include "duckdb/common/enums/file_compression_type.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_buffer.hpp"
@@ -80,7 +80,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -110,6 +110,8 @@ public:
 	static constexpr uint8_t FILE_FLAGS_FILE_CREATE_NEW = 1 << 4;
 	//! Open file in append mode
 	static constexpr uint8_t FILE_FLAGS_APPEND = 1 << 5;
+	//! Open file with restrictive permissions (600 on linux/mac) can only be used when creating, throws if file exists
+	static constexpr uint8_t FILE_FLAGS_PRIVATE = 1 << 6;
 };
 
 class FileSystem {

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

@@ -220,4 +220,11 @@ bool RefersToSameObject(const T &A, const T &B) {
 	return &A == &B;
 }
 
+template<class T, class SRC>
+void DynamicCastCheck(SRC *source) {
+#ifndef __APPLE__
+	D_ASSERT(dynamic_cast<T *>(source));
+#endif
+}
+
 } // namespace duckdb

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

@@ -29,10 +29,10 @@ struct NumericLimits {
 	static constexpr T Maximum() {
 		return std::numeric_limits<T>::max();
 	}
-	DUCKDB_API static constexpr bool IsSigned() {
+	static constexpr bool IsSigned() {
 		return std::is_signed<T>::value;
 	}
-	DUCKDB_API static constexpr idx_t Digits();
+	static constexpr idx_t Digits();
 };
 
 template <>

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

@@ -90,6 +90,9 @@ public:
 	//! systems.
 	static std::string GetLastErrorAsString();
 
+	//! Checks a file is private (checks for 600 on linux/macos, TODO: currently always returns true on windows)
+	static bool IsPrivateFile(const string &path_p, FileOpener *opener);
+
 private:
 	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
 	void SetFilePointer(FileHandle &handle, idx_t location);

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

@@ -9,7 +9,9 @@
 #pragma once
 
 #include <type_traits>
+
 #include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/limits.hpp"
 
 namespace duckdb {
 
@@ -58,4 +60,66 @@ 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>
+TO NumericCast(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 (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);
+	}
+
+	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);
+}
+
+template <class TO>
+TO NumericCast(double val) {
+	return static_cast<TO>(val);
+}
+
+template <class TO>
+TO NumericCast(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);
+}
+
+template <class TO>
+TO UnsafeNumericCast(double val) {
+	return NumericCast<TO>(val);
+}
+
+template <class TO>
+TO UnsafeNumericCast(float val) {
+	return NumericCast<TO>(val);
+}
+
 } // namespace duckdb

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

@@ -21,8 +21,10 @@
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
+#include "duckdb/function/cast/default_casts.hpp"
 
 namespace duckdb {
+struct CastParameters;
 struct ValidityMask;
 class Vector;
 
@@ -35,15 +37,17 @@ struct TryCast {
 
 struct TryCastErrorMessage {
 	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
-		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
+	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
+		throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)",
+		                              GetTypeId<SRC>(), GetTypeId<DST>());
 	}
 };
 
 struct TryCastErrorMessageCommaSeparated {
 	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
-		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
+	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
+		throw NotImplementedException(parameters.query_location, "Unimplemented type for cast (%s -> %s)",
+		                              GetTypeId<SRC>(), GetTypeId<DST>());
 	}
 };
 
@@ -74,9 +78,11 @@ struct Cast {
 };
 
 struct HandleCastError {
-	static void AssignError(const string &error_message, string *error_message_ptr) {
+	static void AssignError(const string &error_message, CastParameters &parameters);
+	static void AssignError(const string &error_message, string *error_message_ptr,
+	                        optional_idx error_location = optional_idx()) {
 		if (!error_message_ptr) {
-			throw ConversionException(error_message);
+			throw ConversionException(error_location, error_message);
 		}
 		if (error_message_ptr->empty()) {
 			*error_message_ptr = error_message;
@@ -504,15 +510,14 @@ DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict);
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, CastParameters &parameters);
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, CastParameters &parameters);
 template <>
-DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message,
-                                                             bool strict);
+DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, CastParameters &parameters);
 template <>
-DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message,
-                                                             bool strict);
+DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result,
+                                                             CastParameters &parameters);
 
 //===--------------------------------------------------------------------===//
 // Date Casts
@@ -560,7 +565,7 @@ DUCKDB_API bool TryCast::Operation(interval_t input, interval_t &result, bool st
 // String -> Date Casts
 //===--------------------------------------------------------------------===//
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters &parameters);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, date_t &result, bool strict);
 template <>
@@ -569,7 +574,7 @@ date_t Cast::Operation(string_t input);
 // String -> Time Casts
 //===--------------------------------------------------------------------===//
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, CastParameters &parameters);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, dtime_t &result, bool strict);
 template <>
@@ -578,7 +583,7 @@ dtime_t Cast::Operation(string_t input);
 // String -> TimeTZ Casts
 //===--------------------------------------------------------------------===//
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, CastParameters &parameters);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict);
 template <>
@@ -587,7 +592,7 @@ dtime_tz_t Cast::Operation(string_t input);
 // String -> Timestamp Casts
 //===--------------------------------------------------------------------===//
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters &parameters);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, timestamp_t &result, bool strict);
 template <>
@@ -596,7 +601,7 @@ timestamp_t Cast::Operation(string_t input);
 // String -> Interval Casts
 //===--------------------------------------------------------------------===//
 template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict);
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, CastParameters &parameters);
 
 //===--------------------------------------------------------------------===//
 // string -> Non-Standard Timestamps
@@ -823,14 +828,12 @@ string_t CastFromBlobToBit::Operation(string_t input, Vector &result);
 
 struct TryCastToBlob {
 	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
-	                             bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
 		throw InternalException("Unsupported type for try cast to blob");
 	}
 };
 template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                              bool strict);
+bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters);
 
 //===--------------------------------------------------------------------===//
 // Bits
@@ -846,24 +849,25 @@ duckdb::string_t CastFromBitToString::Operation(duckdb::string_t input, Vector &
 
 struct CastFromBitToNumeric {
 	template <class SRC = string_t, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, CastParameters &parameters) {
 		D_ASSERT(input.GetSize() > 1);
 
 		// TODO: Allow conversion if the significant bytes of the bitstring can be cast to the target type
 		// Currently only allows bitstring -> numeric if the full bitstring fits inside the numeric type
 		if (input.GetSize() - 1 > sizeof(DST)) {
-			throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<DST>());
+			throw ConversionException(parameters.query_location, "Bitstring doesn't fit inside of %s",
+			                          GetTypeId<DST>());
 		}
 		Bit::BitToNumeric(input, result);
 		return (true);
 	}
 };
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict);
+bool CastFromBitToNumeric::Operation(string_t input, bool &result, CastParameters &parameters);
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict);
+bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, CastParameters &parameters);
 template <>
-bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, bool strict);
+bool CastFromBitToNumeric::Operation(string_t input, uhugeint_t &result, CastParameters &parameters);
 
 struct CastFromBitToBlob {
 	template <class SRC>
@@ -875,15 +879,13 @@ struct CastFromBitToBlob {
 
 struct TryCastToBit {
 	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
-	                             bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
 		throw InternalException("Unsupported type for try cast to bit");
 	}
 };
 
 template <>
-bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                             bool strict);
+bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters);
 
 //===--------------------------------------------------------------------===//
 // UUID
@@ -899,15 +901,14 @@ duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector
 
 struct TryCastToUUID {
 	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
-	                             bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, Vector &result_vector, CastParameters &parameters) {
 		throw InternalException("Unsupported type for try cast to uuid");
 	}
 };
 
 template <>
 DUCKDB_API bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector,
-                                         string *error_message, bool strict);
+                                         CastParameters &parameters);
 
 //===--------------------------------------------------------------------===//
 // Pointers