duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
-
 #ifndef DUCKDB_NO_THREADS
 #include "concurrentqueue.h"
 #include "duckdb/common/thread.hpp"
@@ -21,10 +20,12 @@
 #elif defined(__GNUC__)
 #include <sched.h>
 #include <unistd.h>
+#if defined(__GLIBC__)
+#include <pthread.h>
+#endif
 #endif
 
 namespace duckdb {
-
 struct SchedulerThread {
 #ifndef DUCKDB_NO_THREADS
 	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(std::move(thread_p)) {
@@ -39,15 +40,30 @@ typedef duckdb_moodycamel::ConcurrentQueue<shared_ptr<Task>> concurrent_queue_t;
 typedef duckdb_moodycamel::LightweightSemaphore lightweight_semaphore_t;
 
 struct ConcurrentQueue {
-	concurrent_queue_t q;
+	ConcurrentQueue() : tasks_in_queue(0) {
+	}
+
 	lightweight_semaphore_t semaphore;
 
 	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
+	void EnqueueBulk(ProducerToken &token, vector<shared_ptr<Task>> &tasks);
 	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
+	bool Dequeue(shared_ptr<Task> &task);
+	idx_t GetTasksInQueue() const;
+	idx_t GetApproxSize() const;
+	idx_t GetProducerCount() const;
+	idx_t GetTaskCountForProducer(ProducerToken &token) const;
+	concurrent_queue_t &GetQueue() {
+		return q;
+	}
+
+private:
+	concurrent_queue_t q;
+	atomic<idx_t> tasks_in_queue;
 };
 
 struct QueueProducerToken {
-	explicit QueueProducerToken(ConcurrentQueue &queue) : queue_token(queue.q) {
+	explicit QueueProducerToken(ConcurrentQueue &queue) : queue_token(queue.GetQueue()) {
 	}
 
 	duckdb_moodycamel::ProducerToken queue_token;
@@ -57,24 +73,72 @@ void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
 	lock_guard<mutex> producer_lock(token.producer_lock);
 	task->token = token;
 	if (q.enqueue(token.token->queue_token, std::move(task))) {
+		++tasks_in_queue;
 		semaphore.signal();
 	} else {
 		throw InternalException("Could not schedule task!");
 	}
 }
 
+void ConcurrentQueue::EnqueueBulk(ProducerToken &token, vector<shared_ptr<Task>> &tasks) {
+	typedef std::make_signed<std::size_t>::type ssize_t;
+	lock_guard<mutex> producer_lock(token.producer_lock);
+	for (auto &task : tasks) {
+		task->token = token;
+	}
+	if (q.enqueue_bulk(token.token->queue_token, std::make_move_iterator(tasks.begin()), tasks.size())) {
+		tasks_in_queue += tasks.size();
+		semaphore.signal(NumericCast<ssize_t>(tasks.size()));
+	} else {
+		throw InternalException("Could not schedule tasks!");
+	}
+}
+
 bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	lock_guard<mutex> producer_lock(token.producer_lock);
-	return q.try_dequeue_from_producer(token.token->queue_token, task);
+	if (!q.try_dequeue_from_producer(token.token->queue_token, task)) {
+		return false;
+	}
+	--tasks_in_queue;
+	return true;
+}
+
+bool ConcurrentQueue::Dequeue(shared_ptr<Task> &task) {
+	if (!q.try_dequeue(task)) {
+		return false;
+	}
+	--tasks_in_queue;
+	return true;
+}
+
+idx_t ConcurrentQueue::GetTasksInQueue() const {
+	return tasks_in_queue;
+}
+idx_t ConcurrentQueue::GetApproxSize() const {
+	return q.size_approx();
+}
+idx_t ConcurrentQueue::GetProducerCount() const {
+	return q.size_producers_approx();
+}
+
+idx_t ConcurrentQueue::GetTaskCountForProducer(ProducerToken &token) const {
+	lock_guard<mutex> producer_lock(token.producer_lock);
+	return q.size_producer_approx(token.token->queue_token);
 }
 
 #else
 struct ConcurrentQueue {
 	reference_map_t<QueueProducerToken, std::queue<shared_ptr<Task>>> q;
-	mutex qlock;
+	mutable mutex qlock;
 
 	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
+	void EnqueueBulk(ProducerToken &token, vector<shared_ptr<Task>> &tasks);
 	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
+	bool Dequeue(shared_ptr<Task> &task);
+	idx_t GetTasksInQueue() const;
+	idx_t GetApproxSize() const;
+	idx_t GetProducerCount() const;
+	idx_t GetTaskCountForProducer(ProducerToken &token) const;
 };
 
 void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
@@ -83,6 +147,14 @@ void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
 	q[std::ref(*token.token)].push(std::move(task));
 }
 
+void ConcurrentQueue::EnqueueBulk(ProducerToken &token, vector<shared_ptr<Task>> &tasks) {
+	lock_guard<mutex> lock(qlock);
+	for (auto &task : tasks) {
+		task->token = token;
+		q[std::ref(*token.token)].push(std::move(task));
+	}
+}
+
 bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	lock_guard<mutex> lock(qlock);
 	D_ASSERT(!q.empty());
@@ -98,6 +170,37 @@ bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task>
 	return true;
 }
 
+bool ConcurrentQueue::Dequeue(shared_ptr<Task> &task) {
+	throw InternalException("Global dequeue not supported for no threads queue");
+}
+
+idx_t ConcurrentQueue::GetTasksInQueue() const {
+	lock_guard<mutex> lock(qlock);
+	idx_t task_count = 0;
+	for (auto &producer : q) {
+		task_count += producer.second.size();
+	}
+	return task_count;
+}
+
+idx_t ConcurrentQueue::GetApproxSize() const {
+	return GetTasksInQueue();
+}
+
+idx_t ConcurrentQueue::GetProducerCount() const {
+	lock_guard<mutex> lock(qlock);
+	return q.size();
+}
+
+idx_t ConcurrentQueue::GetTaskCountForProducer(ProducerToken &token) const {
+	lock_guard<mutex> lock(qlock);
+	const auto it = q.find(std::ref(*token.token));
+	if (it == q.end()) {
+		return 0;
+	}
+	return it->second.size();
+}
+
 struct QueueProducerToken {
 	explicit QueueProducerToken(ConcurrentQueue &queue) : queue(&queue) {
 	}
@@ -155,6 +258,10 @@ void TaskScheduler::ScheduleTask(ProducerToken &token, shared_ptr<Task> task) {
 	queue->Enqueue(token, std::move(task));
 }
 
+void TaskScheduler::ScheduleTasks(ProducerToken &producer, vector<shared_ptr<Task>> &tasks) {
+	queue->EnqueueBulk(producer, tasks);
+}
+
 bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	return queue->DequeueFromProducer(token, task);
 }
@@ -188,7 +295,7 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 				}
 			}
 		}
-		if (queue->q.try_dequeue(task)) {
+		if (queue->Dequeue(task)) {
 			auto process_mode = config.options.scheduler_process_partial ? TaskExecutionMode::PROCESS_PARTIAL
 			                                                             : TaskExecutionMode::PROCESS_ALL;
 			auto execute_result = task->Execute(process_mode);
@@ -209,6 +316,9 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 				task.reset();
 				break;
 			}
+		} else if (queue->GetTasksInQueue() > 0) {
+			// failed to dequeue but there are still tasks remaining - signal again to retry
+			queue->semaphore.signal(1);
 		}
 	}
 	// this thread will exit, flush all of its outstanding allocations
@@ -227,7 +337,7 @@ idx_t TaskScheduler::ExecuteTasks(atomic<bool> *marker, idx_t max_tasks) {
 	// loop until the marker is set to false
 	while (*marker && completed_tasks < max_tasks) {
 		shared_ptr<Task> task;
-		if (!queue->q.try_dequeue(task)) {
+		if (!queue->Dequeue(task)) {
 			return completed_tasks;
 		}
 		auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
@@ -257,7 +367,7 @@ void TaskScheduler::ExecuteTasks(idx_t max_tasks) {
 	shared_ptr<Task> task;
 	for (idx_t i = 0; i < max_tasks; i++) {
 		queue->semaphore.wait(TASK_TIMEOUT_USECS);
-		if (!queue->q.try_dequeue(task)) {
+		if (!queue->Dequeue(task)) {
 			return;
 		}
 		try {
@@ -294,36 +404,15 @@ int32_t TaskScheduler::NumberOfThreads() {
 }
 
 idx_t TaskScheduler::GetNumberOfTasks() const {
-#ifndef DUCKDB_NO_THREADS
-	return queue->q.size_approx();
-#else
-	idx_t task_count = 0;
-	for (auto &producer : queue->q) {
-		task_count += producer.second.size();
-	}
-	return task_count;
-#endif
+	return queue->GetTasksInQueue();
 }
 
 idx_t TaskScheduler::GetProducerCount() const {
-#ifndef DUCKDB_NO_THREADS
-	return queue->q.size_producers_approx();
-#else
-	return queue->q.size();
-#endif
+	return queue->GetProducerCount();
 }
 
 idx_t TaskScheduler::GetTaskCountForProducer(ProducerToken &token) const {
-#ifndef DUCKDB_NO_THREADS
-	lock_guard<mutex> producer_lock(token.producer_lock);
-	return queue->q.size_producer_approx(token.token->queue_token);
-#else
-	const auto it = queue->q.find(std::ref(*token.token));
-	if (it == queue->q.end()) {
-		return 0;
-	}
-	return it->second.size();
-#endif
+	return queue->GetTaskCountForProducer(token);
 }
 
 void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) {
@@ -390,7 +479,7 @@ idx_t TaskScheduler::GetEstimatedCPUId() {
 	/* Other oses most likely use tpidr_el0 instead */
 	uintptr_t c;
 	asm volatile("mrs %x0, tpidrro_el0" : "=r"(c)::"memory");
-	return (idx_t)(c & (1 << 3) - 1);
+	return (idx_t)(c & ((1 << 3) - 1));
 #else
 #ifndef DUCKDB_NO_THREADS
 	// fallback to thread id
@@ -408,6 +497,20 @@ void TaskScheduler::RelaunchThreads() {
 	RelaunchThreadsInternal(n);
 }
 
+#ifndef DUCKDB_NO_THREADS
+static void SetThreadAffinity(thread &thread, const int &cpu_id) {
+#if defined(__GLIBC__)
+	cpu_set_t cpuset;
+	CPU_ZERO(&cpuset);
+	CPU_SET(cpu_id, &cpuset);
+
+	// note that we don't care about the return value here
+	// if we did not manage to set affinity, the thread just does not have affinity, which is OK
+	pthread_setaffinity_np(thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+#endif
+}
+#endif
+
 void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
 #ifndef DUCKDB_NO_THREADS
 	auto &config = DBConfig::GetConfig(db);
@@ -433,12 +536,21 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
 	if (threads.size() < new_thread_count) {
 		// we are increasing the number of threads: launch them and run tasks on them
 		idx_t create_new_threads = new_thread_count - threads.size();
+
+		// Whether to pin threads to cores
+		static constexpr idx_t THREAD_PIN_THRESHOLD = 64;
+		const auto pin_threads = db.config.options.pin_threads == ThreadPinMode::ON ||
+		                         (db.config.options.pin_threads == ThreadPinMode::AUTO &&
+		                          std::thread::hardware_concurrency() > THREAD_PIN_THRESHOLD);
 		for (idx_t i = 0; i < create_new_threads; i++) {
 			// launch a thread and assign it a cancellation marker
 			auto marker = unique_ptr<atomic<bool>>(new atomic<bool>(true));
 			unique_ptr<thread> worker_thread;
 			try {
 				worker_thread = make_uniq<thread>(ThreadExecuteTasks, this, marker.get());
+				if (pin_threads) {
+					SetThreadAffinity(*worker_thread, NumericCast<int>(threads.size()));
+				}
 			} catch (std::exception &ex) {
 				// thread constructor failed - this can happen when the system has too many threads allocated
 				// in this case we cannot allocate more threads - stop launching them

package/src/duckdb/src/parallel/thread_context.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/logging/logger.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 namespace duckdb {
 
@@ -20,15 +21,7 @@ ThreadContext::ThreadContext(ClientContext &context) : profiler(context) {
 	}
 
 	log_context.thread_id = TaskScheduler::GetEstimatedCPUId();
-	if (context.transaction.HasActiveTransaction()) {
-		auto query_id = context.transaction.GetActiveQuery();
-		if (query_id == DConstants::INVALID_INDEX) {
-			log_context.transaction_id = optional_idx();
-		} else {
-			log_context.transaction_id = query_id;
-		}
-	}
-	logger = context.db->GetLogManager().CreateLogger(log_context, true);
+	logger = LogManager::Get(context).CreateLogger(log_context, true);
 }
 
 ThreadContext::~ThreadContext() {

package/src/duckdb/src/parser/column_definition.cpp

@@ -122,16 +122,13 @@ bool ColumnDefinition::Generated() const {
 // Generated Columns (VIRTUAL)
 //===--------------------------------------------------------------------===//
 
-static void VerifyColumnRefs(ParsedExpression &expr) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &column_ref = expr.Cast<ColumnRefExpression>();
+static void VerifyColumnRefs(const ParsedExpression &expr) {
+	ParsedExpressionIterator::VisitExpression<ColumnRefExpression>(expr, [&](const ColumnRefExpression &column_ref) {
 		if (column_ref.IsQualified()) {
 			throw ParserException(
 			    "Qualified (tbl.name) column references are not allowed inside of generated column expressions");
 		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { VerifyColumnRefs((ParsedExpression &)child); });
+	});
 }
 
 static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &dependencies) {

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -28,6 +28,7 @@ WindowExpression::WindowExpression(ExpressionType type, string catalog_name, str
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
 	case ExpressionType::WINDOW_NTILE:
+	case ExpressionType::WINDOW_FILL:
 		break;
 	default:
 		throw NotImplementedException("Window aggregate type %s not supported", ExpressionTypeToString(type).c_str());
@@ -57,6 +58,8 @@ ExpressionType WindowExpression::WindowToExpressionType(string &fun_name) {
 		return ExpressionType::WINDOW_LAG;
 	} else if (fun_name == "ntile") {
 		return ExpressionType::WINDOW_NTILE;
+	} else if (fun_name == "fill") {
+		return ExpressionType::WINDOW_FILL;
 	}
 	return ExpressionType::WINDOW_AGGREGATE;
 }

package/src/duckdb/src/parser/parsed_data/attach_info.cpp

@@ -7,44 +7,14 @@
 
 namespace duckdb {
 
-StorageOptions AttachInfo::GetStorageOptions() const {
-	StorageOptions storage_options;
-	string storage_version_user_provided = "";
-	for (auto &entry : options) {
-		if (entry.first == "block_size") {
-			// Extract the block allocation size. This is NOT the actual memory available on a block (block_size),
-			// even though the corresponding option we expose to the user is called "block_size".
-			storage_options.block_alloc_size = entry.second.GetValue<uint64_t>();
-		} else if (entry.first == "encryption_key") {
-			storage_options.block_header_size = DEFAULT_ENCRYPTION_BLOCK_HEADER_SIZE;
-			storage_options.encryption = true;
-		} else if (entry.first == "row_group_size") {
-			storage_options.row_group_size = entry.second.GetValue<uint64_t>();
-		} else if (entry.first == "storage_version") {
-			storage_version_user_provided = entry.second.ToString();
-			storage_options.storage_version =
-			    SerializationCompatibility::FromString(entry.second.ToString()).serialization_version;
-		}
-	}
-	if (storage_options.encryption && (!storage_options.storage_version.IsValid() ||
-	                                   storage_options.storage_version.GetIndex() <
-	                                       SerializationCompatibility::FromString("v1.3.0").serialization_version)) {
-		if (!storage_version_user_provided.empty()) {
-			throw InvalidInputException(
-			    "Explicit provided STORAGE_VERSION (\"%s\") and ENCRYPTION_KEY (storage >= v1.3.0) are not compatible",
-			    storage_version_user_provided);
-		}
-		// set storage version to v1.3.0
-		storage_options.storage_version = SerializationCompatibility::FromString("v1.3.0").serialization_version;
-	}
-	return storage_options;
-}
-
 unique_ptr<AttachInfo> AttachInfo::Copy() const {
 	auto result = make_uniq<AttachInfo>();
 	result->name = name;
 	result->path = path;
 	result->options = options;
+	for (auto &entry : parsed_options) {
+		result->parsed_options[entry.first] = entry.second->Copy();
+	}
 	result->on_conflict = on_conflict;
 	return result;
 }
@@ -57,13 +27,16 @@ string AttachInfo::ToString() const {
 	} else if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		result += " OR REPLACE";
 	}
-	result += " DATABASE";
+	result += " DATABASE ";
 	result += KeywordHelper::WriteQuoted(path, '\'');
 	if (!name.empty()) {
 		result += " AS " + KeywordHelper::WriteOptionallyQuoted(name);
 	}
-	if (!options.empty()) {
+	if (!parsed_options.empty() || !options.empty()) {
 		vector<string> stringified;
+		for (auto &opt : parsed_options) {
+			stringified.push_back(StringUtil::Format("%s %s", opt.first, opt.second->ToString()));
+		}
 		for (auto &opt : options) {
 			stringified.push_back(StringUtil::Format("%s %s", opt.first, opt.second.ToSQLString()));
 		}

package/src/duckdb/src/parser/parsed_data/copy_info.cpp

@@ -3,16 +3,24 @@
 
 namespace duckdb {
 
+CopyInfo::CopyInfo()
+    : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA), is_from(false), is_format_auto_detected(true) {
+}
+
 unique_ptr<CopyInfo> CopyInfo::Copy() const {
 	auto result = make_uniq<CopyInfo>();
 	result->catalog = catalog;
 	result->schema = schema;
 	result->table = table;
 	result->select_list = select_list;
+	result->file_path_expression = file_path_expression ? file_path_expression->Copy() : nullptr;
 	result->file_path = file_path;
 	result->is_from = is_from;
 	result->format = format;
 	result->is_format_auto_detected = is_format_auto_detected;
+	for (auto &entry : parsed_options) {
+		result->parsed_options[entry.first] = entry.second ? entry.second->Copy() : nullptr;
+	}
 	result->options = options;
 	if (select_statement) {
 		result->select_statement = select_statement->Copy();
@@ -20,11 +28,10 @@ unique_ptr<CopyInfo> CopyInfo::Copy() const {
 	return result;
 }
 
-string CopyInfo::CopyOptionsToString(const string &format, bool is_format_auto_detected,
-                                     const case_insensitive_map_t<vector<Value>> &options) {
+string CopyInfo::CopyOptionsToString() const {
 	// We only output the format if there is a format, and it was manually set.
 	const bool output_format = !format.empty() && !is_format_auto_detected;
-	if (!output_format && options.empty()) {
+	if (!output_format && options.empty() && parsed_options.empty()) {
 		return string();
 	}
 	string result;
@@ -34,6 +41,15 @@ string CopyInfo::CopyOptionsToString(const string &format, bool is_format_auto_d
 	if (!format.empty() && !is_format_auto_detected) {
 		stringified.push_back(StringUtil::Format(" FORMAT %s", format));
 	}
+	for (auto &opt : parsed_options) {
+		auto &name = opt.first;
+		auto &expr = opt.second;
+		string option_string = name;
+		if (expr) {
+			option_string += " " + expr->ToString();
+		}
+		stringified.push_back(option_string);
+	}
 	for (auto &opt : options) {
 		auto &name = opt.first;
 		auto &values = opt.second;
@@ -84,8 +100,6 @@ string CopyInfo::ToString() const {
 		D_ASSERT(!select_statement);
 		result += TablePartToString();
 		result += " FROM";
-		result += StringUtil::Format(" %s", SQLString(file_path));
-		result += CopyOptionsToString(format, is_format_auto_detected, options);
 	} else {
 		if (select_statement) {
 			// COPY (select-node) TO ...
@@ -94,9 +108,15 @@ string CopyInfo::ToString() const {
 			result += TablePartToString();
 		}
 		result += " TO ";
-		result += StringUtil::Format("%s", SQLString(file_path));
-		result += CopyOptionsToString(format, is_format_auto_detected, options);
 	}
+	if (file_path_expression && file_path.empty()) {
+		result += "(";
+		result += file_path_expression->ToString();
+		result += ")";
+	} else {
+		result += StringUtil::Format(" %s", SQLString(file_path));
+	}
+	result += CopyOptionsToString();
 	result += ";";
 	return result;
 }

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -14,19 +14,14 @@ CreateIndexInfo::CreateIndexInfo(const duckdb::CreateIndexInfo &info)
       column_ids(info.column_ids), scan_types(info.scan_types), names(info.names) {
 }
 
-static void RemoveTableQualificationRecursive(unique_ptr<ParsedExpression> &expr, const string &table_name) {
-	if (expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
-		ParsedExpressionIterator::EnumerateChildren(*expr, [&table_name](unique_ptr<ParsedExpression> &child) {
-			RemoveTableQualificationRecursive(child, table_name);
-		});
-		return;
-	}
-
-	auto &col_ref = expr->Cast<ColumnRefExpression>();
-	auto &col_names = col_ref.column_names;
-	if (col_ref.IsQualified() && col_ref.GetTableName() == table_name) {
-		col_names.erase(col_names.begin());
-	}
+static void RemoveTableQualificationRecursive(unique_ptr<ParsedExpression> &root_expr, const string &table_name) {
+	ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(
+	    *root_expr, [&](ColumnRefExpression &col_ref) {
+		    auto &col_names = col_ref.column_names;
+		    if (col_ref.IsQualified() && col_ref.GetTableName() == table_name) {
+			    col_names.erase(col_names.begin());
+		    }
+	    });
 }
 
 vector<string> CreateIndexInfo::ExpressionsToList() const {

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -28,4 +28,20 @@ unique_ptr<AlterInfo> CreateInfo::GetAlterInfo() const {
 	throw NotImplementedException("GetAlterInfo not implemented for this type");
 }
 
+string CreateInfo::GetCreatePrefix(const string &entry) const {
+	string prefix = "CREATE";
+	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
+		prefix += " OR REPLACE";
+	}
+	if (temporary) {
+		prefix += " TEMP";
+	}
+	prefix += " " + entry + " ";
+
+	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		prefix += " IF NOT EXISTS ";
+	}
+	return prefix;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_macro_info.cpp

@@ -18,26 +18,16 @@ CreateMacroInfo::CreateMacroInfo(CatalogType type, unique_ptr<MacroFunction> fun
 }
 
 string CreateMacroInfo::ToString() const {
-	string result;
+	auto prefix = GetCreatePrefix("MACRO");
+	prefix += QualifierToString(temporary ? "" : catalog, schema, name) + " ";
+	string definitions;
 	for (auto &function : macros) {
-		if (!result.empty()) {
-			result += ", ";
+		if (!definitions.empty()) {
+			definitions += ", ";
 		}
-		result += function->ToSQL();
+		definitions += function->ToSQL();
 	}
-	// prefix with CREATE MACRO
-	string prefix = "CREATE MACRO ";
-	if (!catalog.empty()) {
-		prefix += KeywordHelper::WriteOptionallyQuoted(catalog);
-		prefix += ".";
-	}
-	if (!schema.empty()) {
-		prefix += KeywordHelper::WriteOptionallyQuoted(schema);
-		prefix += ".";
-	}
-	prefix += KeywordHelper::WriteOptionallyQuoted(name);
-	result = prefix + " " + result + ";";
-	return result;
+	return prefix + definitions + ";";
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {

package/src/duckdb/src/parser/parsed_data/create_table_info.cpp

@@ -30,20 +30,7 @@ unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 }
 
 string CreateTableInfo::ToString() const {
-	string ret = "";
-
-	ret += "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		ret += " OR REPLACE";
-	}
-	if (temporary) {
-		ret += " TEMP";
-	}
-	ret += " TABLE ";
-
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		ret += " IF NOT EXISTS ";
-	}
+	string ret = GetCreatePrefix("TABLE");
 	ret += QualifierToString(temporary ? "" : catalog, schema, table);
 
 	if (query != nullptr) {

package/src/duckdb/src/parser/parsed_data/create_type_info.cpp

@@ -26,18 +26,7 @@ unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
 }
 
 string CreateTypeInfo::ToString() const {
-	string result = "";
-	result += "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		result += " OR REPLACE ";
-	}
-	if (temporary) {
-		result += " TEMPORARY";
-	}
-	result += " TYPE ";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		result += " IF NOT EXISTS ";
-	}
+	string result = GetCreatePrefix("TYPE");
 	result += QualifierToString(temporary ? "" : catalog, schema, name);
 	if (type.id() == LogicalTypeId::ENUM) {
 		auto &values_insert_order = EnumType::GetValuesInsertOrder(type);

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -20,19 +20,7 @@ CreateViewInfo::CreateViewInfo(SchemaCatalogEntry &schema, string view_name)
 }
 
 string CreateViewInfo::ToString() const {
-	string result;
-
-	result += "CREATE";
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		result += " OR REPLACE";
-	}
-	if (temporary) {
-		result += " TEMPORARY";
-	}
-	result += " VIEW ";
-	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
-		result += " IF NOT EXISTS ";
-	}
+	string result = GetCreatePrefix("VIEW");
 	result += QualifierToString(temporary ? "" : catalog, schema, view_name);
 	if (!aliases.empty()) {
 		result += " (";