duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -2,13 +2,15 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/extra_type_info.hpp"
 
 namespace duckdb {
 
-CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY), bind_modifiers(nullptr) {
 }
-CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p)
-    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)) {
+CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p, bind_type_modifiers_function_t bind_modifiers_p)
+    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)),
+      bind_modifiers(bind_modifiers_p) {
 }
 
 unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
@@ -19,25 +21,46 @@ unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
 	if (query) {
 		result->query = query->Copy();
 	}
+	result->bind_modifiers = bind_modifiers;
 	return std::move(result);
 }
 
 string CreateTypeInfo::ToString() const {
 	string result = "";
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto &values_insert_order = EnumType::GetValuesInsertOrder(type);
-	idx_t size = EnumType::GetSize(type);
-	result += "CREATE TYPE ";
-	result += KeywordHelper::WriteOptionallyQuoted(name);
-	result += " AS ENUM ( ";
+	result += "CREATE";
+	if (temporary) {
+		// These are created by PIVOT
+		throw NotImplementedException("CREATE TEMPORARY TYPE can't be parsed currently");
+	}
+	result += " TYPE ";
+	result += QualifierToString(temporary ? "" : catalog, schema, name);
+	if (type.id() == LogicalTypeId::ENUM) {
+		auto &values_insert_order = EnumType::GetValuesInsertOrder(type);
+		idx_t size = EnumType::GetSize(type);
 
-	for (idx_t i = 0; i < size; i++) {
-		result += "'" + values_insert_order.GetValue(i).ToString() + "'";
-		if (i != size - 1) {
-			result += ", ";
+		result += " AS ENUM ( ";
+		for (idx_t i = 0; i < size; i++) {
+			result += "'" + values_insert_order.GetValue(i).ToString() + "'";
+			if (i != size - 1) {
+				result += ", ";
+			}
 		}
+		result += " );";
+	} else if (type.id() == LogicalTypeId::INVALID) {
+		// CREATE TYPE mood AS ENUM (SELECT 'happy')
+		D_ASSERT(query);
+		result += " AS ENUM (" + query->ToString() + ")";
+	} else if (type.id() == LogicalTypeId::USER) {
+		result += " AS ";
+		auto extra_info = type.AuxInfo();
+		D_ASSERT(extra_info);
+		D_ASSERT(extra_info->type == ExtraTypeInfoType::USER_TYPE_INFO);
+		auto &user_info = extra_info->Cast<UserTypeInfo>();
+		result += QualifierToString(user_info.catalog, user_info.schema, user_info.user_type_name);
+	} else {
+		result += " AS ";
+		result += type.ToString();
 	}
-	result += " );";
 	return result;
 }
 

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

@@ -30,11 +30,10 @@ string CreateViewInfo::ToString() const {
 		result += " TEMPORARY";
 	}
 	result += " VIEW ";
-	if (schema != DEFAULT_SCHEMA) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema);
-		result += ".";
+	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		result += " IF NOT EXISTS ";
 	}
-	result += KeywordHelper::WriteOptionallyQuoted(view_name);
+	result += QualifierToString(temporary ? "" : catalog, schema, view_name);
 	if (!aliases.empty()) {
 		result += " (";
 		result += StringUtil::Join(aliases, aliases.size(), ", ",
@@ -43,6 +42,7 @@ string CreateViewInfo::ToString() const {
 	}
 	result += " AS ";
 	result += query->ToString();
+	result += ";";
 	return result;
 }
 

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/parsed_data/detach_info.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
@@ -12,4 +13,15 @@ unique_ptr<DetachInfo> DetachInfo::Copy() const {
 	return result;
 }
 
+string DetachInfo::ToString() const {
+	string result = "";
+	result += "DETACH DATABASE";
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+		result += " IF EXISTS";
+	}
+	result += " " + KeywordHelper::WriteOptionallyQuoted(name);
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

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

@@ -16,4 +16,25 @@ unique_ptr<DropInfo> DropInfo::Copy() const {
 	return make_uniq<DropInfo>(*this);
 }
 
+string DropInfo::ToString() const {
+	string result = "";
+	if (type == CatalogType::PREPARED_STATEMENT) {
+		result += "DEALLOCATE PREPARE ";
+		result += KeywordHelper::WriteOptionallyQuoted(name);
+	} else {
+		result += "DROP";
+		result += " " + ParseInfo::TypeToString(type);
+		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+			result += " IF EXISTS";
+		}
+		result += " ";
+		result += QualifierToString(catalog, schema, name);
+		if (cascade) {
+			result += " CASCADE";
+		}
+	}
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,46 @@
+#include "duckdb/parser/parsed_data/load_info.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
+
+namespace duckdb {
+
+unique_ptr<LoadInfo> LoadInfo::Copy() const {
+	auto result = make_uniq<LoadInfo>();
+	result->filename = filename;
+	result->repository = repository;
+	result->load_type = load_type;
+	result->repo_is_alias = repo_is_alias;
+	return result;
+}
+
+static string LoadInfoToString(LoadType load_type) {
+	switch (load_type) {
+	case LoadType::LOAD:
+		return "LOAD";
+	case LoadType::INSTALL:
+		return "INSTALL";
+	case LoadType::FORCE_INSTALL:
+		return "FORCE INSTALL";
+	default:
+		throw InternalException("ToString for LoadType with type: %s not implemented", EnumUtil::ToString(load_type));
+	}
+}
+
+string LoadInfo::ToString() const {
+	string result = "";
+	result += LoadInfoToString(load_type);
+	result += StringUtil::Format(" '%s'", filename);
+	if (!repository.empty()) {
+		if (repo_is_alias) {
+			result += " FROM " + KeywordHelper::WriteOptionallyQuoted(repository);
+		} else {
+			result += " FROM " + KeywordHelper::WriteQuoted(repository);
+		}
+	}
+
+	result += ";";
+	return result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,50 @@
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
+
+namespace duckdb {
+
+string ParseInfo::TypeToString(CatalogType type) {
+	switch (type) {
+	case CatalogType::TABLE_ENTRY:
+		return "TABLE";
+	case CatalogType::SCALAR_FUNCTION_ENTRY:
+		return "FUNCTION";
+	case CatalogType::INDEX_ENTRY:
+		return "INDEX";
+	case CatalogType::SCHEMA_ENTRY:
+		return "SCHEMA";
+	case CatalogType::TYPE_ENTRY:
+		return "TYPE";
+	case CatalogType::VIEW_ENTRY:
+		return "VIEW";
+	case CatalogType::SEQUENCE_ENTRY:
+		return "SEQUENCE";
+	case CatalogType::MACRO_ENTRY:
+		return "MACRO";
+	case CatalogType::TABLE_MACRO_ENTRY:
+		return "MACRO TABLE";
+	case CatalogType::SECRET_ENTRY:
+		return "SECRET";
+	default:
+		throw InternalException("ParseInfo::TypeToString for CatalogType with type: %s not implemented",
+		                        EnumUtil::ToString(type));
+	}
+}
+
+string ParseInfo::QualifierToString(const string &catalog, const string &schema, const string &name) {
+	string result;
+	if (!catalog.empty()) {
+		result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
+		if (!schema.empty()) {
+			result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
+		}
+	} else if (!schema.empty() && schema != DEFAULT_SCHEMA) {
+		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
+	}
+	result += KeywordHelper::WriteOptionallyQuoted(name);
+	return result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,33 @@
+#include "duckdb/parser/parsed_data/pragma_info.hpp"
+
+namespace duckdb {
+
+unique_ptr<PragmaInfo> PragmaInfo::Copy() const {
+	auto result = make_uniq<PragmaInfo>();
+	result->name = name;
+	for (auto &param : parameters) {
+		result->parameters.push_back(param->Copy());
+	}
+	for (auto &entry : named_parameters) {
+		result->named_parameters.insert(make_pair(entry.first, entry.second->Copy()));
+	}
+	return result;
+}
+
+string PragmaInfo::ToString() const {
+	string result = "";
+	result += "PRAGMA";
+	// FIXME: Can pragma's live in different catalog/schemas ?
+	result += " " + KeywordHelper::WriteOptionallyQuoted(name);
+	if (!parameters.empty()) {
+		vector<string> stringified;
+		for (auto &param : parameters) {
+			stringified.push_back(param->ToString());
+		}
+		result += "(" + StringUtil::Join(stringified, ", ") + ")";
+	}
+	result += ";";
+	return result;
+}
+
+} // namespace duckdb

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -8,4 +9,25 @@ TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
 TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) {
 }
 
+string TransactionInfo::ToString() const {
+	string result = "";
+	switch (type) {
+	case TransactionType::BEGIN_TRANSACTION:
+		result += "BEGIN";
+		break;
+	case TransactionType::COMMIT:
+		result += "COMMIT";
+		break;
+	case TransactionType::ROLLBACK:
+		result += "ROLLBACK";
+		break;
+	default: {
+		throw InternalException("ToString for TransactionStatement with type: %s not implemented",
+		                        EnumUtil::ToString(type));
+	}
+	}
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

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

@@ -15,4 +15,24 @@ unique_ptr<VacuumInfo> VacuumInfo::Copy() {
 	return result;
 }
 
+string VacuumInfo::ToString() const {
+	string result = "";
+	result += "VACUUM";
+	if (options.analyze) {
+		result += " ANALYZE";
+	}
+	if (ref) {
+		result += " " + ref->ToString();
+		if (!columns.empty()) {
+			vector<string> names;
+			for (auto &column : columns) {
+				names.push_back(KeywordHelper::WriteOptionallyQuoted(column));
+			}
+			result += "(" + StringUtil::Join(names, ", ") + ")";
+		}
+	}
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -242,6 +242,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 	case TableReferenceType::BASE_TABLE:
 	case TableReferenceType::EMPTY_FROM:
 	case TableReferenceType::SHOW_REF:
+	case TableReferenceType::COLUMN_DATA:
 		// these TableRefs do not need to be unfolded
 		break;
 	case TableReferenceType::INVALID:

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

@@ -181,7 +181,7 @@ void Parser::ParseQuery(const string &query) {
 			} else {
 				parser_error = parser.error_message;
 				if (parser.error_location > 0) {
-					parser_error_location = parser.error_location - 1;
+					parser_error_location = NumericCast<idx_t>(parser.error_location - 1);
 				}
 			}
 		}
@@ -196,7 +196,7 @@ void Parser::ParseQuery(const string &query) {
 		} else {
 			// split sql string into statements and re-parse using extension
 			auto query_statements = SplitQueryStringIntoStatements(query);
-			auto stmt_loc = 0;
+			idx_t stmt_loc = 0;
 			for (auto const &query_statement : query_statements) {
 				ErrorData another_parser_error;
 				// Creating a new scope to allow extensions to use PostgresParser, which is not reentrant
@@ -219,7 +219,8 @@ void Parser::ParseQuery(const string &query) {
 					} else {
 						another_parser_error = ErrorData(another_parser.error_message);
 						if (another_parser.error_location > 0) {
-							another_parser_error.AddQueryLocation(another_parser.error_location - 1);
+							another_parser_error.AddQueryLocation(
+							    NumericCast<idx_t>(another_parser.error_location - 1));
 						}
 					}
 				} // LCOV_EXCL_STOP
@@ -292,7 +293,7 @@ vector<SimplifiedToken> Parser::Tokenize(const string &query) {
 		default:
 			throw InternalException("Unrecognized token category");
 		} // LCOV_EXCL_STOP
-		token.start = pg_token.start;
+		token.start = NumericCast<idx_t>(pg_token.start);
 		result.push_back(token);
 	}
 	return result;

package/src/duckdb/src/parser/query_node.cpp

@@ -24,6 +24,7 @@ CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
 		kv_info->materialized = kv.second->materialized;
 		res.map[kv.first] = std::move(kv_info);
 	}
+
 	return res;
 }
 
@@ -44,6 +45,7 @@ string CommonTableExpressionMap::ToString() const {
 		result += "RECURSIVE ";
 	}
 	bool first_cte = true;
+
 	for (auto &kv : map) {
 		if (!first_cte) {
 			result += ", ";
@@ -131,15 +133,17 @@ bool QueryNode::Equals(const QueryNode *other) const {
 	if (cte_map.map.size() != other->cte_map.map.size()) {
 		return false;
 	}
+
 	for (auto &entry : cte_map.map) {
 		auto other_entry = other->cte_map.map.find(entry.first);
 		if (other_entry == other->cte_map.map.end()) {
 			return false;
 		}
-		if (entry.second->aliases != other_entry->second->aliases) {
+
+		if (entry.second->aliases != other->cte_map.map.at(entry.first)->aliases) {
 			return false;
 		}
-		if (!entry.second->query->Equals(*other_entry->second->query)) {
+		if (!entry.second->query->Equals(*other->cte_map.map.at(entry.first)->query)) {
 			return false;
 		}
 	}

package/src/duckdb/src/parser/statement/alter_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> AlterStatement::Copy() const {
 	return unique_ptr<AlterStatement>(new AlterStatement(*this));
 }
 
+string AlterStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/attach_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> AttachStatement::Copy() const {
 	return unique_ptr<AttachStatement>(new AttachStatement(*this));
 }
 
+string AttachStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/call_statement.cpp

@@ -12,4 +12,12 @@ unique_ptr<SQLStatement> CallStatement::Copy() const {
 	return unique_ptr<CallStatement>(new CallStatement(*this));
 }
 
+string CallStatement::ToString() const {
+	string result = "";
+	result += "CALL";
+	result += " " + function->ToString();
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/copy_statement.cpp

@@ -6,100 +6,10 @@ CopyStatement::CopyStatement() : SQLStatement(StatementType::COPY_STATEMENT), in
 }
 
 CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-	if (other.select_statement) {
-		select_statement = other.select_statement->Copy();
-	}
-}
-
-string CopyStatement::CopyOptionsToString(const string &format,
-                                          const case_insensitive_map_t<vector<Value>> &options) const {
-	if (format.empty() && options.empty()) {
-		return string();
-	}
-	string result;
-
-	result += " (";
-	if (!format.empty()) {
-		result += " FORMAT ";
-		result += format;
-	}
-	for (auto it = options.begin(); it != options.end(); it++) {
-		if (!format.empty() || it != options.begin()) {
-			result += ", ";
-		}
-		auto &name = it->first;
-		auto &values = it->second;
-
-		result += name + " ";
-		if (values.empty()) {
-			// Options like HEADER don't need an explicit value
-			// just providing the name already sets it to true
-		} else if (values.size() == 1) {
-			result += values[0].ToSQLString();
-		} else {
-			result += "( ";
-			for (idx_t i = 0; i < values.size(); i++) {
-				if (i) {
-					result += ", ";
-				}
-				result += values[i].ToSQLString();
-			}
-			result += " )";
-		}
-	}
-	result += " )";
-	return result;
-}
-
-// COPY table-name (c1, c2, ..)
-string TablePart(const CopyInfo &info) {
-	string result;
-
-	if (!info.catalog.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(info.catalog) + ".";
-	}
-	if (!info.schema.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(info.schema) + ".";
-	}
-	D_ASSERT(!info.table.empty());
-	result += KeywordHelper::WriteOptionallyQuoted(info.table);
-
-	// (c1, c2, ..)
-	if (!info.select_list.empty()) {
-		result += " (";
-		for (idx_t i = 0; i < info.select_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(info.select_list[i]);
-		}
-		result += " )";
-	}
-	return result;
 }
 
 string CopyStatement::ToString() const {
-	string result;
-
-	result += "COPY ";
-	if (info->is_from) {
-		D_ASSERT(!select_statement);
-		result += TablePart(*info);
-		result += " FROM";
-		result += StringUtil::Format(" %s", SQLString(info->file_path));
-		result += CopyOptionsToString(info->format, info->options);
-	} else {
-		if (select_statement) {
-			// COPY (select-node) TO ...
-			result += "(" + select_statement->ToString() + ")";
-		} else {
-			result += TablePart(*info);
-		}
-		result += " TO ";
-		result += StringUtil::Format("%s", SQLString(info->file_path));
-		result += CopyOptionsToString(info->format, info->options);
-	}
-	return result;
+	return info->ToString();
 }
 
 unique_ptr<SQLStatement> CopyStatement::Copy() const {

package/src/duckdb/src/parser/statement/detach_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> DetachStatement::Copy() const {
 	return unique_ptr<DetachStatement>(new DetachStatement(*this));
 }
 
+string DetachStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/drop_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> DropStatement::Copy() const {
 	return unique_ptr<DropStatement>(new DropStatement(*this));
 }
 
+string DropStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/execute_statement.cpp

@@ -15,4 +15,19 @@ unique_ptr<SQLStatement> ExecuteStatement::Copy() const {
 	return unique_ptr<ExecuteStatement>(new ExecuteStatement(*this));
 }
 
+string ExecuteStatement::ToString() const {
+	string result = "";
+	result += "EXECUTE";
+	result += " " + name;
+	if (!named_values.empty()) {
+		vector<string> stringified;
+		for (auto &val : named_values) {
+			stringified.push_back(StringUtil::Format("\"%s\" := %s", val.first, val.second->ToString()));
+		}
+		result += "(" + StringUtil::Join(stringified, ", ") + ")";
+	}
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/explain_statement.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/parser/statement/explain_statement.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -14,4 +15,22 @@ unique_ptr<SQLStatement> ExplainStatement::Copy() const {
 	return unique_ptr<ExplainStatement>(new ExplainStatement(*this));
 }
 
+static string ExplainTypeToString(ExplainType type) {
+	switch (type) {
+	case ExplainType::EXPLAIN_STANDARD:
+		return "EXPLAIN";
+	case ExplainType::EXPLAIN_ANALYZE:
+		return "EXPLAIN ANALYZE";
+	default:
+		throw InternalException("ToString for ExplainType with type: %s not implemented", EnumUtil::ToString(type));
+	}
+}
+
+string ExplainStatement::ToString() const {
+	string result = "";
+	result += ExplainTypeToString(explain_type);
+	result += " " + stmt->ToString();
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/export_statement.cpp

@@ -1,4 +1,6 @@
 #include "duckdb/parser/statement/export_statement.hpp"
+#include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
@@ -14,4 +16,20 @@ unique_ptr<SQLStatement> ExportStatement::Copy() const {
 	return unique_ptr<ExportStatement>(new ExportStatement(*this));
 }
 
+string ExportStatement::ToString() const {
+	string result = "";
+	result += "EXPORT DATABASE";
+	if (!database.empty()) {
+		result += " " + database + " TO";
+	}
+	auto &path = info->file_path;
+	D_ASSERT(info->is_from == false);
+	auto &options = info->options;
+	auto &format = info->format;
+	result += StringUtil::Format(" '%s'", path);
+	result += CopyInfo::CopyOptionsToString(format, options);
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/extension_statement.cpp

@@ -11,4 +11,8 @@ unique_ptr<SQLStatement> ExtensionStatement::Copy() const {
 	return make_uniq<ExtensionStatement>(extension, parse_data->Copy());
 }
 
+string ExtensionStatement::ToString() const {
+	return parse_data->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/load_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> LoadStatement::Copy() const {
 	return unique_ptr<LoadStatement>(new LoadStatement(*this));
 }
 
+string LoadStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb