duckdb 0.7.2-dev3546.0 → 0.7.2-dev3710.0

package/src/duckdb/src/function/table/read_csv.cpp

@@ -33,8 +33,12 @@ void ReadCSVData::FinalizeRead(ClientContext &context) {
 	bool complex_options = options.delimiter.size() > 1 || options.escape.size() > 1 || options.quote.size() > 1;
 	bool not_supported_options = options.null_padding;
 
-	if (!options.run_parallel || null_or_empty || not_supported_options || complex_options ||
-	    options.new_line == NewLineIdentifier::MIX) {
+	auto number_of_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+	if (options.parallel_mode != ParallelMode::PARALLEL && int64_t(files.size() * 2) >= number_of_threads) {
+		single_threaded = true;
+	}
+	if (options.parallel_mode == ParallelMode::SINGLE_THREADED || null_or_empty || not_supported_options ||
+	    complex_options || options.new_line == NewLineIdentifier::MIX) {
 		// not supported for parallel CSV reading
 		single_threaded = true;
 	}
@@ -173,7 +177,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		} else if (loption == "normalize_names") {
 			options.normalize_names = BooleanValue::Get(kv.second);
 		} else if (loption == "parallel") {
-			options.run_parallel = BooleanValue::Get(kv.second);
+			options.parallel_mode =
+			    BooleanValue::Get(kv.second) ? ParallelMode::PARALLEL : ParallelMode::SINGLE_THREADED;
 		} else {
 			options.SetReadOption(loption, kv.second, names);
 		}
@@ -581,6 +586,9 @@ bool LineInfo::CanItGetLine(idx_t file_idx, idx_t batch_idx) {
 	if (current_batches.empty() || done) {
 		return true;
 	}
+	if (file_idx >= current_batches.size() || current_batches[file_idx].empty()) {
+		return true;
+	}
 	auto min_value = *current_batches[file_idx].begin();
 	if (min_value >= batch_idx) {
 		return true;
@@ -1190,6 +1198,11 @@ unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, const string &ta
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(make_uniq<ConstantExpression>(Value(table_name)));
 	table_function->function = make_uniq<FunctionExpression>("read_csv_auto", std::move(children));
+
+	if (!FileSystem::HasGlob(table_name)) {
+		table_function->alias = FileSystem::ExtractBaseName(table_name);
+	}
+
 	return std::move(table_function);
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,14 +1,16 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev3546"
+#define DUCKDB_VERSION "0.7.2-dev3710"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "bd8adef6d1"
+#define DUCKDB_SOURCE_ID "59a4ec3adc"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
 
 #include <cstdint>
 
+#define DUCKDB_STRINGIFY(x) #x
+
 namespace duckdb {
 
 struct PragmaVersionData : public GlobalTableFunctionState {
@@ -89,6 +91,10 @@ string DuckDB::Platform() {
 #endif
 #ifdef __MINGW32__
 	postfix = "_mingw";
+#endif
+// this is used for the windows R builds which use a separate build environment
+#ifdef DUCKDB_OVERRIDE_PLATFORM_POSTFIX
+	postfix = DUCKDB_STRINGIFY(DUCKDB_OVERRIDE_PLATFORM_POSTFIX);
 #endif
 	return os + "_" + arch + postfix;
 }

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/column_dependency_manager.hpp

@@ -23,7 +23,7 @@ class ColumnDependencyManager {
 public:
 	DUCKDB_API ColumnDependencyManager();
 	DUCKDB_API ~ColumnDependencyManager();
-	DUCKDB_API ColumnDependencyManager(ColumnDependencyManager &&other) = default;
+	ColumnDependencyManager(ColumnDependencyManager &&other) = default;
 	ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
 
 public:

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -46,7 +46,7 @@ public:
 	DUCKDB_API void Reset();
 
 	DUCKDB_API const vector<CatalogSearchEntry> &Get();
-	DUCKDB_API const vector<CatalogSearchEntry> &GetSetPaths() {
+	const vector<CatalogSearchEntry> &GetSetPaths() {
 		return set_paths;
 	}
 	DUCKDB_API const CatalogSearchEntry &GetDefault();

package/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp

@@ -23,7 +23,7 @@ struct SimilarCatalogEntry {
 	//! The schema of the entry.
 	optional_ptr<SchemaCatalogEntry> schema;
 
-	DUCKDB_API bool Found() const {
+	bool Found() const {
 		return !name.empty();
 	}
 

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

@@ -121,7 +121,7 @@ public:
 	DUCKDB_API static bool UncaughtException();
 
 	DUCKDB_API static string GetStackTrace(int max_depth = 120);
-	DUCKDB_API static string FormatStackTrace(string message = "") {
+	static string FormatStackTrace(string message = "") {
 		return (message + "\n" + GetStackTrace());
 	}
 
@@ -269,7 +269,7 @@ public:
 class IOException : public Exception {
 public:
 	DUCKDB_API explicit IOException(const string &msg);
-	DUCKDB_API explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
+	explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
 	}
 
 	template <typename... Args>
@@ -371,7 +371,7 @@ public:
 
 class FatalException : public Exception {
 public:
-	DUCKDB_API explicit FatalException(const string &msg) : FatalException(ExceptionType::FATAL, msg) {
+	explicit FatalException(const string &msg) : FatalException(ExceptionType::FATAL, msg) {
 	}
 	template <typename... Args>
 	explicit FatalException(const string &msg, Args... params) : FatalException(ConstructMessage(msg, params...)) {

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

@@ -15,6 +15,28 @@
 
 namespace duckdb {
 
+// Helper class to support custom overloading
+// Escaping " and quoting the value with "
+class SQLIdentifier {
+public:
+	SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
+// Helper class to support custom overloading
+// Escaping ' and quoting the value with '
+class SQLString {
+public:
+	SQLString(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
 enum class PhysicalType : uint8_t;
 struct LogicalType;
 
@@ -47,6 +69,10 @@ public:
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
 template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLString value);
+template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLIdentifier value);
+template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);

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

@@ -178,6 +178,9 @@ public:
 	DUCKDB_API static string PathSeparator();
 	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
 	DUCKDB_API static bool IsPathAbsolute(const string &path);
+	//! Normalize an absolute path - the goal of normalizing is converting "\test.db" and "C:/test.db" into "C:\test.db"
+	//! so that the database system cache can correctly
+	DUCKDB_API static string NormalizeAbsolutePath(const string &path);
 	//! Join two paths together
 	DUCKDB_API static string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
@@ -187,6 +190,11 @@ public:
 	//! Extract the name of a file (e.g if the input is lib/example.dll the name is 'example.dll')
 	DUCKDB_API static string ExtractName(const string &path);
 
+	//! Returns the value of an environment variable - or the empty string if it is not set
+	DUCKDB_API static string GetEnvVariable(const string &name);
+
+	//! Whether there is a glob in the string
+	DUCKDB_API static bool HasGlob(const string &str);
 	//! Runs a glob on the file system, returning a list of matching files
 	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
 	DUCKDB_API vector<string> GlobFiles(const string &path, ClientContext &context,
@@ -224,6 +232,9 @@ public:
 
 	//! Return the name of the filesytem. Used for forming diagnosis messages.
 	DUCKDB_API virtual std::string GetName() const = 0;
+
+	//! Whether or not a file is remote or local, based only on file path
+	DUCKDB_API static bool IsRemoteFile(const string &path);
 };
 
 } // namespace duckdb

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

@@ -12,6 +12,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
@@ -48,7 +49,7 @@ public:
 	}
 
 	//! helper function to get the HTTP
-	static HTTPState *TryGetState(FileOpener *opener) {
+	static optional_ptr<HTTPState> TryGetState(FileOpener *opener) {
 		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
 			return client_context->client_data->http_state.get();

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

@@ -12,14 +12,14 @@ public:
 	int64_t upper;
 
 public:
-	DUCKDB_API hugeint_t() = default;
+	hugeint_t() = default;
 	DUCKDB_API hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
-	DUCKDB_API constexpr hugeint_t(int64_t upper, uint64_t lower) : lower(lower), upper(upper) {
+	constexpr hugeint_t(int64_t upper, uint64_t lower) : lower(lower), upper(upper) {
 	}
-	DUCKDB_API constexpr hugeint_t(const hugeint_t &rhs) = default;
-	DUCKDB_API constexpr 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;
+	constexpr hugeint_t(const hugeint_t &rhs) = default;
+	constexpr hugeint_t(hugeint_t &&rhs) = default;
+	hugeint_t &operator=(const hugeint_t &rhs) = default;
+	hugeint_t &operator=(hugeint_t &&rhs) = default;
 
 	DUCKDB_API string ToString() const;
 

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;