duckdb 0.4.1-dev2267.0 → 0.4.1-dev2299.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "22b39efcd"
-#define DUCKDB_VERSION "v0.4.1-dev2267"
+#define DUCKDB_SOURCE_ID "3075f4d29"
+#define DUCKDB_VERSION "v0.4.1-dev2299"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -165,7 +165,8 @@ typedef idx_t column_t;
 //! Type used for storage (column) identifiers
 typedef idx_t storage_t;
 //! Special value used to signify the ROW ID of a table
-extern const column_t COLUMN_IDENTIFIER_ROW_ID;
+DUCKDB_API extern const column_t COLUMN_IDENTIFIER_ROW_ID;
+DUCKDB_API bool IsRowIdColumnId(column_t column_id);
 
 //! The maximum row identifier used in tables
 extern const row_t MAX_ROW_ID;
@@ -753,50 +754,50 @@ public:
 	int64_t upper;
 
 public:
-	hugeint_t() = default;
-	hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
-	hugeint_t(const hugeint_t &rhs) = default;
-	hugeint_t(hugeint_t &&rhs) = default;
-	hugeint_t &operator=(const hugeint_t &rhs) = default;
-	hugeint_t &operator=(hugeint_t &&rhs) = default;
+	DUCKDB_API hugeint_t() = default;
+	DUCKDB_API hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
+	DUCKDB_API hugeint_t(const hugeint_t &rhs) = default;
+	DUCKDB_API hugeint_t(hugeint_t &&rhs) = default;
+	DUCKDB_API hugeint_t &operator=(const hugeint_t &rhs) = default;
+	DUCKDB_API hugeint_t &operator=(hugeint_t &&rhs) = default;
 
 	DUCKDB_API string ToString() const;
 
 	// comparison operators
-	bool operator==(const hugeint_t &rhs) const;
-	bool operator!=(const hugeint_t &rhs) const;
-	bool operator<=(const hugeint_t &rhs) const;
-	bool operator<(const hugeint_t &rhs) const;
-	bool operator>(const hugeint_t &rhs) const;
-	bool operator>=(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator==(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator!=(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator<=(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator<(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator>(const hugeint_t &rhs) const;
+	DUCKDB_API bool operator>=(const hugeint_t &rhs) const;
 
 	// arithmetic operators
-	hugeint_t operator+(const hugeint_t &rhs) const;
-	hugeint_t operator-(const hugeint_t &rhs) const;
-	hugeint_t operator*(const hugeint_t &rhs) const;
-	hugeint_t operator/(const hugeint_t &rhs) const;
-	hugeint_t operator%(const hugeint_t &rhs) const;
-	hugeint_t operator-() const;
+	DUCKDB_API hugeint_t operator+(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator-(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator*(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator/(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator%(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator-() const;
 
 	// bitwise operators
-	hugeint_t operator>>(const hugeint_t &rhs) const;
-	hugeint_t operator<<(const hugeint_t &rhs) const;
-	hugeint_t operator&(const hugeint_t &rhs) const;
-	hugeint_t operator|(const hugeint_t &rhs) const;
-	hugeint_t operator^(const hugeint_t &rhs) const;
-	hugeint_t operator~() const;
+	DUCKDB_API hugeint_t operator>>(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator<<(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator&(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator|(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator^(const hugeint_t &rhs) const;
+	DUCKDB_API hugeint_t operator~() const;
 
 	// in-place operators
-	hugeint_t &operator+=(const hugeint_t &rhs);
-	hugeint_t &operator-=(const hugeint_t &rhs);
-	hugeint_t &operator*=(const hugeint_t &rhs);
-	hugeint_t &operator/=(const hugeint_t &rhs);
-	hugeint_t &operator%=(const hugeint_t &rhs);
-	hugeint_t &operator>>=(const hugeint_t &rhs);
-	hugeint_t &operator<<=(const hugeint_t &rhs);
-	hugeint_t &operator&=(const hugeint_t &rhs);
-	hugeint_t &operator|=(const hugeint_t &rhs);
-	hugeint_t &operator^=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator+=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator-=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator*=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator/=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator%=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator>>=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator<<=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator&=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator|=(const hugeint_t &rhs);
+	DUCKDB_API hugeint_t &operator^=(const hugeint_t &rhs);
 };
 
 struct string_t;
@@ -1793,7 +1794,7 @@ public:
 };
 
 template <>
-string Deserializer::Read();
+DUCKDB_API string Deserializer::Read();
 
 } // namespace duckdb
 
@@ -2130,8 +2131,8 @@ public:
 
 	//! Serializes to a buffer allocated by the serializer, will expand when
 	//! writing past the initial threshold
-	BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS,
-	                   FileOpener *opener = nullptr);
+	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS,
+	                              FileOpener *opener = nullptr);
 
 	FileSystem &fs;
 	string path;
@@ -2141,17 +2142,17 @@ public:
 	unique_ptr<FileHandle> handle;
 
 public:
-	void WriteData(const_data_ptr_t buffer, uint64_t write_size) override;
+	DUCKDB_API void WriteData(const_data_ptr_t buffer, uint64_t write_size) override;
 	//! Flush the buffer to disk and sync the file to ensure writing is completed
-	void Sync();
+	DUCKDB_API void Sync();
 	//! Flush the buffer to the file (without sync)
-	void Flush();
+	DUCKDB_API void Flush();
 	//! Returns the current size of the file
-	int64_t GetFileSize();
+	DUCKDB_API int64_t GetFileSize();
 	//! Truncate the size to a previous size (given that size <= GetFileSize())
-	void Truncate(int64_t size);
+	DUCKDB_API void Truncate(int64_t size);
 
-	idx_t GetTotalWritten();
+	DUCKDB_API idx_t GetTotalWritten();
 };
 
 } // namespace duckdb
@@ -2285,7 +2286,7 @@ namespace duckdb {
 class VectorBuffer;
 
 struct SelectionData {
-	explicit SelectionData(idx_t count);
+	DUCKDB_API explicit SelectionData(idx_t count);
 
 	unique_ptr<sel_t[]> owned_data;
 };
@@ -3403,9 +3404,9 @@ public:
 	Allocator &operator=(Allocator &&allocator) noexcept = delete;
 	DUCKDB_API ~Allocator();
 
-	data_ptr_t AllocateData(idx_t size);
-	void FreeData(data_ptr_t pointer, idx_t size);
-	data_ptr_t ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t new_size);
+	DUCKDB_API data_ptr_t AllocateData(idx_t size);
+	DUCKDB_API void FreeData(data_ptr_t pointer, idx_t size);
+	DUCKDB_API data_ptr_t ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t new_size);
 
 	AllocatedData Allocate(idx_t size) {
 		return AllocatedData(*this, AllocateData(size), size);
@@ -3444,7 +3445,7 @@ private:
 //! Note that there is a cost to doing so (several atomic operations will be performed on allocation/free).
 //! As such this class should be used primarily for larger allocations.
 struct BufferAllocator {
-	static Allocator &Get(ClientContext &context);
+	DUCKDB_API static Allocator &Get(ClientContext &context);
 };
 
 } // namespace duckdb
@@ -4839,7 +4840,7 @@ struct VectorOperations {
 	DUCKDB_API static bool TryCast(Vector &source, Vector &result, idx_t count, string *error_message,
 	                               bool strict = false);
 	//! Cast the data from the source type to the target type. Throws an exception if the cast fails.
-	static void Cast(Vector &source, Vector &result, idx_t count, bool strict = false);
+	DUCKDB_API static void Cast(Vector &source, Vector &result, idx_t count, bool strict = false);
 
 	// Copy the data of <source> to the target vector
 	static void Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
@@ -7113,130 +7114,130 @@ namespace duckdb {
 
 template <class T>
 struct NumericLimits {
-	static T Minimum();
-	static T Maximum();
-	static bool IsSigned();
-	static idx_t Digits();
+	DUCKDB_API static T Minimum();
+	DUCKDB_API static T Maximum();
+	DUCKDB_API static bool IsSigned();
+	DUCKDB_API static idx_t Digits();
 };
 
 template <>
 struct NumericLimits<int8_t> {
-	static int8_t Minimum();
-	static int8_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static int8_t Minimum();
+	DUCKDB_API static int8_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 3;
 	}
 };
 template <>
 struct NumericLimits<int16_t> {
-	static int16_t Minimum();
-	static int16_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static int16_t Minimum();
+	DUCKDB_API static int16_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 5;
 	}
 };
 template <>
 struct NumericLimits<int32_t> {
-	static int32_t Minimum();
-	static int32_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static int32_t Minimum();
+	DUCKDB_API static int32_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 10;
 	}
 };
 template <>
 struct NumericLimits<int64_t> {
-	static int64_t Minimum();
-	static int64_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static int64_t Minimum();
+	DUCKDB_API static int64_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 19;
 	}
 };
 template <>
 struct NumericLimits<hugeint_t> {
-	static hugeint_t Minimum();
-	static hugeint_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static hugeint_t Minimum();
+	DUCKDB_API static hugeint_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 39;
 	}
 };
 template <>
 struct NumericLimits<uint8_t> {
-	static uint8_t Minimum();
-	static uint8_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static uint8_t Minimum();
+	DUCKDB_API static uint8_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return false;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 3;
 	}
 };
 template <>
 struct NumericLimits<uint16_t> {
-	static uint16_t Minimum();
-	static uint16_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static uint16_t Minimum();
+	DUCKDB_API static uint16_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return false;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 5;
 	}
 };
 template <>
 struct NumericLimits<uint32_t> {
-	static uint32_t Minimum();
-	static uint32_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static uint32_t Minimum();
+	DUCKDB_API static uint32_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return false;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 10;
 	}
 };
 template <>
 struct NumericLimits<uint64_t> {
-	static uint64_t Minimum();
-	static uint64_t Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static uint64_t Minimum();
+	DUCKDB_API static uint64_t Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return false;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 20;
 	}
 };
 template <>
 struct NumericLimits<float> {
-	static float Minimum();
-	static float Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static float Minimum();
+	DUCKDB_API static float Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 127;
 	}
 };
 template <>
 struct NumericLimits<double> {
-	static double Minimum();
-	static double Maximum();
-	static bool IsSigned() {
+	DUCKDB_API static double Minimum();
+	DUCKDB_API static double Maximum();
+	DUCKDB_API static bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+	DUCKDB_API static idx_t Digits() {
 		return 250;
 	}
 };
@@ -7254,7 +7255,7 @@ public:
 	static string ToString(hugeint_t input);
 
 	template <class T>
-	static bool TryCast(hugeint_t input, T &result);
+	DUCKDB_API static bool TryCast(hugeint_t input, T &result);
 
 	template <class T>
 	static T Cast(hugeint_t input) {
@@ -7344,29 +7345,29 @@ public:
 };
 
 template <>
-bool Hugeint::TryCast(hugeint_t input, int8_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int8_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, int16_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int16_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, int32_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int32_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, int64_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, int64_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, uint8_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint8_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, uint16_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint16_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, uint32_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint32_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, uint64_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, uint64_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, hugeint_t &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, hugeint_t &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, float &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, float &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, double &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, double &result);
 template <>
-bool Hugeint::TryCast(hugeint_t input, long double &result);
+DUCKDB_API bool Hugeint::TryCast(hugeint_t input, long double &result);
 
 template <>
 bool Hugeint::TryConvert(int8_t value, hugeint_t &result);
@@ -7499,59 +7500,59 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 struct Equals {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return left == right;
 	}
 };
 struct NotEquals {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return !Equals::Operation(left, right);
 	}
 };
 
 struct GreaterThan {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return left > right;
 	}
 };
 
 struct GreaterThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return left >= right;
 	}
 };
 
 struct LessThan {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(T left, T right) {
 		return GreaterThanEquals::Operation(right, left);
 	}
 };
 
 template <>
-bool Equals::Operation(float left, float right);
+DUCKDB_API bool Equals::Operation(float left, float right);
 template <>
-bool Equals::Operation(double left, double right);
+DUCKDB_API bool Equals::Operation(double left, double right);
 
 template <>
-bool GreaterThan::Operation(float left, float right);
+DUCKDB_API bool GreaterThan::Operation(float left, float right);
 template <>
-bool GreaterThan::Operation(double left, double right);
+DUCKDB_API bool GreaterThan::Operation(double left, double right);
 
 template <>
-bool GreaterThanEquals::Operation(float left, float right);
+DUCKDB_API bool GreaterThanEquals::Operation(float left, float right);
 template <>
-bool GreaterThanEquals::Operation(double left, double right);
+DUCKDB_API bool GreaterThanEquals::Operation(double left, double right);
 
 // Distinct semantics are from Postgres record sorting. NULL = NULL and not-NULL < NULL
 // Deferring to the non-distinct operations removes the need for further specialisation.
@@ -11269,19 +11270,19 @@ class ColumnDataRowCollection;
 class ColumnDataCollection {
 public:
 	//! Constructs an in-memory column data collection from an allocator
-	ColumnDataCollection(Allocator &allocator, vector<LogicalType> types);
+	DUCKDB_API ColumnDataCollection(Allocator &allocator, vector<LogicalType> types);
 	//! Constructs a buffer-managed column data collection
-	ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types);
+	DUCKDB_API ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types);
 	//! Constructs either an in-memory or a buffer-managed column data collection
-	ColumnDataCollection(ClientContext &context, vector<LogicalType> types,
-	                     ColumnDataAllocatorType type = ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
+	DUCKDB_API ColumnDataCollection(ClientContext &context, vector<LogicalType> types,
+	                                ColumnDataAllocatorType type = ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
 	//! Creates a column data collection that inherits the blocks to write to. This allows blocks to be shared
 	//! between multiple column data collections and prevents wasting space.
 	//! Note that after one CDC inherits blocks from another, the other
 	//! cannot be written to anymore (i.e. we take ownership of the half-written blocks).
-	ColumnDataCollection(ColumnDataCollection &parent);
-	ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator, vector<LogicalType> types);
-	~ColumnDataCollection();
+	DUCKDB_API ColumnDataCollection(ColumnDataCollection &parent);
+	DUCKDB_API ColumnDataCollection(shared_ptr<ColumnDataAllocator> allocator, vector<LogicalType> types);
+	DUCKDB_API ~ColumnDataCollection();
 
 public:
 	DUCKDB_API vector<LogicalType> &Types() {
@@ -13323,7 +13324,7 @@ class BufferedSerializer : public Serializer {
 public:
 	//! Serializes to a buffer allocated by the serializer, will expand when
 	//! writing past the initial threshold
-	explicit BufferedSerializer(idx_t maximum_size = SERIALIZER_DEFAULT_SIZE);
+	DUCKDB_API explicit BufferedSerializer(idx_t maximum_size = SERIALIZER_DEFAULT_SIZE);
 	//! Serializes to a provided (owned) data pointer
 	BufferedSerializer(unique_ptr<data_t[]> data, idx_t size);
 	BufferedSerializer(data_ptr_t data, idx_t size);
@@ -13464,7 +13465,7 @@ private:
 };
 
 template <>
-void FieldWriter::Write(const string &val);
+DUCKDB_API void FieldWriter::Write(const string &val);
 
 class FieldDeserializer : public Deserializer {
 public:
@@ -15635,25 +15636,25 @@ inline hash_t CombineHash(hash_t left, hash_t right) {
 }
 
 template <>
-hash_t Hash(uint64_t val);
+DUCKDB_API hash_t Hash(uint64_t val);
 template <>
-hash_t Hash(int64_t val);
+DUCKDB_API hash_t Hash(int64_t val);
 template <>
-hash_t Hash(hugeint_t val);
+DUCKDB_API hash_t Hash(hugeint_t val);
 template <>
-hash_t Hash(float val);
+DUCKDB_API hash_t Hash(float val);
 template <>
-hash_t Hash(double val);
+DUCKDB_API hash_t Hash(double val);
 template <>
-hash_t Hash(const char *val);
+DUCKDB_API hash_t Hash(const char *val);
 template <>
-hash_t Hash(char *val);
+DUCKDB_API hash_t Hash(char *val);
 template <>
-hash_t Hash(string_t val);
+DUCKDB_API hash_t Hash(string_t val);
 template <>
-hash_t Hash(interval_t val);
-hash_t Hash(const char *val, size_t size);
-hash_t Hash(uint8_t *val, size_t size);
+DUCKDB_API hash_t Hash(interval_t val);
+DUCKDB_API hash_t Hash(const char *val, size_t size);
+DUCKDB_API hash_t Hash(uint8_t *val, size_t size);
 
 } // namespace duckdb
 
@@ -21587,32 +21588,32 @@ public:
 
 public:
 	//! Returns the string size of a blob -> string conversion
-	static idx_t GetStringSize(string_t blob);
+	DUCKDB_API static idx_t GetStringSize(string_t blob);
 	//! Converts a blob to a string, writing the output to the designated output string.
 	//! The string needs to have space for at least GetStringSize(blob) bytes.
-	static void ToString(string_t blob, char *output);
+	DUCKDB_API static void ToString(string_t blob, char *output);
 	//! Convert a blob object to a string
-	static string ToString(string_t blob);
+	DUCKDB_API static string ToString(string_t blob);
 
 	//! Returns the blob size of a string -> blob conversion
-	static bool TryGetBlobSize(string_t str, idx_t &result_size, string *error_message);
-	static idx_t GetBlobSize(string_t str);
+	DUCKDB_API static bool TryGetBlobSize(string_t str, idx_t &result_size, string *error_message);
+	DUCKDB_API static idx_t GetBlobSize(string_t str);
 	//! Convert a string to a blob. This function should ONLY be called after calling GetBlobSize, since it does NOT
 	//! perform data validation.
-	static void ToBlob(string_t str, data_ptr_t output);
+	DUCKDB_API static void ToBlob(string_t str, data_ptr_t output);
 	//! Convert a string object to a blob
-	static string ToBlob(string_t str);
+	DUCKDB_API static string ToBlob(string_t str);
 
 	// base 64 conversion functions
 	//! Returns the string size of a blob -> base64 conversion
-	static idx_t ToBase64Size(string_t blob);
+	DUCKDB_API static idx_t ToBase64Size(string_t blob);
 	//! Converts a blob to a base64 string, output should have space for at least ToBase64Size(blob) bytes
-	static void ToBase64(string_t blob, char *output);
+	DUCKDB_API static void ToBase64(string_t blob, char *output);
 
 	//! Returns the string size of a base64 string -> blob conversion
-	static idx_t FromBase64Size(string_t str);
+	DUCKDB_API static idx_t FromBase64Size(string_t str);
 	//! Converts a base64 string to a blob, output should have space for at least FromBase64Size(blob) bytes
-	static void FromBase64(string_t str, data_ptr_t output, idx_t output_size);
+	DUCKDB_API static void FromBase64(string_t str, data_ptr_t output, idx_t output_size);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -24452,8 +24453,8 @@ public:
 		cache[key] = move(value);
 	}
 
-	static ObjectCache &GetObjectCache(ClientContext &context);
-	static bool ObjectCacheEnabled(ClientContext &context);
+	DUCKDB_API static ObjectCache &GetObjectCache(ClientContext &context);
+	DUCKDB_API static bool ObjectCacheEnabled(ClientContext &context);
 
 private:
 	//! Object Cache
@@ -24493,7 +24494,7 @@ class Vector;
 
 class ValidityStatistics : public BaseStatistics {
 public:
-	explicit ValidityStatistics(bool has_null = false, bool has_no_null = true);
+	DUCKDB_API explicit ValidityStatistics(bool has_null = false, bool has_no_null = true);
 
 	//! Whether or not the segment can contain NULL values
 	bool has_null;
@@ -24501,9 +24502,9 @@ public:
 	bool has_no_null;
 
 public:
-	void Merge(const BaseStatistics &other) override;
+	DUCKDB_API void Merge(const BaseStatistics &other) override;
 
-	bool IsConstant() const override;
+	DUCKDB_API bool IsConstant() const override;
 
 	unique_ptr<BaseStatistics> Copy() const override;
 
@@ -24528,7 +24529,7 @@ public:
 	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
 
 public:
-	explicit StringStatistics(LogicalType type, StatisticsType stats_type);
+	DUCKDB_API explicit StringStatistics(LogicalType type, StatisticsType stats_type);
 
 	//! The minimum value of the segment, potentially truncated
 	data_t min[MAX_STRING_MINMAX_SIZE];
@@ -24542,8 +24543,8 @@ public:
 	bool has_overflow_strings;
 
 public:
-	void Update(const string_t &value);
-	void Merge(const BaseStatistics &other) override;
+	DUCKDB_API void Update(const string_t &value);
+	DUCKDB_API void Merge(const BaseStatistics &other) override;
 
 	unique_ptr<BaseStatistics> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
@@ -24622,8 +24623,8 @@ namespace duckdb {
 
 class NumericStatistics : public BaseStatistics {
 public:
-	explicit NumericStatistics(LogicalType type, StatisticsType stats_type);
-	NumericStatistics(LogicalType type, Value min, Value max, StatisticsType stats_type);
+	DUCKDB_API explicit NumericStatistics(LogicalType type, StatisticsType stats_type);
+	DUCKDB_API NumericStatistics(LogicalType type, Value min, Value max, StatisticsType stats_type);
 
 	//! The minimum value of the segment
 	Value min;
@@ -24631,11 +24632,11 @@ public:
 	Value max;
 
 public:
-	void Merge(const BaseStatistics &other) override;
+	DUCKDB_API void Merge(const BaseStatistics &other) override;
 
-	bool IsConstant() const override;
+	DUCKDB_API bool IsConstant() const override;
 
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
+	DUCKDB_API FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
 
 	unique_ptr<BaseStatistics> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
@@ -25240,7 +25241,7 @@ class Vector;
 class VectorCache {
 public:
 	//! Instantiate a vector cache with the given type
-	explicit VectorCache(Allocator &allocator, const LogicalType &type);
+	DUCKDB_API explicit VectorCache(Allocator &allocator, const LogicalType &type);
 
 	buffer_ptr<VectorBuffer> buffer;
 
@@ -26828,13 +26829,13 @@ namespace duckdb {
 class HivePartitioning {
 public:
 	//! Parse a filename that follows the hive partitioning scheme
-	static std::map<string, string> Parse(string &filename);
+	DUCKDB_API static std::map<string, string> Parse(string &filename);
 	//! Prunes a list of filenames based on a set of filters, can be used by TableFunctions in the
 	//! pushdown_complex_filter function to skip files with filename-based filters. Also removes the filters that always
 	//! evaluate to true.
-	static void ApplyFiltersToFileList(vector<string> &files, vector<unique_ptr<Expression>> &filters,
-	                                   unordered_map<string, column_t> &column_map, idx_t table_index,
-	                                   bool hive_enabled, bool filename_enabled);
+	DUCKDB_API static void ApplyFiltersToFileList(vector<string> &files, vector<unique_ptr<Expression>> &filters,
+	                                              unordered_map<string, column_t> &column_map, idx_t table_index,
+	                                              bool hive_enabled, bool filename_enabled);
 };
 
 } // namespace duckdb