duckdb 0.7.2-dev3666.0 → 0.7.2-dev3710.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev3666.0",
+  "version": "0.7.2-dev3710.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/json_functions/json_transform.cpp

@@ -659,7 +659,7 @@ static bool TransformObjectToMap(yyjson_val *objects[], yyjson_alc *alc, Vector
 	// Transform keys
 	if (!JSONTransform::Transform(keys, alc, MapVector::GetKeys(result), list_size, options)) {
 		throw ConversionException(
-		    StringUtil::Format(options.error_message, ". Cannot default to NULL, because map keys cannot be NULL"));
+		    StringUtil::Format(options.error_message + ". Cannot default to NULL, because map keys cannot be NULL"));
 	}
 
 	// Transform values

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -225,7 +225,7 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 	transform_options.error_unknown_key = bind_data->auto_detect && !bind_data->ignore_errors;
 	transform_options.delay_error = true;
 
-	return bind_data;
+	return std::move(bind_data);
 }
 
 static void ReadJSONFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

package/src/duckdb/extension/json/json_functions/read_json_objects.cpp

@@ -16,7 +16,7 @@ unique_ptr<FunctionData> ReadJSONObjectsBind(ClientContext &context, TableFuncti
 	bind_data->reader_bind =
 	    MultiFileReader::BindOptions(bind_data->options.file_options, bind_data->files, return_types, names);
 
-	return bind_data;
+	return std::move(bind_data);
 }
 
 static void ReadJSONObjectsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

package/src/duckdb/src/common/exception.cpp

@@ -59,6 +59,23 @@ string Exception::GetStackTrace(int max_depth) {
 }
 
 string Exception::ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values) {
+#ifdef DEBUG
+	// Verify that we have the required amount of values for the message
+	idx_t parameter_count = 0;
+	for (idx_t i = 0; i < msg.size(); i++) {
+		if (msg[i] != '%') {
+			continue;
+		}
+		if (i < msg.size() && msg[i + 1] == '%') {
+			i++;
+			continue;
+		}
+		parameter_count++;
+	}
+	if (parameter_count != values.size()) {
+		throw InternalException("Expected %d parameters, received %d", parameter_count, values.size());
+	}
+#endif
 	return ExceptionFormatValue::Format(msg, values);
 }
 

package/src/duckdb/src/common/exception_format_value.cpp

@@ -3,6 +3,7 @@
 #include "fmt/format.h"
 #include "fmt/printf.h"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
@@ -40,6 +41,19 @@ template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value) {
 	return ExceptionFormatValue(std::move(value));
 }
+
+template <>
+ExceptionFormatValue
+ExceptionFormatValue::CreateFormatValue(SQLString value) { // NOLINT: templating requires us to copy value here
+	return KeywordHelper::WriteQuoted(value.raw_string, '\'');
+}
+
+template <>
+ExceptionFormatValue
+ExceptionFormatValue::CreateFormatValue(SQLIdentifier value) { // NOLINT: templating requires us to copy value here
+	return KeywordHelper::WriteOptionallyQuoted(value.raw_string, '"');
+}
+
 template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value) {
 	return ExceptionFormatValue(string(value));

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

@@ -11,6 +11,7 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/extension_helper.hpp"
+#include "duckdb/common/windows_util.hpp"
 
 #include <cstdint>
 #include <cstdio>
@@ -53,6 +54,14 @@ bool PathMatched(const string &path, const string &sub_path) {
 
 #ifndef _WIN32
 
+string FileSystem::GetEnvVariable(const string &name) {
+	const char *env = getenv(name.c_str());
+	if (!env) {
+		return string();
+	}
+	return env;
+}
+
 bool FileSystem::IsPathAbsolute(const string &path) {
 	auto path_separator = FileSystem::PathSeparator();
 	return PathMatched(path, path_separator);
@@ -85,36 +94,59 @@ string FileSystem::GetWorkingDirectory() {
 	}
 	return string(buffer.get());
 }
+
+string FileSystem::NormalizeAbsolutePath(const string &path) {
+	D_ASSERT(IsPathAbsolute(path));
+	return path;
+}
+
 #else
 
-bool FileSystem::IsPathAbsolute(const string &path) {
-	// 1) A single backslash
-	auto sub_path = FileSystem::PathSeparator();
-	if (PathMatched(path, sub_path)) {
-		return true;
+string FileSystem::GetEnvVariable(const string &env) {
+	// first convert the environment variable name to the correct encoding
+	auto env_w = WindowsUtil::UTF8ToUnicode(env.c_str());
+	// use _wgetenv to get the value
+	auto res_w = _wgetenv(env_w.c_str());
+	if (!res_w) {
+		// no environment variable of this name found
+		return string();
 	}
-	// 2) check if starts with a double-backslash (i.e., \\)
-	sub_path += FileSystem::PathSeparator();
-	if (PathMatched(path, sub_path)) {
+	return WindowsUtil::UnicodeToUTF8(res_w);
+}
+
+bool FileSystem::IsPathAbsolute(const string &path) {
+	// 1) A single backslash or forward-slash
+	if (PathMatched(path, "\\") || PathMatched(path, "/")) {
 		return true;
 	}
-	// 3) A disk designator with a backslash (e.g., C:\)
+	// 2) A disk designator with a backslash (e.g., C:\ or C:/)
 	auto path_aux = path;
 	path_aux.erase(0, 1);
-	sub_path = ":" + FileSystem::PathSeparator();
-	if (PathMatched(path_aux, sub_path)) {
+	if (PathMatched(path_aux, ":\\") || PathMatched(path_aux, ":/")) {
 		return true;
 	}
 	return false;
 }
 
+string FileSystem::NormalizeAbsolutePath(const string &path) {
+	D_ASSERT(IsPathAbsolute(path));
+	auto result = StringUtil::Lower(FileSystem::ConvertSeparators(path));
+	if (PathMatched(result, "\\")) {
+		// Path starts with a single backslash or forward slash
+		// prepend drive letter
+		return GetWorkingDirectory().substr(0, 2) + result;
+	}
+	return result;
+}
+
 string FileSystem::PathSeparator() {
 	return "\\";
 }
 
 void FileSystem::SetWorkingDirectory(const string &path) {
-	if (!SetCurrentDirectory(path.c_str())) {
-		throw IOException("Could not change working directory!");
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
+	if (!SetCurrentDirectoryW(unicode_path.c_str())) {
+		throw IOException("Could not change working directory to \"%s\"", path);
 	}
 }
 
@@ -134,16 +166,16 @@ idx_t FileSystem::GetAvailableMemory() {
 }
 
 string FileSystem::GetWorkingDirectory() {
-	idx_t count = GetCurrentDirectory(0, nullptr);
+	idx_t count = GetCurrentDirectoryW(0, nullptr);
 	if (count == 0) {
 		throw IOException("Could not get working directory!");
 	}
-	auto buffer = make_unsafe_array<char>(count);
-	idx_t ret = GetCurrentDirectory(count, buffer.get());
+	auto buffer = make_unsafe_array<wchar_t>(count);
+	idx_t ret = GetCurrentDirectoryW(count, buffer.get());
 	if (count != ret + 1) {
 		throw IOException("Could not get working directory!");
 	}
-	return string(buffer.get(), ret);
+	return WindowsUtil::UnicodeToUTF8(buffer.get());
 }
 
 #endif
@@ -161,13 +193,7 @@ string FileSystem::ConvertSeparators(const string &path) {
 		return path;
 	}
 	// on windows-based systems we accept both
-	string result = path;
-	for (idx_t i = 0; i < result.size(); i++) {
-		if (result[i] == '/') {
-			result[i] = separator;
-		}
-	}
-	return result;
+	return StringUtil::Replace(path, "/", separator_str);
 }
 
 string FileSystem::ExtractName(const string &path) {
@@ -202,14 +228,10 @@ string FileSystem::GetHomeDirectory(optional_ptr<FileOpener> opener) {
 	}
 	// fallback to the default home directories for the specified system
 #ifdef DUCKDB_WINDOWS
-	const char *homedir = getenv("USERPROFILE");
+	return FileSystem::GetEnvVariable("USERPROFILE");
 #else
-	const char *homedir = getenv("HOME");
+	return FileSystem::GetEnvVariable("HOME");
 #endif
-	if (homedir) {
-		return homedir;
-	}
-	return string();
 }
 
 string FileSystem::GetHomeDirectory() {

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

@@ -162,8 +162,9 @@ static FileType GetFileTypeInternal(int fd) { // LCOV_EXCL_START
 	}
 } // LCOV_EXCL_STOP
 
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock_type,
+unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, uint8_t flags, FileLockType lock_type,
                                                  FileCompressionType compression, FileOpener *opener) {
+	auto path = FileSystem::ExpandPath(path_p, opener);
 	if (compression != FileCompressionType::UNCOMPRESSED) {
 		throw NotImplementedException("Unsupported compression type for default file system");
 	}
@@ -506,8 +507,9 @@ public:
 	};
 };
 
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock_type,
+unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, uint8_t flags, FileLockType lock_type,
                                                  FileCompressionType compression, FileOpener *opener) {
+	auto path = FileSystem::ExpandPath(path_p, opener);
 	if (compression != FileCompressionType::UNCOMPRESSED) {
 		throw NotImplementedException("Unsupported compression type for default file system");
 	}
@@ -775,7 +777,7 @@ void LocalFileSystem::MoveFile(const string &source, const string &target) {
 	auto source_unicode = WindowsUtil::UTF8ToUnicode(source.c_str());
 	auto target_unicode = WindowsUtil::UTF8ToUnicode(target.c_str());
 	if (!MoveFileW(source_unicode.c_str(), target_unicode.c_str())) {
-		throw IOException("Could not move file");
+		throw IOException("Could not move file: %s", GetLastErrorAsString());
 	}
 }
 

package/src/duckdb/src/common/types.cpp

@@ -349,7 +349,7 @@ string LogicalType::ToString() const {
 		auto &child_types = StructType::GetChildTypes(*this);
 		string ret = "STRUCT(";
 		for (size_t i = 0; i < child_types.size(); i++) {
-			ret += KeywordHelper::WriteOptionallyQuoted(child_types[i].first) + " " + child_types[i].second.ToString();
+			ret += StringUtil::Format("%s %s", SQLIdentifier(child_types[i].first), child_types[i].second);
 			if (i < child_types.size() - 1) {
 				ret += ", ";
 			}

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -77,7 +77,7 @@ static void AppendFilteredToResult(Vector &lambda_vector, list_entry_t *result_e
 		}
 
 		// found a true value
-		if (lambda_validity.RowIsValid(entry) && lambda_values[entry] > 0) {
+		if (lambda_validity.RowIsValid(entry) && lambda_values[entry]) {
 			true_sel.set_index(true_count++, i);
 			curr_list_len++;
 		}

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

@@ -51,8 +51,8 @@ static void WriteCopyStatement(FileSystem &fs, stringstream &ss, CopyInfo &info,
 		ss << KeywordHelper::WriteOptionallyQuoted(exported_table.schema_name) << ".";
 	}
 
-	ss << KeywordHelper::WriteOptionallyQuoted(exported_table.table_name) << " FROM '" << exported_table.file_path
-	   << "' (";
+	ss << StringUtil::Format("%s FROM %s (", SQLIdentifier(exported_table.table_name),
+	                         SQLString(exported_table.file_path));
 
 	// write the copy options
 	ss << "FORMAT '" << info.format << "'";

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

@@ -41,7 +41,7 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 	)
 	SELECT "name"
 	FROM db_objects
-	ORDER BY "name";)EOF", where_clause, where_clause, where_clause);
+	ORDER BY "name";)EOF", where_clause, where_clause);
 	// clang-format on
 
 	return pragma_query;

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

@@ -586,6 +586,9 @@ bool LineInfo::CanItGetLine(idx_t file_idx, idx_t batch_idx) {
 	if (current_batches.empty() || done) {
 		return true;
 	}
+	if (file_idx >= current_batches.size() || current_batches[file_idx].empty()) {
+		return true;
+	}
 	auto min_value = *current_batches[file_idx].begin();
 	if (min_value >= batch_idx) {
 		return true;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev3666"
+#define DUCKDB_VERSION "0.7.2-dev3710"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "eae707d54c"
+#define DUCKDB_SOURCE_ID "59a4ec3adc"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -15,6 +15,28 @@
 
 namespace duckdb {
 
+// Helper class to support custom overloading
+// Escaping " and quoting the value with "
+class SQLIdentifier {
+public:
+	SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
+// Helper class to support custom overloading
+// Escaping ' and quoting the value with '
+class SQLString {
+public:
+	SQLString(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
 enum class PhysicalType : uint8_t;
 struct LogicalType;
 
@@ -47,6 +69,10 @@ public:
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
 template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLString value);
+template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLIdentifier value);
+template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);

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

@@ -178,6 +178,9 @@ public:
 	DUCKDB_API static string PathSeparator();
 	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
 	DUCKDB_API static bool IsPathAbsolute(const string &path);
+	//! Normalize an absolute path - the goal of normalizing is converting "\test.db" and "C:/test.db" into "C:\test.db"
+	//! so that the database system cache can correctly
+	DUCKDB_API static string NormalizeAbsolutePath(const string &path);
 	//! Join two paths together
 	DUCKDB_API static string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
@@ -187,6 +190,9 @@ 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);
 
+	//! Returns the value of an environment variable - or the empty string if it is not set
+	DUCKDB_API static string GetEnvVariable(const string &name);
+
 	//! 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

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

@@ -15,6 +15,7 @@
 #include <cstring>
 
 namespace duckdb {
+
 /**
  * String Utility Functions
  * Note that these are not the most efficient implementations (i.e., they copy
@@ -85,6 +86,23 @@ public:
 		return false;
 	}
 
+	template <class TO>
+	static vector<TO> ConvertStrings(const vector<string> &strings) {
+		vector<TO> result;
+		for (auto &string : strings) {
+			result.emplace_back(string);
+		}
+		return result;
+	}
+
+	static vector<SQLIdentifier> ConvertToSQLIdentifiers(const vector<string> &strings) {
+		return ConvertStrings<SQLIdentifier>(strings);
+	}
+
+	static vector<SQLString> ConvertToSQLStrings(const vector<string> &strings) {
+		return ConvertStrings<SQLString>(strings);
+	}
+
 	//! Returns true if the needle string exists in the haystack
 	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
 

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -92,7 +92,7 @@ public:
 		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
 			return child->alias.empty() || !add_alias
 			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+			           : StringUtil::Format("%s := %s", SQLIdentifier(child->alias), child->ToString());
 		});
 		// ordered aggregate
 		if (order_bys && !order_bys->orders.empty()) {

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -96,8 +96,8 @@ public:
 			auto child_string = entry.children[1]->ToString();
 			D_ASSERT(child_string.size() >= 3);
 			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return "(" + entry.children[0]->ToString() + ")." +
-			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+			return StringUtil::Format("(%s).%s", entry.children[0]->ToString(),
+			                          SQLIdentifier(child_string.substr(1, child_string.size() - 2)));
 		}
 		case ExpressionType::ARRAY_CONSTRUCTOR: {
 			string result = "(ARRAY[";

package/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp

@@ -17,9 +17,14 @@ public:
 	//! Returns true if the given text matches a keyword of the parser
 	static bool IsKeyword(const string &text);
 
+	static string EscapeQuotes(const string &text, char quote = '"');
+
 	//! Returns true if the given string needs to be quoted when written as an identifier
 	static bool RequiresQuotes(const string &text, bool allow_caps = true);
 
+	//! Writes a string that is quoted
+	static string WriteQuoted(const string &text, char quote = '\'');
+
 	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
 	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
 };

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -1,8 +1,10 @@
 #include "duckdb/main/db_instance_cache.hpp"
 #include "duckdb/main/extension_helper.hpp"
+
 namespace duckdb {
 
-string GetDBAbsolutePath(const string &database) {
+string GetDBAbsolutePath(const string &database_p) {
+	auto database = FileSystem::ExpandPath(database_p, nullptr);
 	if (database.empty()) {
 		return ":memory:";
 	}
@@ -15,9 +17,9 @@ string GetDBAbsolutePath(const string &database) {
 		return database;
 	}
 	if (FileSystem::IsPathAbsolute(database)) {
-		return database;
+		return FileSystem::NormalizeAbsolutePath(database);
 	}
-	return FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database);
+	return FileSystem::NormalizeAbsolutePath(FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database));
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -133,6 +133,23 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install);
 }
 
+unsafe_array_ptr<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
+	auto source_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
+	file_size = source_file->GetFileSize();
+	auto in_buffer = make_unsafe_array<data_t>(file_size);
+	source_file->Read(in_buffer.get(), file_size);
+	source_file->Close();
+	return in_buffer;
+}
+
+void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, idx_t data_size) {
+	auto target_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_APPEND |
+	                                         FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
+	target_file->Write(data, data_size);
+	target_file->Close();
+	target_file.reset();
+}
+
 void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
                                                const string &local_path, const string &extension, bool force_install) {
 	if (!config.options.enable_external_access) {
@@ -152,18 +169,9 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	}
 	auto is_http_url = StringUtil::Contains(extension, "http://");
 	if (fs.FileExists(extension)) {
-
-		std::ifstream in(extension, std::ios::binary);
-		if (in.bad()) {
-			throw IOException("Failed to read extension from \"%s\"", extension);
-		}
-		std::ofstream out(temp_path, std::ios::binary);
-		out << in.rdbuf();
-		if (out.bad()) {
-			throw IOException("Failed to write extension to \"%s\"", temp_path);
-		}
-		in.close();
-		out.close();
+		idx_t file_size;
+		auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
+		WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
 
 		fs.MoveFile(temp_path, local_extension_path);
 		return;
@@ -225,12 +233,8 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		}
 	}
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
-	std::ofstream out(temp_path, std::ios::binary);
-	out.write(decompressed_body.data(), decompressed_body.size());
-	if (out.bad()) {
-		throw IOException("Failed to write extension to %s", temp_path);
-	}
-	out.close();
+
+	WriteExtensionFileToDisk(fs, temp_path, (void *)decompressed_body.data(), decompressed_body.size());
 	fs.MoveFile(temp_path, local_extension_path);
 #endif
 }

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

@@ -15,7 +15,7 @@ CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpres
 }
 
 string CollateExpression::ToString() const {
-	return child->ToString() + " COLLATE " + KeywordHelper::WriteOptionallyQuoted(collation);
+	return StringUtil::Format("%s COLLATE %s", child->ToString(), SQLIdentifier(collation));
 }
 
 bool CollateExpression::Equal(const CollateExpression *a, const CollateExpression *b) {

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

@@ -29,11 +29,21 @@ bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) {
 	return IsKeyword(text);
 }
 
+string KeywordHelper::EscapeQuotes(const string &text, char quote) {
+	return StringUtil::Replace(text, string(1, quote), string(2, quote));
+}
+
+string KeywordHelper::WriteQuoted(const string &text, char quote) {
+	// 1. Escapes all occurences of 'quote' by doubling them (escape in SQL)
+	// 2. Adds quotes around the string
+	return string(1, quote) + EscapeQuotes(text) + string(1, quote);
+}
+
 string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps) {
 	if (!RequiresQuotes(text, allow_caps)) {
 		return text;
 	}
-	return string(1, quote) + StringUtil::Replace(text, string(1, quote), string(2, quote)) + string(1, quote);
+	return WriteQuoted(text, quote);
 }
 
 } // namespace duckdb

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

@@ -39,7 +39,7 @@ string SelectNode::ToString() const {
 		}
 		result += select_list[i]->ToString();
 		if (!select_list[i]->alias.empty()) {
-			result += " AS " + KeywordHelper::WriteOptionallyQuoted(select_list[i]->alias);
+			result += StringUtil::Format(" AS %s", SQLIdentifier(select_list[i]->alias));
 		}
 	}
 	if (from_table && from_table->type != TableReferenceType::EMPTY) {

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

@@ -86,7 +86,7 @@ string CopyStatement::ToString() const {
 		D_ASSERT(!select_statement);
 		result += TablePart(*info);
 		result += " FROM";
-		result += StringUtil::Format(" '%s'", info->file_path);
+		result += StringUtil::Format(" %s", SQLString(info->file_path));
 		result += CopyOptionsToString(info->format, info->options);
 	} else {
 		if (select_statement) {
@@ -96,7 +96,7 @@ string CopyStatement::ToString() const {
 			result += TablePart(*info);
 		}
 		result += " TO ";
-		result += StringUtil::Format("'%s'", info->file_path);
+		result += StringUtil::Format("%s", SQLString(info->file_path));
 		result += CopyOptionsToString(info->format, info->options);
 	}
 	return result;

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

@@ -16,7 +16,7 @@ string TableRef::BaseToString(string result) const {
 
 string TableRef::BaseToString(string result, const vector<string> &column_name_alias) const {
 	if (!alias.empty()) {
-		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
+		result += StringUtil::Format(" AS %s", SQLIdentifier(alias));
 	}
 	if (!column_name_alias.empty()) {
 		D_ASSERT(!alias.empty());

package/src/duckdb/src/storage/storage_manager.cpp

@@ -19,6 +19,9 @@ StorageManager::StorageManager(AttachedDatabase &db, string path_p, bool read_on
     : db(db), path(std::move(path_p)), read_only(read_only) {
 	if (path.empty()) {
 		path = ":memory:";
+	} else {
+		auto &fs = FileSystem::Get(db);
+		this->path = fs.ExpandPath(path);
 	}
 }