duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -11,7 +11,7 @@
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/exception_format_value.hpp"
 #include "duckdb/common/shared_ptr.hpp"
-#include "duckdb/common/map.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/typedefs.hpp"
 
 #include <vector>
@@ -20,7 +20,12 @@
 namespace duckdb {
 enum class PhysicalType : uint8_t;
 struct LogicalType;
+class Expression;
+class ParsedExpression;
+class QueryErrorContext;
+class TableRef;
 struct hugeint_t;
+class optional_idx;
 
 inline void assert_restrict_function(const void *left_start, const void *left_end, const void *right_start,
                                      const void *right_end, const char *fname, int linenr) {
@@ -81,29 +86,19 @@ enum class ExceptionType {
 	DEPENDENCY = 37,             // dependency
 	HTTP = 38,
 	MISSING_EXTENSION = 39, // Thrown when an extension is used but not loaded
-	AUTOLOAD = 40           // Thrown when an extension is used but not loaded
+	AUTOLOAD = 40,          // Thrown when an extension is used but not loaded
+	SEQUENCE = 41
 };
-class HTTPException;
 
-class Exception : public std::exception {
+class Exception : public std::runtime_error {
 public:
-	DUCKDB_API explicit Exception(const string &msg);
 	DUCKDB_API Exception(ExceptionType exception_type, const string &message);
-
-	ExceptionType type;
+	DUCKDB_API Exception(ExceptionType exception_type, const string &message,
+	                     const unordered_map<string, string> &extra_info);
 
 public:
-	DUCKDB_API const char *what() const noexcept override;
-	DUCKDB_API const string &RawMessage() const;
-
 	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
 	DUCKDB_API static ExceptionType StringToExceptionType(const string &type);
-	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message,
-	                                                           const std::shared_ptr<Exception> &original);
-	virtual std::shared_ptr<Exception> Copy() const {
-		return make_shared<Exception>(type, raw_message_);
-	}
-	DUCKDB_API const HTTPException &AsHTTPException() const;
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
@@ -114,6 +109,21 @@ public:
 		return ConstructMessageRecursive(msg, values, params...);
 	}
 
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const Expression &expr);
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const ParsedExpression &expr);
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const QueryErrorContext &error_context);
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const TableRef &ref);
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(optional_idx error_location);
+	DUCKDB_API static unordered_map<string, string> InitializeExtraInfo(const string &subtype,
+	                                                                    optional_idx error_location);
+
+	DUCKDB_API static string ToJSON(ExceptionType type, const string &message);
+	DUCKDB_API static string ToJSON(ExceptionType type, const string &message,
+	                                const unordered_map<string, string> &extra_info);
+
+	DUCKDB_API static bool InvalidatesTransaction(ExceptionType exception_type);
+	DUCKDB_API static bool InvalidatesDatabase(ExceptionType exception_type);
+
 	DUCKDB_API static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values);
 
 	template <class T, typename... Args>
@@ -130,31 +140,13 @@ public:
 		return (message + "\n" + GetStackTrace());
 	}
 
-private:
-	string exception_message_;
-	string raw_message_;
+	DUCKDB_API static void SetQueryLocation(optional_idx error_location, unordered_map<string, string> &extra_info);
 };
 
 //===--------------------------------------------------------------------===//
 // Exception derived classes
 //===--------------------------------------------------------------------===//
-
-//! Exceptions that are StandardExceptions do NOT invalidate the current transaction when thrown
-class StandardException : public Exception {
-public:
-	DUCKDB_API StandardException(ExceptionType exception_type, const string &message);
-};
-
-class CatalogException : public StandardException {
-public:
-	DUCKDB_API explicit CatalogException(const string &msg);
-
-	template <typename... Args>
-	explicit CatalogException(const string &msg, Args... params) : CatalogException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ConnectionException : public StandardException {
+class ConnectionException : public Exception {
 public:
 	DUCKDB_API explicit ConnectionException(const string &msg);
 
@@ -164,16 +156,7 @@ public:
 	}
 };
 
-class ParserException : public StandardException {
-public:
-	DUCKDB_API explicit ParserException(const string &msg);
-
-	template <typename... Args>
-	explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class PermissionException : public StandardException {
+class PermissionException : public Exception {
 public:
 	DUCKDB_API explicit PermissionException(const string &msg);
 
@@ -183,45 +166,6 @@ public:
 	}
 };
 
-class BinderException : public StandardException {
-public:
-	DUCKDB_API explicit BinderException(const string &msg);
-
-	template <typename... Args>
-	explicit BinderException(const string &msg, Args... params) : BinderException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ConversionException : public Exception {
-public:
-	DUCKDB_API explicit ConversionException(const string &msg);
-
-	template <typename... Args>
-	explicit ConversionException(const string &msg, Args... params)
-	    : ConversionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class TransactionException : public Exception {
-public:
-	DUCKDB_API explicit TransactionException(const string &msg);
-
-	template <typename... Args>
-	explicit TransactionException(const string &msg, Args... params)
-	    : TransactionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class NotImplementedException : public Exception {
-public:
-	DUCKDB_API explicit NotImplementedException(const string &msg);
-
-	template <typename... Args>
-	explicit NotImplementedException(const string &msg, Args... params)
-	    : NotImplementedException(ConstructMessage(msg, params...)) {
-	}
-};
-
 class OutOfRangeException : public Exception {
 public:
 	DUCKDB_API explicit OutOfRangeException(const string &msg);
@@ -230,6 +174,10 @@ public:
 	explicit OutOfRangeException(const string &msg, Args... params)
 	    : OutOfRangeException(ConstructMessage(msg, params...)) {
 	}
+	DUCKDB_API OutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API OutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API OutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
+	DUCKDB_API OutOfRangeException(const PhysicalType varType, const idx_t length);
 };
 
 class OutOfMemoryException : public Exception {
@@ -274,12 +222,18 @@ public:
 class IOException : public Exception {
 public:
 	DUCKDB_API explicit IOException(const string &msg);
+	DUCKDB_API explicit IOException(const string &msg, const unordered_map<string, string> &extra_info);
 	explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
 	}
 
 	template <typename... Args>
 	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
 	}
+
+	template <typename... Args>
+	explicit IOException(const string &msg, const unordered_map<string, string> &extra_info, Args... params)
+	    : IOException(ConstructMessage(msg, params...), extra_info) {
+	}
 };
 
 class MissingExtensionException : public Exception {
@@ -292,74 +246,19 @@ public:
 	}
 };
 
-class AutoloadException : public Exception {
+class NotImplementedException : public Exception {
 public:
-	DUCKDB_API explicit AutoloadException(const string &extension_name, Exception &e);
+	DUCKDB_API explicit NotImplementedException(const string &msg);
 
 	template <typename... Args>
-	explicit AutoloadException(const string &extension_name, Exception &e, Args... params)
-	    : AutoloadException(ConstructMessage(extension_name, e, params...)) {
+	explicit NotImplementedException(const string &msg, Args... params)
+	    : NotImplementedException(ConstructMessage(msg, params...)) {
 	}
-
-protected:
-	Exception &wrapped_exception;
 };
 
-class HTTPException : public IOException {
+class AutoloadException : public Exception {
 public:
-	template <typename>
-	struct ResponseShape {
-		typedef int status;
-	};
-
-	template <class RESPONSE, typename ResponseShape<decltype(RESPONSE::status)>::status = 0, typename... ARGS>
-	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
-	    : HTTPException(response.status, response.body, response.headers, response.reason, msg, params...) {
-	}
-
-	template <typename>
-	struct ResponseWrapperShape {
-		typedef int code;
-	};
-	template <class RESPONSE, typename ResponseWrapperShape<decltype(RESPONSE::code)>::code = 0, typename... ARGS>
-	explicit HTTPException(RESPONSE &response, const string &msg, ARGS... params)
-	    : HTTPException(response.code, response.body, response.headers, response.error, msg, params...) {
-	}
-
-	template <typename HEADERS, typename... ARGS>
-	explicit HTTPException(int status_code, string response_body, HEADERS headers, const string &reason,
-	                       const string &msg, ARGS... params)
-	    : IOException(ExceptionType::HTTP, ConstructMessage(msg, params...)), status_code(status_code), reason(reason),
-	      response_body(std::move(response_body)) {
-		this->headers.insert(headers.begin(), headers.end());
-		D_ASSERT(this->headers.size() > 0);
-	}
-
-	std::shared_ptr<Exception> Copy() const {
-		return make_shared<HTTPException>(status_code, response_body, headers, reason, RawMessage());
-	}
-
-	const std::multimap<std::string, std::string> GetHeaders() const {
-		return headers;
-	}
-	int GetStatusCode() const {
-		return status_code;
-	}
-	const string &GetResponseBody() const {
-		return response_body;
-	}
-	const string &GetReason() const {
-		return reason;
-	}
-	[[noreturn]] void Throw() const {
-		throw HTTPException(status_code, response_body, headers, reason, RawMessage());
-	}
-
-private:
-	int status_code;
-	string reason;
-	string response_body;
-	std::multimap<string, string> headers;
+	DUCKDB_API explicit AutoloadException(const string &extension_name, const string &message);
 };
 
 class SerializationException : public Exception {
@@ -403,7 +302,7 @@ protected:
 	}
 };
 
-class InternalException : public FatalException {
+class InternalException : public Exception {
 public:
 	DUCKDB_API explicit InternalException(const string &msg);
 
@@ -416,19 +315,16 @@ public:
 class InvalidInputException : public Exception {
 public:
 	DUCKDB_API explicit InvalidInputException(const string &msg);
+	DUCKDB_API explicit InvalidInputException(const string &msg, const unordered_map<string, string> &extra_info);
 
 	template <typename... Args>
 	explicit InvalidInputException(const string &msg, Args... params)
 	    : InvalidInputException(ConstructMessage(msg, params...)) {
 	}
-};
-
-class CastException : public Exception {
-public:
-	DUCKDB_API CastException(const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API CastException(const LogicalType &origType, const LogicalType &newType);
-	DUCKDB_API
-	CastException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized
+	template <typename... Args>
+	explicit InvalidInputException(Expression &expr, const string &msg, Args... params)
+	    : InvalidInputException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
+	}
 };
 
 class InvalidTypeException : public Exception {
@@ -447,17 +343,7 @@ public:
 	TypeMismatchException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized
 };
 
-class ValueOutOfRangeException : public Exception {
-public:
-	DUCKDB_API ValueOutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const PhysicalType varType, const idx_t length);
-	DUCKDB_API ValueOutOfRangeException(
-	    const string &msg); //! Needed to be able to recreate the exception after it's been serialized
-};
-
-class ParameterNotAllowedException : public StandardException {
+class ParameterNotAllowedException : public Exception {
 public:
 	DUCKDB_API explicit ParameterNotAllowedException(const string &msg);
 

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

@@ -47,10 +47,11 @@ enum class ExceptionFormatValueType : uint8_t {
 };
 
 struct ExceptionFormatValue {
-	DUCKDB_API ExceptionFormatValue(double dbl_val);   // NOLINT
-	DUCKDB_API ExceptionFormatValue(int64_t int_val);  // NOLINT
-	DUCKDB_API ExceptionFormatValue(string str_val);   // NOLINT
-	DUCKDB_API ExceptionFormatValue(hugeint_t hg_val); // NOLINT
+	DUCKDB_API ExceptionFormatValue(double dbl_val);     // NOLINT
+	DUCKDB_API ExceptionFormatValue(int64_t int_val);    // NOLINT
+	DUCKDB_API ExceptionFormatValue(string str_val);     // NOLINT
+	DUCKDB_API ExceptionFormatValue(hugeint_t hg_val);   // NOLINT
+	DUCKDB_API ExceptionFormatValue(uhugeint_t uhg_val); // NOLINT
 
 	ExceptionFormatValueType type;
 
@@ -86,5 +87,7 @@ template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value);
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value);
+template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(uhugeint_t value);
 
 } // namespace duckdb

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

@@ -23,7 +23,10 @@ enum class ExtraTypeInfoType : uint8_t {
 	STRUCT_TYPE_INFO = 5,
 	ENUM_TYPE_INFO = 6,
 	USER_TYPE_INFO = 7,
-	AGGREGATE_STATE_TYPE_INFO = 8
+	AGGREGATE_STATE_TYPE_INFO = 8,
+	ARRAY_TYPE_INFO = 9,
+	ANY_TYPE_INFO = 10,
+	INTEGER_LITERAL_TYPE_INFO = 11
 };
 
 struct ExtraTypeInfo {
@@ -138,7 +141,10 @@ private:
 
 struct UserTypeInfo : public ExtraTypeInfo {
 	explicit UserTypeInfo(string name_p);
+	UserTypeInfo(string catalog_p, string schema_p, string name_p);
 
+	string catalog;
+	string schema;
 	string user_type_name;
 
 public:
@@ -182,4 +188,50 @@ private:
 	idx_t dict_size;
 };
 
+struct ArrayTypeInfo : public ExtraTypeInfo {
+	LogicalType child_type;
+	idx_t size;
+	explicit ArrayTypeInfo(LogicalType child_type_p, idx_t size_p);
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &reader);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+};
+
+struct AnyTypeInfo : public ExtraTypeInfo {
+	AnyTypeInfo(LogicalType target_type, idx_t cast_score);
+
+	LogicalType target_type;
+	idx_t cast_score;
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	AnyTypeInfo();
+};
+
+struct IntegerLiteralTypeInfo : public ExtraTypeInfo {
+	IntegerLiteralTypeInfo(Value constant_value);
+
+	Value constant_value;
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	IntegerLiteralTypeInfo();
+};
+
 } // namespace duckdb

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

@@ -146,12 +146,12 @@ static duckdb::unique_ptr<T> make_unique(_Args&&... __args) {
 }
 
 template <typename T>
-T MaxValue(T a, T b) {
+constexpr T MaxValue(T a, T b) {
 	return a > b ? a : b;
 }
 
 template <typename T>
-T MinValue(T a, T b) {
+constexpr T MinValue(T a, T b) {
 	return a < b ? a : b;
 }
 
@@ -160,12 +160,17 @@ T AbsValue(T a) {
 	return a < 0 ? -a : a;
 }
 
-//Align value (ceiling)
+//! Align value (ceiling)
 template<class T, T val=8>
 static inline T AlignValue(T n) {
 	return ((n + (val - 1)) / val) * val;
 }
 
+template<class T, T val=8>
+constexpr inline T AlignValueFloor(T n) {
+	return (n / val) * val;
+}
+
 template<class T, T val=8>
 static inline bool ValueIsAligned(T n) {
 	return (n % val) == 0;
@@ -210,4 +215,9 @@ bool RefersToSameObject(const reference<T> &A, const reference<T> &B) {
 	return &A.get() == &B.get();
 }
 
+template<class T>
+bool RefersToSameObject(const T &A, const T &B) {
+	return &A == &B;
+}
+
 } // namespace duckdb

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

@@ -13,6 +13,7 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/main/client_context_state.hpp"
 
 namespace duckdb {
 
@@ -33,6 +34,8 @@ private:
 	shared_ptr<char> data;
 	//! Data capacity
 	uint64_t capacity = 0;
+	//! Size of file
+	idx_t size;
 	//! Lock for initializing the file
 	mutex lock;
 	//! When initialized is set to true, the file is safe for parallel reading without holding the lock
@@ -47,7 +50,7 @@ public:
 	//! allocate a buffer for the file
 	void AllocateBuffer(idx_t size);
 	//! Indicate the file is fully downloaded and safe for parallel reading without lock
-	void SetInitialized();
+	void SetInitialized(idx_t total_size);
 	//! Grow buffer to new size, copying over `bytes_to_copy` to the new buffer
 	void GrowBuffer(idx_t new_capacity, idx_t bytes_to_copy);
 	//! Write to the buffer
@@ -62,20 +65,26 @@ public:
 	uint64_t GetCapacity() {
 		return file->capacity;
 	}
+	//! Return the size of the initialized file
+	idx_t GetSize() {
+		D_ASSERT(file->initialized);
+		return file->size;
+	}
 
 private:
 	unique_ptr<lock_guard<mutex>> lock;
 	shared_ptr<CachedFile> file;
 };
 
-class HTTPState {
+class HTTPState : public ClientContextState {
 public:
 	//! Reset all counters and cached files
 	void Reset();
 	//! Get cache entry, create if not exists
 	shared_ptr<CachedFile> &GetCachedFile(const string &path);
-	//! Helper function to get the HTTP state
-	static shared_ptr<HTTPState> TryGetState(FileOpener *opener);
+	//! Helper functions to get the HTTP state
+	static shared_ptr<HTTPState> TryGetState(ClientContext &context, bool create_on_missing = true);
+	static shared_ptr<HTTPState> TryGetState(FileOpener *opener, bool create_on_missing = true);
 
 	bool IsEmpty() {
 		return head_count == 0 && get_count == 0 && put_count == 0 && post_count == 0 && total_bytes_received == 0 &&
@@ -89,6 +98,11 @@ public:
 	atomic<idx_t> total_bytes_received {0};
 	atomic<idx_t> total_bytes_sent {0};
 
+	//! Called by the ClientContext when the current query ends
+	void QueryEnd(ClientContext &context) override {
+		Reset();
+	}
+
 private:
 	//! Mutex to lock when getting the cached file(Parallel Only)
 	mutex cached_files_mutex;

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

@@ -7,6 +7,9 @@
 
 namespace duckdb {
 
+// Forward declaration to allow conversion between hugeint and uhugeint
+struct uhugeint_t;
+
 struct hugeint_t {
 public:
 	uint64_t lower;
@@ -64,7 +67,7 @@ public:
 	DUCKDB_API explicit operator bool() const;
 	DUCKDB_API bool operator!() const;
 
-	// cast operators
+	// cast operators -- doesn't check bounds/overflow/underflow
 	DUCKDB_API explicit operator uint8_t() const;
 	DUCKDB_API explicit operator uint16_t() const;
 	DUCKDB_API explicit operator uint32_t() const;
@@ -73,6 +76,7 @@ public:
 	DUCKDB_API explicit operator int16_t() const;
 	DUCKDB_API explicit operator int32_t() const;
 	DUCKDB_API explicit operator int64_t() const;
+	DUCKDB_API operator uhugeint_t() const; // NOLINT: Allow implicit conversion from `hugeint_t`
 };
 
 } // namespace duckdb

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/types.hpp"
 
 #include <type_traits>
@@ -37,7 +38,7 @@ struct NumericLimits {
 template <>
 struct NumericLimits<hugeint_t> {
 	static constexpr hugeint_t Minimum() {
-		return {std::numeric_limits<int64_t>::lowest(), 1};
+		return {std::numeric_limits<int64_t>::lowest(), 0};
 	};
 	static constexpr hugeint_t Maximum() {
 		return {std::numeric_limits<int64_t>::max(), std::numeric_limits<uint64_t>::max()};
@@ -51,6 +52,23 @@ struct NumericLimits<hugeint_t> {
 	}
 };
 
+template <>
+struct NumericLimits<uhugeint_t> {
+	static constexpr uhugeint_t Minimum() {
+		return {0, 0};
+	};
+	static constexpr uhugeint_t Maximum() {
+		return {std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max()};
+	};
+	static constexpr bool IsSigned() {
+		return false;
+	}
+
+	static constexpr idx_t Digits() {
+		return 39;
+	}
+};
+
 template <>
 constexpr idx_t NumericLimits<int8_t>::Digits() {
 	return 3;

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/file_system.hpp"
+#include "duckdb/common/windows_undefs.hpp"
 
 namespace duckdb {
 

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

@@ -9,11 +9,11 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/multi_file_reader_options.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
-#include "duckdb/common/union_by_name.hpp"
+#include "duckdb/common/multi_file_reader_options.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/common/union_by_name.hpp"
 
 namespace duckdb {
 class TableFunction;
@@ -40,6 +40,8 @@ struct MultiFileReaderBindData {
 	idx_t filename_idx = DConstants::INVALID_INDEX;
 	//! The set of hive partitioning indexes (if any)
 	vector<HivePartitioningIndex> hive_partitioning_indexes;
+	//! The index of the file_row_number column (if any)
+	idx_t file_row_number_idx = DConstants::INVALID_INDEX;
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderBindData Deserialize(Deserializer &deserializer);
@@ -110,6 +112,9 @@ struct MultiFileReader {
 	                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
 	                                     optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
 	                                     const string &initial_file);
+	//! Populated the filter_map
+	DUCKDB_API static void CreateFilterMap(const vector<LogicalType> &global_types,
+	                                       optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data);
 	//! 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);