duckdb 0.7.2-dev3546.0 → 0.7.2-dev3666.0

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

@@ -19,10 +19,10 @@ namespace duckdb {
 
 template <class T>
 struct NumericLimits {
-	DUCKDB_API static constexpr T Minimum() {
+	static constexpr T Minimum() {
 		return std::numeric_limits<T>::lowest();
 	};
-	DUCKDB_API static constexpr T Maximum() {
+	static constexpr T Maximum() {
 		return std::numeric_limits<T>::max();
 	};
 	DUCKDB_API static bool IsSigned();
@@ -31,169 +31,169 @@ struct NumericLimits {
 
 template <>
 struct NumericLimits<int8_t> {
-	DUCKDB_API static constexpr int8_t Minimum() {
+	static constexpr int8_t Minimum() {
 		return std::numeric_limits<int8_t>::lowest();
 	};
-	DUCKDB_API static constexpr int8_t Maximum() {
+	static constexpr int8_t Maximum() {
 		return std::numeric_limits<int8_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 3;
 	}
 };
 template <>
 struct NumericLimits<int16_t> {
-	DUCKDB_API static constexpr int16_t Minimum() {
+	static constexpr int16_t Minimum() {
 		return std::numeric_limits<int16_t>::lowest();
 	};
-	DUCKDB_API static constexpr int16_t Maximum() {
+	static constexpr int16_t Maximum() {
 		return std::numeric_limits<int16_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 5;
 	}
 };
 template <>
 struct NumericLimits<int32_t> {
-	DUCKDB_API static constexpr int32_t Minimum() {
+	static constexpr int32_t Minimum() {
 		return std::numeric_limits<int32_t>::lowest();
 	};
-	DUCKDB_API static constexpr int32_t Maximum() {
+	static constexpr int32_t Maximum() {
 		return std::numeric_limits<int32_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 10;
 	}
 };
 
 template <>
 struct NumericLimits<int64_t> {
-	DUCKDB_API static constexpr int64_t Minimum() {
+	static constexpr int64_t Minimum() {
 		return std::numeric_limits<int64_t>::lowest();
 	};
-	DUCKDB_API static constexpr int64_t Maximum() {
+	static constexpr int64_t Maximum() {
 		return std::numeric_limits<int64_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 19;
 	}
 };
 template <>
 struct NumericLimits<hugeint_t> {
-	DUCKDB_API static constexpr hugeint_t Minimum() {
+	static constexpr hugeint_t Minimum() {
 		return {std::numeric_limits<int64_t>::lowest(), 1};
 	};
-	DUCKDB_API static constexpr hugeint_t Maximum() {
+	static constexpr hugeint_t Maximum() {
 		return {std::numeric_limits<int64_t>::max(), std::numeric_limits<uint64_t>::max()};
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 39;
 	}
 };
 
 template <>
 struct NumericLimits<uint8_t> {
-	DUCKDB_API static constexpr uint8_t Minimum() {
+	static constexpr uint8_t Minimum() {
 		return std::numeric_limits<uint8_t>::lowest();
 	};
-	DUCKDB_API static constexpr uint8_t Maximum() {
+	static constexpr uint8_t Maximum() {
 		return std::numeric_limits<uint8_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return false;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 3;
 	}
 };
 
 template <>
 struct NumericLimits<uint16_t> {
-	DUCKDB_API static constexpr uint16_t Minimum() {
+	static constexpr uint16_t Minimum() {
 		return std::numeric_limits<uint16_t>::lowest();
 	};
-	DUCKDB_API static constexpr uint16_t Maximum() {
+	static constexpr uint16_t Maximum() {
 		return std::numeric_limits<uint16_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return false;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 5;
 	}
 };
 template <>
 struct NumericLimits<uint32_t> {
-	DUCKDB_API static constexpr uint32_t Minimum() {
+	static constexpr uint32_t Minimum() {
 		return std::numeric_limits<uint32_t>::lowest();
 	};
-	DUCKDB_API static constexpr uint32_t Maximum() {
+	static constexpr uint32_t Maximum() {
 		return std::numeric_limits<uint32_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return false;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 10;
 	}
 };
 template <>
 struct NumericLimits<uint64_t> {
-	DUCKDB_API static constexpr uint64_t Minimum() {
+	static constexpr uint64_t Minimum() {
 		return std::numeric_limits<uint64_t>::lowest();
 	};
-	DUCKDB_API static constexpr uint64_t Maximum() {
+	static constexpr uint64_t Maximum() {
 		return std::numeric_limits<uint64_t>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return false;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 20;
 	}
 };
 template <>
 struct NumericLimits<float> {
-	DUCKDB_API static constexpr float Minimum() {
+	static constexpr float Minimum() {
 		return std::numeric_limits<float>::lowest();
 	};
-	DUCKDB_API static constexpr float Maximum() {
+	static constexpr float Maximum() {
 		return std::numeric_limits<float>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 127;
 	}
 };
 template <>
 struct NumericLimits<double> {
-	DUCKDB_API static constexpr double Minimum() {
+	static constexpr double Minimum() {
 		return std::numeric_limits<double>::lowest();
 	};
-	DUCKDB_API static constexpr double Maximum() {
+	static constexpr double Maximum() {
 		return std::numeric_limits<double>::max();
 	};
-	DUCKDB_API static bool IsSigned() {
+	static bool IsSigned() {
 		return true;
 	}
-	DUCKDB_API static idx_t Digits() {
+	static idx_t Digits() {
 		return 250;
 	}
 };

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

@@ -22,21 +22,21 @@ class Vector;
 
 struct TryCast {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
 		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
 	}
 };
 
 struct TryCastErrorMessage {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
+	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>());
 	}
 };
 
 struct TryCastErrorMessageCommaSeparated {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
+	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>());
 	}
 };
@@ -520,21 +520,21 @@ DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &resul
 //===--------------------------------------------------------------------===//
 struct TryCastToTimestampNS {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
 		throw InternalException("Unsupported type for try cast to timestamp (ns)");
 	}
 };
 
 struct TryCastToTimestampMS {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
 		throw InternalException("Unsupported type for try cast to timestamp (ms)");
 	}
 };
 
 struct TryCastToTimestampSec {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
 		throw InternalException("Unsupported type for try cast to timestamp (s)");
 	}
 };
@@ -702,8 +702,8 @@ duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector
 
 struct TryCastToUUID {
 	template <class SRC, class DST>
-	DUCKDB_API 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, string *error_message,
+	                             bool strict = false) {
 		throw InternalException("Unsupported type for try cast to uuid");
 	}
 };

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

@@ -23,41 +23,41 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 struct Equals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return left == right;
 	}
 };
 struct NotEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return !Equals::Operation(left, right);
 	}
 };
 
 struct GreaterThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return left > right;
 	}
 };
 
 struct GreaterThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return !GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+	static inline bool Operation(const T &left, const T &right) {
 		return !GreaterThan::Operation(left, right);
 	}
 };

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

@@ -17,7 +17,7 @@ namespace duckdb {
 
 struct ConvertToString {
 	template <class SRC>
-	DUCKDB_API static inline string Operation(SRC input) {
+	static inline string Operation(SRC input) {
 		throw InternalException("Unrecognized type for ConvertToString %s", GetTypeId<SRC>());
 	}
 };

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

@@ -17,16 +17,14 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 struct TryCastToDecimal {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width,
-	                                        uint8_t scale) {
+	static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
 		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
 	}
 };
 
 struct TryCastToDecimalCommaSeparated {
 	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width,
-	                                        uint8_t scale) {
+	static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
 		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
 	}
 };

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

@@ -20,7 +20,7 @@ class Vector;
 
 struct StringCast {
 	template <class SRC>
-	DUCKDB_API static inline string_t Operation(SRC input, Vector &result) {
+	static inline string_t Operation(SRC input, Vector &result) {
 		throw NotImplementedException("Unimplemented type for string cast!");
 	}
 };

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

@@ -72,7 +72,7 @@ bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &
 
 struct SubtractOperatorOverflowCheck {
 	template <class TA, class TB, class TR>
-	DUCKDB_API static inline TR Operation(TA left, TB right) {
+	static inline TR Operation(TA left, TB right) {
 		TR result;
 		if (!TrySubtractOperator::Operation(left, right, result)) {
 			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,

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

@@ -39,7 +39,7 @@ public:
 	//! Let's us do things like 'if (error)'
 	DUCKDB_API operator bool() const;
 	DUCKDB_API bool operator==(const PreservedError &other) const;
-	DUCKDB_API const shared_ptr<Exception> &GetError() {
+	const shared_ptr<Exception> &GetError() {
 		return exception_instance;
 	}
 

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

@@ -15,7 +15,7 @@ enum class RegexOptions : uint8_t { NONE, CASE_INSENSITIVE };
 class Regex {
 public:
 	DUCKDB_API Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
-	DUCKDB_API Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
+	Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
 	}
 	const duckdb_re2::RE2 &GetRegex() const {
 		return *regex;

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

@@ -45,25 +45,25 @@ public:
 		throw InvalidInputException("Invalid input for binary digit: %s", string(c, 1));
 	}
 
-	DUCKDB_API static bool CharacterIsSpace(char c) {
+	static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}
-	DUCKDB_API static bool CharacterIsNewline(char c) {
+	static bool CharacterIsNewline(char c) {
 		return c == '\n' || c == '\r';
 	}
-	DUCKDB_API static bool CharacterIsDigit(char c) {
+	static bool CharacterIsDigit(char c) {
 		return c >= '0' && c <= '9';
 	}
-	DUCKDB_API static bool CharacterIsHex(char c) {
+	static bool CharacterIsHex(char c) {
 		return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 	}
-	DUCKDB_API static char CharacterToLower(char c) {
+	static char CharacterToLower(char c) {
 		if (c >= 'A' && c <= 'Z') {
 			return c - ('A' - 'a');
 		}
 		return c;
 	}
-	DUCKDB_API static char CharacterIsAlpha(char c) {
+	static char CharacterIsAlpha(char c) {
 		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
 	}
 	static bool CharacterIsOperator(char c) {
@@ -200,7 +200,7 @@ public:
 
 	//! Returns true if two null-terminated strings are equal or point to the same address.
 	//! Returns false if only one of the strings is nullptr
-	DUCKDB_API static bool Equals(const char *s1, const char *s2) {
+	static bool Equals(const char *s1, const char *s2) {
 		if (s1 == s2) {
 			return true;
 		}

package/src/duckdb/src/include/duckdb/common/types/chunk_collection.hpp

@@ -30,7 +30,7 @@ public:
 	explicit ChunkCollection(ClientContext &context);
 
 	//! The types of columns in the ChunkCollection
-	DUCKDB_API vector<LogicalType> &Types() {
+	vector<LogicalType> &Types() {
 		return types;
 	}
 	const vector<LogicalType> &Types() const {
@@ -38,12 +38,12 @@ public:
 	}
 
 	//! The amount of rows in the ChunkCollection
-	DUCKDB_API const idx_t &Count() const {
+	const idx_t &Count() const {
 		return count;
 	}
 
 	//! The amount of columns in the ChunkCollection
-	DUCKDB_API idx_t ColumnCount() const {
+	idx_t ColumnCount() const {
 		return types.size();
 	}
 
@@ -76,12 +76,12 @@ public:
 	DUCKDB_API void Print() const;
 
 	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunkForRow(idx_t row_index) {
+	DataChunk &GetChunkForRow(idx_t row_index) {
 		return *chunks[LocateChunk(row_index)];
 	}
 
 	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunk(idx_t chunk_index) {
+	DataChunk &GetChunk(idx_t chunk_index) {
 		D_ASSERT(chunk_index < chunks.size());
 		return *chunks[chunk_index];
 	}
@@ -90,21 +90,21 @@ public:
 		return *chunks[chunk_index];
 	}
 
-	DUCKDB_API const vector<unique_ptr<DataChunk>> &Chunks() {
+	const vector<unique_ptr<DataChunk>> &Chunks() {
 		return chunks;
 	}
 
-	DUCKDB_API idx_t ChunkCount() const {
+	idx_t ChunkCount() const {
 		return chunks.size();
 	}
 
-	DUCKDB_API void Reset() {
+	void Reset() {
 		count = 0;
 		chunks.clear();
 		types.clear();
 	}
 
-	DUCKDB_API unique_ptr<DataChunk> Fetch() {
+	unique_ptr<DataChunk> Fetch() {
 		if (ChunkCount() == 0) {
 			return nullptr;
 		}
@@ -115,7 +115,7 @@ public:
 	}
 
 	//! Locates the chunk that belongs to the specific index
-	DUCKDB_API idx_t LocateChunk(idx_t index) {
+	idx_t LocateChunk(idx_t index) {
 		idx_t result = index / STANDARD_VECTOR_SIZE;
 		D_ASSERT(result < chunks.size());
 		return result;

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -44,20 +44,20 @@ public:
 
 public:
 	//! The types of columns in the ColumnDataCollection
-	DUCKDB_API vector<LogicalType> &Types() {
+	vector<LogicalType> &Types() {
 		return types;
 	}
-	DUCKDB_API const vector<LogicalType> &Types() const {
+	const vector<LogicalType> &Types() const {
 		return types;
 	}
 
 	//! The amount of rows in the ColumnDataCollection
-	DUCKDB_API const idx_t &Count() const {
+	const idx_t &Count() const {
 		return count;
 	}
 
 	//! The amount of columns in the ColumnDataCollection
-	DUCKDB_API idx_t ColumnCount() const {
+	idx_t ColumnCount() const {
 		return types.size();
 	}
 
@@ -177,32 +177,32 @@ public:
 
 public:
 	// container API
-	DUCKDB_API bool empty() const {
+	bool empty() const {
 		return rows.empty();
 	}
-	DUCKDB_API idx_t size() const {
+	idx_t size() const {
 		return rows.size();
 	}
 
 	DUCKDB_API ColumnDataRow &operator[](idx_t i);
 	DUCKDB_API const ColumnDataRow &operator[](idx_t i) const;
 
-	DUCKDB_API vector<ColumnDataRow>::iterator begin() {
+	vector<ColumnDataRow>::iterator begin() {
 		return rows.begin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::iterator end() {
+	vector<ColumnDataRow>::iterator end() {
 		return rows.end();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator cbegin() const {
+	vector<ColumnDataRow>::const_iterator cbegin() const {
 		return rows.cbegin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator cend() const {
+	vector<ColumnDataRow>::const_iterator cend() const {
 		return rows.cend();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator begin() const {
+	vector<ColumnDataRow>::const_iterator begin() const {
 		return rows.begin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator end() const {
+	vector<ColumnDataRow>::const_iterator end() const {
 		return rows.end();
 	}
 

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp

@@ -43,10 +43,10 @@ private:
 	};
 
 public:
-	DUCKDB_API ColumnDataChunkIterator begin() {
+	ColumnDataChunkIterator begin() {
 		return ColumnDataChunkIterator(&collection, column_ids);
 	}
-	DUCKDB_API ColumnDataChunkIterator end() {
+	ColumnDataChunkIterator end() {
 		return ColumnDataChunkIterator(nullptr, vector<column_t>());
 	}
 };

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -165,7 +165,7 @@ public:
 
 	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
 	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value BLOB_RAW(const string &data) { // NOLINT
+	static Value BLOB_RAW(const string &data) { // NOLINT
 		return Value::BLOB((const_data_ptr_t)data.c_str(), data.size());
 	}
 	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)

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

@@ -308,14 +308,14 @@ struct LogicalType {
 	DUCKDB_API static LogicalType FormatDeserialize(FormatDeserializer &deserializer);
 
 
-	DUCKDB_API static bool TypeIsTimestamp(LogicalTypeId id) {
+	static bool TypeIsTimestamp(LogicalTypeId id) {
 		return (id == LogicalTypeId::TIMESTAMP ||
 				id == LogicalTypeId::TIMESTAMP_MS ||
 				id == LogicalTypeId::TIMESTAMP_NS ||
 				id == LogicalTypeId::TIMESTAMP_SEC ||
 				id == LogicalTypeId::TIMESTAMP_TZ);
 	}
-	DUCKDB_API static bool TypeIsTimestamp(const LogicalType& type) {
+	static bool TypeIsTimestamp(const LogicalType& type) {
 		return TypeIsTimestamp(type.id());
 	}
 	DUCKDB_API string ToString() const;

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

@@ -9,7 +9,7 @@
 #pragma once
 
 #ifndef DUCKDB_API
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(__MINGW32__)
 #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
 #define DUCKDB_API __declspec(dllexport)
 #else

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -48,7 +48,7 @@ struct ExecuteFunctionState : public ExpressionState {
 	unique_ptr<FunctionLocalState> local_state;
 
 public:
-	DUCKDB_API static FunctionLocalState *GetFunctionState(ExpressionState &state) {
+	static FunctionLocalState *GetFunctionState(ExpressionState &state) {
 		return ((ExecuteFunctionState &)state).local_state.get();
 	}
 };