duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

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

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/chrono.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 
@@ -108,7 +109,11 @@ TaskScheduler::TaskScheduler(DatabaseInstance &db)
 
 TaskScheduler::~TaskScheduler() {
 #ifndef DUCKDB_NO_THREADS
-	RelaunchThreadsInternal(0);
+	try {
+		RelaunchThreadsInternal(0);
+	} catch (...) {
+		// nothing we can do in the destructor if this fails
+	}
 #endif
 }
 
@@ -260,7 +265,8 @@ void TaskScheduler::SetAllocatorFlushTreshold(idx_t threshold) {
 
 void TaskScheduler::Signal(idx_t n) {
 #ifndef DUCKDB_NO_THREADS
-	queue->semaphore.signal(n);
+	typedef std::make_signed<std::size_t>::type ssize_t;
+	queue->semaphore.signal(NumericCast<ssize_t>(n));
 #endif
 }
 
@@ -279,7 +285,7 @@ void TaskScheduler::RelaunchThreads() {
 void TaskScheduler::RelaunchThreadsInternal(int32_t n) {
 #ifndef DUCKDB_NO_THREADS
 	auto &config = DBConfig::GetConfig(db);
-	idx_t new_thread_count = n;
+	auto new_thread_count = NumericCast<idx_t>(n);
 	if (threads.size() == new_thread_count) {
 		current_thread_count = NumericCast<int32_t>(threads.size() + config.options.external_threads);
 		return;

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

@@ -23,6 +23,7 @@ ColumnDefinition ColumnDefinition::Copy() const {
 	copy.compression_type = compression_type;
 	copy.category = category;
 	copy.comment = comment;
+	copy.tags = tags;
 	return copy;
 }
 

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -29,15 +29,17 @@ string ForeignKeyConstraint::ToString() const {
 			base += ".";
 		}
 		base += info.table;
-		base += "(";
-
-		for (idx_t i = 0; i < pk_columns.size(); i++) {
-			if (i > 0) {
-				base += ", ";
+		if (!pk_columns.empty()) {
+			base += "(";
+
+			for (idx_t i = 0; i < pk_columns.size(); i++) {
+				if (i > 0) {
+					base += ", ";
+				}
+				base += KeywordHelper::WriteOptionallyQuoted(pk_columns[i]);
 			}
-			base += KeywordHelper::WriteOptionallyQuoted(pk_columns[i]);
+			base += ")";
 		}
-		base += ")";
 
 		return base;
 	}

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

@@ -28,7 +28,7 @@ string StarExpression::ToString() const {
 			if (!first_entry) {
 				result += ", ";
 			}
-			result += entry;
+			result += KeywordHelper::WriteOptionallyQuoted(entry);
 			first_entry = false;
 		}
 		result += ")";
@@ -42,7 +42,7 @@ string StarExpression::ToString() const {
 			}
 			result += entry.second->ToString();
 			result += " AS ";
-			result += entry.first;
+			result += KeywordHelper::WriteOptionallyQuoted(entry.first);
 			first_entry = false;
 		}
 		result += ")";

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

@@ -35,4 +35,8 @@ unique_ptr<AlterInfo> AddScalarFunctionOverloadInfo::Copy() const {
 	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
 }
 
+string AddScalarFunctionOverloadInfo::ToString() const {
+	throw NotImplementedException("NOT PARSABLE CURRENTLY");
+}
+
 } // namespace duckdb

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

@@ -35,4 +35,8 @@ unique_ptr<AlterInfo> AddTableFunctionOverloadInfo::Copy() const {
 	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
 }
 
+string AddTableFunctionOverloadInfo::ToString() const {
+	throw NotImplementedException("NOT PARSABLE");
+}
+
 } // namespace duckdb

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/common/extra_type_info.hpp"
 
 #include "duckdb/parser/constraint.hpp"
 
@@ -25,6 +26,21 @@ unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	                                                      owner_name, if_not_found);
 }
 
+string ChangeOwnershipInfo::ToString() const {
+	string result = "";
+
+	result += "ALTER ";
+	result += TypeToString(entry_catalog_type);
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " OWNED BY ";
+	result += QualifierToString(catalog, owner_schema, owner_name);
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // SetCommentInfo
 //===--------------------------------------------------------------------===//
@@ -44,6 +60,20 @@ unique_ptr<AlterInfo> SetCommentInfo::Copy() const {
 	                                                 if_not_found);
 }
 
+string SetCommentInfo::ToString() const {
+	string result = "";
+
+	result += "COMMENT ON ";
+	result += ParseInfo::TypeToString(entry_catalog_type);
+	result += " ";
+	result += QualifierToString(catalog, schema, name);
+	result += " IS ";
+	result += comment_value.ToSQLString();
+
+	result += ";";
+	return result;
+}
+
 SetCommentInfo::SetCommentInfo() : AlterInfo(AlterType::SET_COMMENT) {
 }
 
@@ -82,6 +112,21 @@ unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
 }
 
+string RenameColumnInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " RENAME COLUMN ";
+	result += KeywordHelper::WriteOptionallyQuoted(old_name);
+	result += " TO ";
+	result += KeywordHelper::WriteOptionallyQuoted(new_name);
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
@@ -99,6 +144,19 @@ unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
 }
 
+string RenameTableInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " RENAME TO ";
+	result += KeywordHelper::WriteOptionallyQuoted(new_table_name);
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
@@ -118,6 +176,22 @@ unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
 }
 
+string AddColumnInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " ADD COLUMN";
+	if (if_column_not_exists) {
+		result += " IF NOT EXISTS";
+	}
+	throw NotImplementedException("COLUMN SERIALIZATION");
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
@@ -135,6 +209,25 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists, cascade);
 }
 
+string RemoveColumnInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " DROP COLUMN ";
+	if (if_column_exists) {
+		result += "IF EXISTS ";
+	}
+	result += KeywordHelper::WriteOptionallyQuoted(removed_column);
+	if (cascade) {
+		result += " CASCADE";
+	}
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
@@ -154,6 +247,32 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
 	                                                       expression->Copy());
 }
 
+string ChangeColumnTypeInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " ALTER COLUMN ";
+	result += KeywordHelper::WriteOptionallyQuoted(column_name);
+	result += " TYPE ";
+	result += target_type.ToString(); // FIXME: ToSQLString ?
+	auto extra_type_info = target_type.AuxInfo();
+	if (extra_type_info && extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) {
+		auto &string_info = extra_type_info->Cast<StringTypeInfo>();
+		if (!string_info.collation.empty()) {
+			result += " COLLATE " + string_info.collation;
+		}
+	}
+	if (expression) {
+		result += " USING ";
+		result += expression->ToString();
+	}
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
@@ -172,6 +291,25 @@ unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
 	                                                 expression ? expression->Copy() : nullptr);
 }
 
+string SetDefaultInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " ALTER COLUMN ";
+	result += KeywordHelper::WriteOptionallyQuoted(column_name);
+	if (expression) {
+		result += " SET DEFAULT ";
+		result += expression->ToString();
+	} else {
+		result += " DROP DEFAULT";
+	}
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
@@ -188,6 +326,20 @@ unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
 	return make_uniq_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
+string SetNotNullInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " ALTER COLUMN ";
+	result += KeywordHelper::WriteOptionallyQuoted(column_name);
+	result += " SET NOT NULL";
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
@@ -204,6 +356,20 @@ unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
 	return make_uniq_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
+string DropNotNullInfo::ToString() const {
+	string result = "";
+	result += "ALTER TABLE ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " ALTER COLUMN ";
+	result += KeywordHelper::WriteOptionallyQuoted(column_name);
+	result += " DROP NOT NULL";
+	result += ";";
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
@@ -225,6 +391,10 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
 	                                                      pk_keys, fk_keys, type);
 }
 
+string AlterForeignKeyInfo::ToString() const {
+	throw NotImplementedException("NOT PARSABLE CURRENTLY");
+}
+
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
@@ -258,4 +428,17 @@ unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
 }
 
+string RenameViewInfo::ToString() const {
+	string result = "";
+	result += "ALTER VIEW ";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += QualifierToString(catalog, schema, name);
+	result += " RENAME TO ";
+	result += KeywordHelper::WriteOptionallyQuoted(new_view_name);
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
@@ -11,4 +12,26 @@ unique_ptr<AttachInfo> AttachInfo::Copy() const {
 	return result;
 }
 
+string AttachInfo::ToString() const {
+	string result = "";
+	result += "ATTACH";
+	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		result += " IF NOT EXISTS";
+	}
+	result += " DATABASE";
+	result += StringUtil::Format(" '%s'", path);
+	if (!name.empty()) {
+		result += " AS " + KeywordHelper::WriteOptionallyQuoted(name);
+	}
+	if (!options.empty()) {
+		vector<string> stringified;
+		for (auto &opt : options) {
+			stringified.push_back(StringUtil::Format("%s %s", opt.first, opt.second.ToSQLString()));
+		}
+		result += " (" + StringUtil::Join(stringified, ", ") + ")";
+	}
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

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

@@ -1,5 +1,6 @@
 #include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry_retriever.hpp"
 
 namespace duckdb {
 
@@ -21,8 +22,20 @@ unique_ptr<AlterInfo> SetColumnCommentInfo::Copy() const {
 	return std::move(result);
 }
 
-optional_ptr<CatalogEntry> SetColumnCommentInfo::TryResolveCatalogEntry(ClientContext &context) {
-	auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, catalog, schema, name, if_not_found);
+string SetColumnCommentInfo::ToString() const {
+	string result = "";
+
+	D_ASSERT(catalog_entry_type == CatalogType::INVALID);
+	result += "COMMENT ON COLUMN ";
+	result += QualifierToString(catalog, schema, name);
+	result += " IS ";
+	result += comment_value.ToSQLString();
+	result += ";";
+	return result;
+}
+
+optional_ptr<CatalogEntry> SetColumnCommentInfo::TryResolveCatalogEntry(CatalogEntryRetriever &retriever) {
+	auto entry = retriever.GetEntry(CatalogType::TABLE_ENTRY, catalog, schema, name, if_not_found);
 
 	if (entry) {
 		catalog_entry_type = entry->type;

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

@@ -0,0 +1,100 @@
+#include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/parser/query_node.hpp"
+
+namespace duckdb {
+
+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 = file_path;
+	result->is_from = is_from;
+	result->format = format;
+	result->options = options;
+	if (select_statement) {
+		result->select_statement = select_statement->Copy();
+	}
+	return result;
+}
+
+string CopyInfo::CopyOptionsToString(const string &format, const case_insensitive_map_t<vector<Value>> &options) {
+	if (format.empty() && options.empty()) {
+		return string();
+	}
+	string result;
+
+	result += " (";
+	vector<string> stringified;
+	if (!format.empty()) {
+		stringified.push_back(StringUtil::Format(" FORMAT %s", format));
+	}
+	for (auto &opt : options) {
+		auto &name = opt.first;
+		auto &values = opt.second;
+
+		auto option = name + " ";
+		if (values.empty()) {
+			// Options like HEADER don't need an explicit value
+			// just providing the name already sets it to true
+			stringified.push_back(option);
+		} else if (values.size() == 1) {
+			stringified.push_back(option + values[0].ToSQLString());
+		} else {
+			vector<string> sub_values;
+			for (auto &val : values) {
+				sub_values.push_back(val.ToSQLString());
+			}
+			stringified.push_back(option + "( " + StringUtil::Join(sub_values, ", ") + " )");
+		}
+	}
+	result += StringUtil::Join(stringified, ", ");
+	result += " )";
+	return result;
+}
+
+string CopyInfo::TablePartToString() const {
+	string result;
+
+	D_ASSERT(!table.empty());
+	result += QualifierToString(catalog, schema, table);
+
+	// (c1, c2, ..)
+	if (!select_list.empty()) {
+		vector<string> options;
+		for (auto &option : select_list) {
+			options.push_back(KeywordHelper::WriteOptionallyQuoted(option));
+		}
+		result += " (";
+		result += StringUtil::Join(options, ", ");
+		result += " )";
+	}
+	return result;
+}
+
+string CopyInfo::ToString() const {
+	string result = "";
+	result += "COPY ";
+	if (is_from) {
+		D_ASSERT(!select_statement);
+		result += TablePartToString();
+		result += " FROM";
+		result += StringUtil::Format(" %s", SQLString(file_path));
+		result += CopyOptionsToString(format, options);
+	} else {
+		if (select_statement) {
+			// COPY (select-node) TO ...
+			result += "(" + select_statement->ToString() + ")";
+		} else {
+			result += TablePartToString();
+		}
+		result += " TO ";
+		result += StringUtil::Format("%s", SQLString(file_path));
+		result += CopyOptionsToString(format, options);
+	}
+	result += ";";
+	return result;
+}
+
+} // namespace duckdb

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

@@ -41,7 +41,7 @@ string CreateIndexInfo::ToString() const {
 	}
 	result += KeywordHelper::WriteOptionallyQuoted(index_name);
 	result += " ON ";
-	result += KeywordHelper::WriteOptionallyQuoted(table);
+	result += QualifierToString(temporary ? "" : catalog, schema, table);
 	if (index_type != "ART") {
 		result += " USING ";
 		result += KeywordHelper::WriteOptionallyQuoted(index_type);
@@ -57,7 +57,20 @@ string CreateIndexInfo::ToString() const {
 		// column ref expressions are qualified with the table name
 		// we need to remove them to reproduce the original query
 		RemoveTableQualificationRecursive(copy, table);
-		result += copy->ToString();
+		bool add_parenthesis = true;
+		if (copy->type == ExpressionType::COLUMN_REF) {
+			auto &column_ref = copy->Cast<ColumnRefExpression>();
+			if (!column_ref.IsQualified()) {
+				// Only when column references are not qualified, i.e (col1, col2)
+				// then these expressions do not need to be wrapped in parenthesis
+				add_parenthesis = false;
+			}
+		}
+		if (add_parenthesis) {
+			result += StringUtil::Format("(%s)", copy->ToString());
+		} else {
+			result += StringUtil::Format("%s", copy->ToString());
+		}
 	}
 	result += ")";
 	if (!options.empty()) {
@@ -72,6 +85,7 @@ string CreateIndexInfo::ToString() const {
 		}
 		result += " )";
 	}
+	result += ";";
 	return result;
 }
 

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

@@ -19,7 +19,9 @@ void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.temporary = temporary;
 	other.internal = internal;
 	other.sql = sql;
+	other.dependencies = dependencies;
 	other.comment = comment;
+	other.tags = tags;
 }
 
 unique_ptr<AlterInfo> CreateInfo::GetAlterInfo() const {

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

@@ -0,0 +1,40 @@
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
+
+namespace duckdb {
+
+CreateSchemaInfo::CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+}
+
+unique_ptr<CreateInfo> CreateSchemaInfo::Copy() const {
+	auto result = make_uniq<CreateSchemaInfo>();
+	CopyProperties(*result);
+	return std::move(result);
+}
+
+string CreateSchemaInfo::ToString() const {
+	string ret = "";
+	string qualified = QualifierToString(temporary ? "" : catalog, "", schema);
+
+	switch (on_conflict) {
+	case OnCreateConflict::ALTER_ON_CONFLICT: {
+		ret += "CREATE SCHEMA " + qualified + " ON CONFLICT INSERT OR REPLACE;";
+		break;
+	}
+	case OnCreateConflict::IGNORE_ON_CONFLICT: {
+		ret += "CREATE SCHEMA " + qualified + " IF NOT EXISTS;";
+		break;
+	}
+	case OnCreateConflict::REPLACE_ON_CONFLICT: {
+		ret += "CREATE OR REPLACE SCHEMA " + qualified + ";";
+		break;
+	}
+	case OnCreateConflict::ERROR_ON_CONFLICT: {
+		ret += "CREATE SCHEMA " + qualified + ";";
+		break;
+	}
+	}
+	return ret;
+}
+
+} // namespace duckdb

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

@@ -24,4 +24,26 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 	return std::move(result);
 }
 
+string CreateSequenceInfo::ToString() const {
+	std::stringstream ss;
+	ss << "CREATE";
+	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
+		ss << " OR REPLACE";
+	}
+	if (temporary) {
+		ss << " TEMPORARY";
+	}
+	ss << " SEQUENCE ";
+	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		ss << " IF NOT EXISTS ";
+	}
+	ss << QualifierToString(temporary ? "" : catalog, schema, name);
+	ss << " INCREMENT BY " << increment;
+	ss << " MINVALUE " << min_value;
+	ss << " MAXVALUE " << max_value;
+	ss << " START " << start_value;
+	ss << " " << (cycle ? "CYCLE" : "NO CYCLE") << ";";
+	return ss.str();
+}
+
 } // namespace duckdb

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

@@ -32,12 +32,20 @@ unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 string CreateTableInfo::ToString() const {
 	string ret = "";
 
-	string table_name = KeywordHelper::WriteOptionallyQuoted(table);
-	if (schema != DEFAULT_SCHEMA) {
-		table_name = KeywordHelper::WriteOptionallyQuoted(schema) + "." + table_name;
+	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 ";
+	}
+	ret += QualifierToString(temporary ? "" : catalog, schema, table);
 
-	ret += "CREATE TABLE " + table_name;
 	if (query != nullptr) {
 		ret += " AS " + query->ToString();
 	} else {