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

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -724,6 +724,11 @@ unique_ptr<TableRef> ParquetScanReplacement(ClientContext &context, const string
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(make_uniq<ConstantExpression>(Value(table_name)));
 	table_function->function = make_uniq<FunctionExpression>("parquet_scan", std::move(children));
+
+	if (!FileSystem::HasGlob(table_name)) {
+		table_function->alias = FileSystem::ExtractBaseName(table_name);
+	}
+
 	return std::move(table_function);
 }
 

package/src/duckdb/src/common/file_system.cpp

@@ -305,6 +305,20 @@ void FileSystem::FileSync(FileHandle &handle) {
 	throw NotImplementedException("%s: FileSync is not implemented!", GetName());
 }
 
+bool FileSystem::HasGlob(const string &str) {
+	for (idx_t i = 0; i < str.size(); i++) {
+		switch (str[i]) {
+		case '*':
+		case '?':
+		case '[':
+			return true;
+		default:
+			break;
+		}
+	}
+	return false;
+}
+
 vector<string> FileSystem::Glob(const string &path, FileOpener *opener) {
 	throw NotImplementedException("%s: Glob is not implemented!", GetName());
 }
@@ -333,12 +347,8 @@ vector<string> FileSystem::GlobFiles(const string &pattern, ClientContext &conte
 	auto result = Glob(pattern);
 	if (result.empty()) {
 		string required_extension;
-		const string prefixes[] = {"http://", "https://", "s3://"};
-		for (auto &prefix : prefixes) {
-			if (StringUtil::StartsWith(pattern, prefix)) {
-				required_extension = "httpfs";
-				break;
-			}
+		if (FileSystem::IsRemoteFile(pattern)) {
+			required_extension = "httpfs";
 		}
 		if (!required_extension.empty() && !context.db->ExtensionIsLoaded(required_extension)) {
 			// an extension is required to read this file but it is not loaded - try to load it
@@ -455,4 +465,14 @@ FileType FileHandle::GetType() {
 	return file_system.GetFileType(*this);
 }
 
+bool FileSystem::IsRemoteFile(const string &path) {
+	const string prefixes[] = {"http://", "https://", "s3://"};
+	for (auto &prefix : prefixes) {
+		if (StringUtil::StartsWith(path, prefix)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/local_file_system.cpp

@@ -819,19 +819,6 @@ idx_t LocalFileSystem::SeekPosition(FileHandle &handle) {
 	return GetFilePointer(handle);
 }
 
-static bool HasGlob(const string &str) {
-	for (idx_t i = 0; i < str.size(); i++) {
-		switch (str[i]) {
-		case '*':
-		case '?':
-		case '[':
-			return true;
-		default:
-			break;
-		}
-	}
-	return false;
-}
 static bool IsCrawl(const string &glob) {
 	// glob must match exactly
 	return glob == "**";

package/src/duckdb/src/execution/operator/persistent/buffered_csv_reader.cpp

@@ -1172,6 +1172,16 @@ void BufferedCSVReader::SkipEmptyLines() {
 	}
 }
 
+void UpdateMaxLineLength(ClientContext &context, idx_t line_length) {
+	if (!context.client_data->debug_set_max_line_length) {
+		return;
+	}
+	if (line_length < context.client_data->debug_max_line_length) {
+		return;
+	}
+	context.client_data->debug_max_line_length = line_length;
+}
+
 bool BufferedCSVReader::TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message) {
 	// used for parsing algorithm
 	bool finished_chunk = false;
@@ -1239,9 +1249,7 @@ add_row : {
 		return false;
 	}
 	finished_chunk = AddRow(insert_chunk, column, error_message);
-	if (context.client_data->max_line_length < position - line_start) {
-		context.client_data->max_line_length = position - line_start;
-	}
+	UpdateMaxLineLength(context, position - line_start);
 	if (!error_message.empty()) {
 		return false;
 	}
@@ -1379,9 +1387,7 @@ final_state:
 		AddValue(string_t(buffer.get() + start, position - start - offset), column, escape_positions, has_quotes);
 		finished_chunk = AddRow(insert_chunk, column, error_message);
 		SkipEmptyLines();
-		if (context.client_data->max_line_length < position - line_start) {
-			context.client_data->max_line_length = position - line_start;
-		}
+		UpdateMaxLineLength(context, position - line_start);
 		if (!error_message.empty()) {
 			return false;
 		}

package/src/duckdb/src/execution/operator/persistent/csv_reader_options.cpp

@@ -183,6 +183,12 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 }
 
 void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value &value) {
+	if (loption == "new_line") {
+		// Steal this from SetBaseOption so we can write different newlines (e.g., format JSON ARRAY)
+		write_newline = ParseString(value, loption);
+		return;
+	}
+
 	if (SetBaseOption(loption, value)) {
 		return;
 	}
@@ -199,6 +205,10 @@ void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value
 		}
 		SetDateFormat(LogicalTypeId::TIMESTAMP, format, false);
 		SetDateFormat(LogicalTypeId::TIMESTAMP_TZ, format, false);
+	} else if (loption == "prefix") {
+		prefix = ParseString(value, loption);
+	} else if (loption == "suffix") {
+		suffix = ParseString(value, loption);
 	} else {
 		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
 	}

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -50,15 +50,17 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
 	return R"(
 			SELECT
+				t.database_name AS database,
+				t.schema_name AS schema,
 				t.table_name,
 				LIST(c.column_name order by c.column_index) AS column_names,
 				LIST(c.data_type order by c.column_index) AS column_types,
-				FIRST(t.temporary) AS temporary
+				FIRST(t.temporary) AS temporary,
 			FROM duckdb_tables t
 			JOIN duckdb_columns c
 			USING (table_oid)
-			GROUP BY t.table_name
-			ORDER BY t.table_name;
+			GROUP BY t.database_name, t.schema_name, t.table_name
+			ORDER BY t.database_name, t.schema_name, t.table_name;
 	)";
 }
 

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

@@ -1,15 +1,16 @@
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/file_system.hpp"
+#include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/types/column/column_data_collection.hpp"
+
 #include <limits>
 
 namespace duckdb {
@@ -57,6 +58,15 @@ void BaseCSVData::Finalize() {
 			SubstringDetection(options.escape, options.null_str, "ESCAPE", "NULL");
 		}
 	}
+
+	if (!options.prefix.empty() || !options.suffix.empty()) {
+		if (options.prefix.empty() || options.suffix.empty()) {
+			throw BinderException("COPY ... (FORMAT CSV) must have both PREFIX and SUFFIX, or none at all");
+		}
+		if (options.header) {
+			throw BinderException("COPY ... (FORMAT CSV)'s HEADER cannot be combined with PREFIX/SUFFIX");
+		}
+	}
 }
 
 static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &info, vector<string> &names,
@@ -85,6 +95,9 @@ static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &i
 		bind_data->requires_quotes[bind_data->options.delimiter[0]] = true;
 		bind_data->requires_quotes[bind_data->options.quote[0]] = true;
 	}
+	if (!bind_data->options.write_newline.empty()) {
+		bind_data->newline = bind_data->options.write_newline;
+	}
 	return std::move(bind_data);
 }
 
@@ -251,24 +264,41 @@ struct LocalWriteCSVData : public LocalFunctionData {
 	BufferedSerializer serializer;
 	//! A chunk with VARCHAR columns to cast intermediates into
 	DataChunk cast_chunk;
+	//! If we've written any rows yet, allows us to prevent a trailing comma when writing JSON ARRAY
+	bool written_anything = false;
 };
 
 struct GlobalWriteCSVData : public GlobalFunctionData {
-	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileCompressionType compression) : fs(fs) {
+	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileCompressionType compression)
+	    : fs(fs), written_anything(false) {
 		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW,
 		                     FileLockType::WRITE_LOCK, compression);
 	}
 
+	//! Write generic data, e.g., CSV header
 	void WriteData(const_data_ptr_t data, idx_t size) {
 		lock_guard<mutex> flock(lock);
 		handle->Write((void *)data, size);
 	}
 
+	//! Write rows
+	void WriteRows(const_data_ptr_t data, idx_t size, const string &newline) {
+		lock_guard<mutex> flock(lock);
+		if (written_anything) {
+			handle->Write((void *)newline.c_str(), newline.length());
+		} else {
+			written_anything = true;
+		}
+		handle->Write((void *)data, size);
+	}
+
 	FileSystem &fs;
 	//! The mutex for writing to the physical file
 	mutex lock;
 	//! The file handle to write to
 	unique_ptr<FileHandle> handle;
+	//! If we've written any rows yet, allows us to prevent a trailing comma when writing JSON ARRAY
+	bool written_anything;
 };
 
 static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ExecutionContext &context, FunctionData &bind_data) {
@@ -290,6 +320,10 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 	auto global_data =
 	    make_uniq<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path, options.compression);
 
+	if (!options.prefix.empty()) {
+		global_data->WriteData((const_data_ptr_t)options.prefix.c_str(), options.prefix.size());
+	}
+
 	if (options.header) {
 		BufferedSerializer serializer;
 		// write the header line to the file
@@ -304,11 +338,12 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 
 		global_data->WriteData(serializer.blob.data.get(), serializer.blob.size);
 	}
+
 	return std::move(global_data);
 }
 
 static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_data, DataChunk &cast_chunk,
-                                  BufferedSerializer &writer, DataChunk &input) {
+                                  BufferedSerializer &writer, DataChunk &input, bool &written_anything) {
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &options = csv_data.options;
 
@@ -338,6 +373,11 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 	cast_chunk.Flatten();
 	// now loop over the vectors and output the values
 	for (idx_t row_idx = 0; row_idx < cast_chunk.size(); row_idx++) {
+		if (row_idx == 0 && !written_anything) {
+			written_anything = true;
+		} else {
+			writer.WriteBufferData(csv_data.newline);
+		}
 		// write values
 		for (idx_t col_idx = 0; col_idx < cast_chunk.ColumnCount(); col_idx++) {
 			if (col_idx != 0) {
@@ -357,7 +397,6 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 			WriteQuotedString(writer, csv_data, str_data[row_idx].GetData(), str_data[row_idx].GetSize(),
 			                  csv_data.options.force_quote[col_idx]);
 		}
-		writer.WriteBufferData(csv_data.newline);
 	}
 }
 
@@ -368,13 +407,15 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
 
 	// write data into the local buffer
-	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.serializer, input);
+	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.serializer, input,
+	                      local_data.written_anything);
 
 	// check if we should flush what we have currently written
 	auto &writer = local_data.serializer;
 	if (writer.blob.size >= csv_data.flush_size) {
-		global_state.WriteData(writer.blob.data.get(), writer.blob.size);
+		global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
 		writer.Reset();
+		local_data.written_anything = false;
 	}
 }
 
@@ -385,10 +426,11 @@ static void WriteCSVCombine(ExecutionContext &context, FunctionData &bind_data,
                             LocalFunctionData &lstate) {
 	auto &local_data = lstate.Cast<LocalWriteCSVData>();
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
+	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &writer = local_data.serializer;
 	// flush the local writer
-	if (writer.blob.size > 0) {
-		global_state.WriteData(writer.blob.data.get(), writer.blob.size);
+	if (local_data.written_anything) {
+		global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
 		writer.Reset();
 	}
 }
@@ -398,6 +440,16 @@ static void WriteCSVCombine(ExecutionContext &context, FunctionData &bind_data,
 //===--------------------------------------------------------------------===//
 void WriteCSVFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
+	auto &csv_data = bind_data.Cast<WriteCSVData>();
+	auto &options = csv_data.options;
+
+	BufferedSerializer serializer;
+	if (!options.suffix.empty()) {
+		serializer.WriteBufferData(options.suffix);
+	} else if (global_state.written_anything) {
+		serializer.WriteBufferData(csv_data.newline);
+	}
+	global_state.WriteData(serializer.blob.data.get(), serializer.blob.size);
 
 	global_state.handle->Close();
 	global_state.handle.reset();
@@ -434,10 +486,11 @@ unique_ptr<PreparedBatchData> WriteCSVPrepareBatch(ClientContext &context, Funct
 	DataChunk cast_chunk;
 	cast_chunk.Initialize(Allocator::Get(context), types);
 
-	auto batch = make_uniq<WriteCSVBatchData>();
 	// write CSV chunks to the batch data
+	bool written_anything = false;
+	auto batch = make_uniq<WriteCSVBatchData>();
 	for (auto &chunk : collection->Chunks()) {
-		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->serializer, chunk);
+		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->serializer, chunk, written_anything);
 	}
 	return std::move(batch);
 }
@@ -449,8 +502,9 @@ void WriteCSVFlushBatch(ClientContext &context, FunctionData &bind_data, GlobalF
                         PreparedBatchData &batch) {
 	auto &csv_batch = batch.Cast<WriteCSVBatchData>();
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
+	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &writer = csv_batch.serializer;
-	global_state.WriteData(writer.blob.data.get(), writer.blob.size);
+	global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
 	writer.Reset();
 }
 

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);
 		}
@@ -1190,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-dev3546"
+#define DUCKDB_VERSION "0.7.2-dev3666"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "bd8adef6d1"
+#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/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/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;