duckdb 0.2.10-dev331.0 → 0.2.10-dev343.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.2.10-dev331.0",
+  "version": "0.2.10-dev343.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -20327,14 +20327,18 @@ extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG)
 namespace duckdb {
 
 static void AssertValidFileFlags(uint8_t flags) {
-	// cannot combine Read and Write flags
-	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_READ && flags & FileFlags::FILE_FLAGS_WRITE));
-	// cannot combine Read and CREATE/Append flags
-	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_READ && flags & FileFlags::FILE_FLAGS_APPEND));
-	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_READ && flags & FileFlags::FILE_FLAGS_FILE_CREATE));
-	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_READ && flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW));
+#ifdef DEBUG
+	bool is_read = flags & FileFlags::FILE_FLAGS_READ;
+	bool is_write = flags & FileFlags::FILE_FLAGS_WRITE;
+	// require either READ or WRITE (or both)
+	D_ASSERT(is_read || is_write);
+	// CREATE/Append flags require writing
+	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_APPEND));
+	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_FILE_CREATE));
+	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW));
 	// cannot combine CREATE and CREATE_NEW flags
 	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_FILE_CREATE && flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW));
+#endif
 }
 
 #ifndef _WIN32
@@ -20367,6 +20371,31 @@ public:
 	int fd;
 };
 
+static FileType GetFileTypeInternal(int fd) {
+	struct stat s;
+	if (fstat(fd, &s) == -1) {
+		return FileType::FILE_TYPE_INVALID;
+	}
+	switch (s.st_mode & S_IFMT) {
+	case S_IFBLK:
+		return FileType::FILE_TYPE_BLOCKDEV;
+	case S_IFCHR:
+		return FileType::FILE_TYPE_CHARDEV;
+	case S_IFIFO:
+		return FileType::FILE_TYPE_FIFO;
+	case S_IFDIR:
+		return FileType::FILE_TYPE_DIR;
+	case S_IFLNK:
+		return FileType::FILE_TYPE_LINK;
+	case S_IFREG:
+		return FileType::FILE_TYPE_REGULAR;
+	case S_IFSOCK:
+		return FileType::FILE_TYPE_SOCKET;
+	default:
+		return FileType::FILE_TYPE_INVALID;
+	}
+}
+
 unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock_type,
                                                  FileCompressionType compression, FileOpener *opener) {
 	if (compression != FileCompressionType::UNCOMPRESSED) {
@@ -20377,12 +20406,21 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 
 	int open_flags = 0;
 	int rc;
-	if (flags & FileFlags::FILE_FLAGS_READ) {
+	bool open_read = flags & FileFlags::FILE_FLAGS_READ;
+	bool open_write = flags & FileFlags::FILE_FLAGS_WRITE;
+	if (open_read && open_write) {
+		open_flags = O_RDWR;
+	} else if (open_read) {
 		open_flags = O_RDONLY;
+	} else if (open_write) {
+		open_flags = O_WRONLY;
 	} else {
+		throw InternalException("READ, WRITE or both should be specified when opening a file");
+	}
+	if (open_write) {
 		// need Read or Write
 		D_ASSERT(flags & FileFlags::FILE_FLAGS_WRITE);
-		open_flags = O_RDWR | O_CLOEXEC;
+		open_flags |= O_CLOEXEC;
 		if (flags & FileFlags::FILE_FLAGS_FILE_CREATE) {
 			open_flags |= O_CREAT;
 		} else if (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW) {
@@ -20418,15 +20456,19 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 	// #endif
 	if (lock_type != FileLockType::NO_LOCK) {
 		// set lock on file
-		struct flock fl;
-		memset(&fl, 0, sizeof fl);
-		fl.l_type = lock_type == FileLockType::READ_LOCK ? F_RDLCK : F_WRLCK;
-		fl.l_whence = SEEK_SET;
-		fl.l_start = 0;
-		fl.l_len = 0;
-		rc = fcntl(fd, F_SETLK, &fl);
-		if (rc == -1) {
-			throw IOException("Could not set lock on file \"%s\": %s", path, strerror(errno));
+		// but only if it is not an input/output stream
+		auto file_type = GetFileTypeInternal(fd);
+		if (file_type != FileType::FILE_TYPE_FIFO && file_type != FileType::FILE_TYPE_SOCKET) {
+			struct flock fl;
+			memset(&fl, 0, sizeof fl);
+			fl.l_type = lock_type == FileLockType::READ_LOCK ? F_RDLCK : F_WRLCK;
+			fl.l_whence = SEEK_SET;
+			fl.l_start = 0;
+			fl.l_len = 0;
+			rc = fcntl(fd, F_SETLK, &fl);
+			if (rc == -1) {
+				throw IOException("Could not set lock on file \"%s\": %s", path, strerror(errno));
+			}
 		}
 	}
 	return make_unique<UnixFileHandle>(*this, path, fd);
@@ -20512,28 +20554,7 @@ time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
 
 FileType LocalFileSystem::GetFileType(FileHandle &handle) {
 	int fd = ((UnixFileHandle &)handle).fd;
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		return FileType::FILE_TYPE_INVALID;
-	}
-	switch (s.st_mode & S_IFMT) {
-	case S_IFBLK:
-		return FileType::FILE_TYPE_BLOCKDEV;
-	case S_IFCHR:
-		return FileType::FILE_TYPE_CHARDEV;
-	case S_IFIFO:
-		return FileType::FILE_TYPE_FIFO;
-	case S_IFDIR:
-		return FileType::FILE_TYPE_DIR;
-	case S_IFLNK:
-		return FileType::FILE_TYPE_LINK;
-	case S_IFREG:
-		return FileType::FILE_TYPE_REGULAR;
-	case S_IFSOCK:
-		return FileType::FILE_TYPE_SOCKET;
-	default:
-		return FileType::FILE_TYPE_INVALID;
-	}
+	return GetFileTypeInternal(fd);
 }
 
 void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
@@ -20736,14 +20757,21 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 	DWORD share_mode;
 	DWORD creation_disposition = OPEN_EXISTING;
 	DWORD flags_and_attributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
-	if (flags & FileFlags::FILE_FLAGS_READ) {
+	bool open_read = flags & FileFlags::FILE_FLAGS_READ;
+	bool open_write = flags & FileFlags::FILE_FLAGS_WRITE;
+	if (open_read && open_write) {
+		desired_access = GENERIC_READ | GENERIC_WRITE;
+		share_mode = 0;
+	} else if (open_read) {
 		desired_access = GENERIC_READ;
 		share_mode = FILE_SHARE_READ;
-	} else {
-		// need Read or Write
-		D_ASSERT(flags & FileFlags::FILE_FLAGS_WRITE);
-		desired_access = GENERIC_READ | GENERIC_WRITE;
+	} else if (open_write) {
+		desired_access = GENERIC_WRITE;
 		share_mode = 0;
+	} else {
+		throw InternalException("READ, WRITE or both should be specified when opening a file");
+	}
+	if (open_write) {
 		if (flags & FileFlags::FILE_FLAGS_FILE_CREATE) {
 			creation_disposition = OPEN_ALWAYS;
 		} else if (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW) {
@@ -34540,6 +34568,7 @@ hash_t Hash(uint8_t *val, size_t size) {
 
 
 
+
 #include <cmath>
 #include <limits>
 
@@ -59863,7 +59892,7 @@ unique_ptr<FileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions
 static string GenerateColumnName(const idx_t total_cols, const idx_t col_number, const string &prefix = "column") {
 	int max_digits = NumericHelper::UnsignedLength(total_cols - 1);
 	int digits = NumericHelper::UnsignedLength(col_number);
-	string leading_zeros = string("0", max_digits - digits);
+	string leading_zeros = string(max_digits - digits, '0');
 	string value = to_string(col_number);
 	return string(prefix + leading_zeros + value);
 }
@@ -83966,6 +83995,7 @@ void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 #include <limits>
 #include <algorithm>
 
@@ -92159,6 +92189,7 @@ public:
 } // namespace duckdb
 
 
+
 #include <limits>
 
 namespace duckdb {
@@ -99873,13 +99904,47 @@ void QueryProfiler::ToStream(std::ostream &ss, bool print_optimizer_output) cons
 	}
 }
 
+static string JSONSanitize(const string &text) {
+	string result;
+	result.reserve(text.size());
+	for (idx_t i = 0; i < text.size(); i++) {
+		switch (text[i]) {
+		case '\b':
+			result += "\\b";
+			break;
+		case '\f':
+			result += "\\f";
+			break;
+		case '\n':
+			result += "\\n";
+			break;
+		case '\r':
+			result += "\\r";
+			break;
+		case '\t':
+			result += "\\t";
+			break;
+		case '"':
+			result += "\\\"";
+			break;
+		case '\\':
+			result += "\\\\";
+			break;
+		default:
+			result += text[i];
+			break;
+		}
+	}
+	return result;
+}
+
 // Print a row
 static void PrintRow(std::ostream &ss, const string &annotation, int id, const string &name, double time,
-                     int sample_counter, int tuple_counter, string extra_info, int depth) {
+                     int sample_counter, int tuple_counter, const string &extra_info, int depth) {
 	ss << string(depth * 3, ' ') << " {\n";
-	ss << string(depth * 3, ' ') << "   \"annotation\": \"" + annotation + "\",\n";
+	ss << string(depth * 3, ' ') << "   \"annotation\": \"" + JSONSanitize(annotation) + "\",\n";
 	ss << string(depth * 3, ' ') << "   \"id\": " + to_string(id) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"name\": \"" + name + "\",\n";
+	ss << string(depth * 3, ' ') << "   \"name\": \"" + JSONSanitize(name) + "\",\n";
 #if defined(RDTSC)
 	ss << string(depth * 3, ' ') << "   \"timing\": \"NULL\" ,\n";
 	ss << string(depth * 3, ' ') << "   \"cycles_per_tuple\": " + StringUtil::Format("%.4f", time) + ",\n";
@@ -99889,8 +99954,7 @@ static void PrintRow(std::ostream &ss, const string &annotation, int id, const s
 #endif
 	ss << string(depth * 3, ' ') << "   \"sample_size\": " << to_string(sample_counter) + ",\n";
 	ss << string(depth * 3, ' ') << "   \"input_size\": " << to_string(tuple_counter) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"extra_info\": \""
-	   << StringUtil::Replace(std::move(extra_info), "\n", "\\n") + "\"\n";
+	ss << string(depth * 3, ' ') << "   \"extra_info\": \"" << JSONSanitize(extra_info) + "\"\n";
 	ss << string(depth * 3, ' ') << " },\n";
 }
 
@@ -99912,11 +99976,10 @@ static void ExtractFunctions(std::ostream &ss, ExpressionInfo &info, int &fun_id
 
 static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int depth = 1) {
 	ss << string(depth * 3, ' ') << " {\n";
-	ss << string(depth * 3, ' ') << "   \"name\": \"" + node.name + "\",\n";
+	ss << string(depth * 3, ' ') << "   \"name\": \"" + JSONSanitize(node.name) + "\",\n";
 	ss << string(depth * 3, ' ') << "   \"timing\":" + to_string(node.info.time) + ",\n";
 	ss << string(depth * 3, ' ') << "   \"cardinality\":" + to_string(node.info.elements) + ",\n";
-	ss << string(depth * 3, ' ')
-	   << "   \"extra_info\": \"" + StringUtil::Replace(node.extra_info, "\n", "\\n") + "\",\n";
+	ss << string(depth * 3, ' ') << "   \"extra_info\": \"" + JSONSanitize(node.extra_info) + "\",\n";
 	ss << string(depth * 3, ' ') << "   \"timings\": [";
 	int32_t function_counter = 1;
 	int32_t expression_counter = 1;
@@ -99970,8 +100033,7 @@ string QueryProfiler::ToJSON() const {
 	ss << "   \"timing\": " + to_string(main_query.Elapsed()) + ",\n";
 	ss << "   \"cardinality\": " + to_string(root->info.elements) + ",\n";
 	// JSON cannot have literal control characters in string literals
-	string extra_info = StringUtil::Replace(query, "\t", "\\t");
-	extra_info = StringUtil::Replace(extra_info, "\n", "\\n");
+	string extra_info = JSONSanitize(query);
 	ss << "   \"extra-info\": \"" + extra_info + "\", \n";
 	// print the phase timings
 	ss << "   \"timings\": [\n";
@@ -146502,7 +146564,7 @@ SingleFileBlockManager::SingleFileBlockManager(DatabaseInstance &db, string path
 		flags = FileFlags::FILE_FLAGS_READ;
 		lock = FileLockType::READ_LOCK;
 	} else {
-		flags = FileFlags::FILE_FLAGS_WRITE;
+		flags = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_READ;
 		lock = FileLockType::WRITE_LOCK;
 		if (create_new) {
 			flags |= FileFlags::FILE_FLAGS_FILE_CREATE;

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "7dd852e1d"
-#define DUCKDB_VERSION "0.2.10-dev331"
+#define DUCKDB_SOURCE_ID "f327c62f7"
+#define DUCKDB_VERSION "0.2.10-dev343"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //