duckdb 0.7.2-dev3515.0 → 0.7.2-dev3666.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);
 		}
@@ -1055,6 +1060,12 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializable(file_options);
 	// write options
 	writer.WriteListNoReference<bool>(force_quote);
+	// FIXME: serialize date_format / has_format
+	vector<string> csv_formats;
+	for (auto &format : date_format) {
+		csv_formats.push_back(format.second.format_specifier);
+	}
+	writer.WriteList<string>(csv_formats);
 }
 
 void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
@@ -1091,6 +1102,17 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	file_options = reader.ReadRequiredSerializable<MultiFileReaderOptions, MultiFileReaderOptions>();
 	// write options
 	force_quote = reader.ReadRequiredList<bool>();
+	auto formats = reader.ReadRequiredList<string>();
+	vector<LogicalTypeId> format_types {LogicalTypeId::DATE, LogicalTypeId::TIMESTAMP};
+	for (idx_t f_idx = 0; f_idx < formats.size(); f_idx++) {
+		auto &format = formats[f_idx];
+		auto &type = format_types[f_idx];
+		if (format.empty()) {
+			continue;
+		}
+		has_format[type] = true;
+		StrTimeFormat::ParseFormatSpecifier(format, date_format[type]);
+	}
 }
 
 static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
@@ -1173,6 +1195,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-dev3515"
+#define DUCKDB_VERSION "0.7.2-dev3666"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "12638bd156"
+#define DUCKDB_SOURCE_ID "eae707d54c"
 #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/function/table_macro_function.cpp

@@ -31,4 +31,14 @@ string TableMacroFunction::ToSQL(const string &schema, const string &name) const
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
 }
 
+void TableMacroFunction::SerializeInternal(FieldWriter &writer) const {
+	writer.WriteSerializable(*query_node);
+}
+
+unique_ptr<MacroFunction> TableMacroFunction::Deserialize(FieldReader &reader) {
+	auto result = make_uniq<TableMacroFunction>();
+	result->query_node = reader.ReadRequiredSerializable<QueryNode>();
+	return std::move(result);
+}
+
 } // namespace duckdb

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_entry/macro_catalog_entry.hpp

@@ -24,8 +24,10 @@ public:
 	unique_ptr<MacroFunction> function;
 
 public:
+	virtual unique_ptr<CreateMacroInfo> GetInfoForSerialization() const;
 	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) const = 0;
+	virtual void Serialize(Serializer &serializer) const;
+	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &main_source, ClientContext &context);
 
 	string ToSQL() const override {
 		return function->ToSQL(schema.name, name);

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

@@ -23,11 +23,5 @@ public:
 
 public:
 	ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) const override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };
 } // namespace duckdb

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

@@ -22,12 +22,6 @@ public:
 
 public:
 	TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) const override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };
 
 } // namespace duckdb

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/constants.hpp

@@ -15,6 +15,8 @@
 #include "duckdb/common/typedefs.hpp"
 
 namespace duckdb {
+class Serializer;
+class Deserializer;
 
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE

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/field_writer.hpp

@@ -263,15 +263,15 @@ public:
 		return ReadRequiredGenericList<T, idx_t, IndexReadOperation>();
 	}
 
-	template <class T>
-	set<T> ReadRequiredSet() {
+	template <class T, class CONTAINER_TYPE = set<T>>
+	CONTAINER_TYPE ReadRequiredSet() {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read a required field, but field is missing");
 		}
 		AddField();
 		auto result_count = source.Read<uint32_t>();
-		set<T> result;
+		CONTAINER_TYPE result;
 		for (idx_t i = 0; i < result_count; i++) {
 			result.insert(source.Read<T>());
 		}

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

@@ -187,6 +187,8 @@ 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);
 
+	//! 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 +226,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!");
 	}
 };