duckdb 0.3.2-dev1046.0 → 0.3.2-dev1095.0

package/package.json

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

package/src/duckdb.cpp

@@ -13124,6 +13124,9 @@ extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG)
 
 namespace duckdb {
 
+FileSystem::~FileSystem() {
+}
+
 FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
 	return *context.db->config.file_system;
 }
@@ -13347,6 +13350,12 @@ bool FileSystem::OnDiskFile(FileHandle &handle) {
 }
 // LCOV_EXCL_STOP
 
+FileHandle::FileHandle(FileSystem &file_system, string path_p) : file_system(file_system), path(move(path_p)) {
+}
+
+FileHandle::~FileHandle() {
+}
+
 int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
 	return file_system.Read(*this, buffer, nr_bytes);
 }
@@ -78550,7 +78559,8 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 					break;
 				case 'c':
 				case 'x':
-				case 'X': {
+				case 'X':
+				case 'T': {
 					string subformat;
 					if (format_char == 'c') {
 						// %c: Locale’s appropriate date and time representation.
@@ -78560,7 +78570,7 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 						// %x - Locale’s appropriate date representation.
 						// we push the ISO date format here
 						subformat = "%Y-%m-%d";
-					} else if (format_char == 'X') {
+					} else if (format_char == 'X' || format_char == 'T') {
 						// %X - Locale’s appropriate time representation.
 						// we push the ISO time format here
 						subformat = "%H:%M:%S";
@@ -79035,7 +79045,18 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 				result_data[4] -= minute_offset;
 				break;
 			}
-
+			case StrTimeSpecifier::TZ_NAME: {
+				// skip leading spaces
+				while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
+					pos++;
+				}
+				// stop when we encounter a space or the end of the string
+				while (pos < size && !StringUtil::CharacterIsSpace(data[pos])) {
+					pos++;
+				}
+				// FIXME: actually use the timestamp...
+				break;
+			}
 			default:
 				throw NotImplementedException("Unsupported specifier for strptime");
 			}
@@ -79134,6 +79155,20 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 	return make_unique<StrpTimeBindData>(format);
 }
 
+StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
+	StrpTimeFormat format;
+	format.format_specifier = format_string;
+	string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+	if (!error.empty()) {
+		throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+	}
+	StrpTimeFormat::ParseResult result;
+	if (!format.Parse(text, result)) {
+		throw InvalidInputException("Failed to parse string \"%s\" with format specifier \"%s\"", text, format_string);
+	}
+	return result;
+}
+
 string StrpTimeFormat::FormatStrpTimeError(const string &input, idx_t position) {
 	if (position == DConstants::INVALID_INDEX) {
 		return string();

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "59838eae3"
-#define DUCKDB_VERSION "0.3.2-dev1046"
+#define DUCKDB_SOURCE_ID "b8f633b51"
+#define DUCKDB_VERSION "0.3.2-dev1095"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1812,30 +1812,28 @@ enum class FileType {
 
 struct FileHandle {
 public:
-	FileHandle(FileSystem &file_system, string path) : file_system(file_system), path(path) {
-	}
+	DUCKDB_API FileHandle(FileSystem &file_system, string path);
 	FileHandle(const FileHandle &) = delete;
-	virtual ~FileHandle() {
-	}
+	DUCKDB_API virtual ~FileHandle();
 
-	int64_t Read(void *buffer, idx_t nr_bytes);
-	int64_t Write(void *buffer, idx_t nr_bytes);
-	void Read(void *buffer, idx_t nr_bytes, idx_t location);
-	void Write(void *buffer, idx_t nr_bytes, idx_t location);
-	void Seek(idx_t location);
-	void Reset();
-	idx_t SeekPosition();
-	void Sync();
-	void Truncate(int64_t new_size);
-	string ReadLine();
+	DUCKDB_API int64_t Read(void *buffer, idx_t nr_bytes);
+	DUCKDB_API int64_t Write(void *buffer, idx_t nr_bytes);
+	DUCKDB_API void Read(void *buffer, idx_t nr_bytes, idx_t location);
+	DUCKDB_API void Write(void *buffer, idx_t nr_bytes, idx_t location);
+	DUCKDB_API void Seek(idx_t location);
+	DUCKDB_API void Reset();
+	DUCKDB_API idx_t SeekPosition();
+	DUCKDB_API void Sync();
+	DUCKDB_API void Truncate(int64_t new_size);
+	DUCKDB_API string ReadLine();
 
-	bool CanSeek();
-	bool OnDiskFile();
-	idx_t GetFileSize();
-	FileType GetType();
+	DUCKDB_API bool CanSeek();
+	DUCKDB_API bool OnDiskFile();
+	DUCKDB_API idx_t GetFileSize();
+	DUCKDB_API FileType GetType();
 
 	//! Closes the file handle.
-	virtual void Close() = 0;
+	DUCKDB_API virtual void Close() = 0;
 
 public:
 	FileSystem &file_system;
@@ -1862,107 +1860,107 @@ public:
 
 class FileSystem {
 public:
-	virtual ~FileSystem() {
-	}
+	DUCKDB_API virtual ~FileSystem();
 
 public:
-	static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
-	static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
-	static FileSystem &GetFileSystem(ClientContext &context);
-	static FileSystem &GetFileSystem(DatabaseInstance &db);
-	static FileOpener *GetFileOpener(ClientContext &context);
+	DUCKDB_API static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
+	DUCKDB_API static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
+	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
+	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
+	DUCKDB_API static FileOpener *GetFileOpener(ClientContext &context);
 
-	virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = DEFAULT_LOCK,
-	                                        FileCompressionType compression = DEFAULT_COMPRESSION,
-	                                        FileOpener *opener = nullptr);
+	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,
+	                                                   FileLockType lock = DEFAULT_LOCK,
+	                                                   FileCompressionType compression = DEFAULT_COMPRESSION,
+	                                                   FileOpener *opener = nullptr);
 
 	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
 	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
+	DUCKDB_API virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
 	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be read. This is
 	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
+	DUCKDB_API virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
 	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
 	//! amount of bytes read.
-	virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
+	DUCKDB_API virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
 	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
+	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
 
 	//! Returns the file size of a file handle, returns -1 on error
-	virtual int64_t GetFileSize(FileHandle &handle);
+	DUCKDB_API virtual int64_t GetFileSize(FileHandle &handle);
 	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	virtual time_t GetLastModifiedTime(FileHandle &handle);
+	DUCKDB_API virtual time_t GetLastModifiedTime(FileHandle &handle);
 	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	virtual FileType GetFileType(FileHandle &handle);
+	DUCKDB_API virtual FileType GetFileType(FileHandle &handle);
 	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
 	//! the file
-	virtual void Truncate(FileHandle &handle, int64_t new_size);
+	DUCKDB_API virtual void Truncate(FileHandle &handle, int64_t new_size);
 
 	//! Check if a directory exists
-	virtual bool DirectoryExists(const string &directory);
+	DUCKDB_API virtual bool DirectoryExists(const string &directory);
 	//! Create a directory if it does not exist
-	virtual void CreateDirectory(const string &directory);
+	DUCKDB_API virtual void CreateDirectory(const string &directory);
 	//! Recursively remove a directory and all files in it
-	virtual void RemoveDirectory(const string &directory);
+	DUCKDB_API virtual void RemoveDirectory(const string &directory);
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	virtual bool ListFiles(const string &directory, const std::function<void(string, bool)> &callback);
+	DUCKDB_API virtual bool ListFiles(const string &directory, const std::function<void(string, bool)> &callback);
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
-	virtual void MoveFile(const string &source, const string &target);
+	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
 	//! Check if a file exists
-	virtual bool FileExists(const string &filename);
+	DUCKDB_API virtual bool FileExists(const string &filename);
 	//! Remove a file from disk
-	virtual void RemoveFile(const string &filename);
+	DUCKDB_API virtual void RemoveFile(const string &filename);
 	//! Sync a file handle to disk
-	virtual void FileSync(FileHandle &handle);
+	DUCKDB_API virtual void FileSync(FileHandle &handle);
 
 	//! Sets the working directory
-	static void SetWorkingDirectory(const string &path);
+	DUCKDB_API static void SetWorkingDirectory(const string &path);
 	//! Gets the working directory
-	static string GetWorkingDirectory();
+	DUCKDB_API static string GetWorkingDirectory();
 	//! Gets the users home directory
-	static string GetHomeDirectory();
+	DUCKDB_API static string GetHomeDirectory();
 	//! Returns the system-available memory in bytes
-	static idx_t GetAvailableMemory();
+	DUCKDB_API static idx_t GetAvailableMemory();
 	//! Path separator for the current file system
-	static string PathSeparator();
+	DUCKDB_API static string PathSeparator();
 	//! Join two paths together
-	static string JoinPath(const string &a, const string &path);
+	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)
-	static string ConvertSeparators(const string &path);
+	DUCKDB_API static string ConvertSeparators(const string &path);
 	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is example)
-	static string ExtractBaseName(const string &path);
+	DUCKDB_API static string ExtractBaseName(const string &path);
 
 	//! Runs a glob on the file system, returning a list of matching files
-	virtual vector<string> Glob(const string &path);
+	DUCKDB_API virtual vector<string> Glob(const string &path);
 
 	//! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc.
-	virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
-	virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
+	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
+	DUCKDB_API virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
 
 	//! Whether or not a sub-system can handle a specific file path
-	virtual bool CanHandleFile(const string &fpath);
+	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
 
 	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	virtual void Seek(FileHandle &handle, idx_t location);
+	DUCKDB_API virtual void Seek(FileHandle &handle, idx_t location);
 	//! Reset a file to the beginning (equivalent to Seek(handle, 0) for simple files)
-	virtual void Reset(FileHandle &handle);
-	virtual idx_t SeekPosition(FileHandle &handle);
+	DUCKDB_API virtual void Reset(FileHandle &handle);
+	DUCKDB_API virtual idx_t SeekPosition(FileHandle &handle);
 
 	//! Whether or not we can seek into the file
-	virtual bool CanSeek();
+	DUCKDB_API virtual bool CanSeek();
 	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
 	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	virtual bool OnDiskFile(FileHandle &handle);
+	DUCKDB_API virtual bool OnDiskFile(FileHandle &handle);
 
-	virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
+	DUCKDB_API virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
 
 	//! Create a LocalFileSystem.
-	static unique_ptr<FileSystem> CreateLocal();
+	DUCKDB_API static unique_ptr<FileSystem> CreateLocal();
 
 protected:
 	//! Return the name of the filesytem. Used for forming diagnosis messages.
-	virtual std::string GetName() const = 0;
+	DUCKDB_API virtual std::string GetName() const = 0;
 };
 
 } // namespace duckdb
@@ -11506,17 +11504,17 @@ public:
 	DBConfig config;
 
 public:
-	StorageManager &GetStorageManager();
-	Catalog &GetCatalog();
-	FileSystem &GetFileSystem();
-	TransactionManager &GetTransactionManager();
-	TaskScheduler &GetScheduler();
-	ObjectCache &GetObjectCache();
-	ConnectionManager &GetConnectionManager();
+	DUCKDB_API StorageManager &GetStorageManager();
+	DUCKDB_API Catalog &GetCatalog();
+	DUCKDB_API FileSystem &GetFileSystem();
+	DUCKDB_API TransactionManager &GetTransactionManager();
+	DUCKDB_API TaskScheduler &GetScheduler();
+	DUCKDB_API ObjectCache &GetObjectCache();
+	DUCKDB_API ConnectionManager &GetConnectionManager();
 
 	idx_t NumberOfThreads();
 
-	static DatabaseInstance &GetDatabase(ClientContext &context);
+	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
 
 private:
 	void Initialize(const char *path, DBConfig *config);
@@ -20513,7 +20511,7 @@ struct StrfTimeFormat : public StrTimeFormat {
 	void FormatString(date_t date, int32_t data[7], char *target);
 	void FormatString(date_t date, dtime_t time, char *target);
 
-	static string Format(timestamp_t timestamp, const string &format);
+	DUCKDB_API static string Format(timestamp_t timestamp, const string &format);
 
 protected:
 	//! The variable-length specifiers. To determine total string size, these need to be checked.
@@ -20547,9 +20545,14 @@ public:
 		timestamp_t ToTimestamp();
 		string FormatError(string_t input, const string &format_specifier);
 	};
+
+public:
 	//! The full format specifier, for error messages
 	string format_specifier;
 
+public:
+	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
+
 	bool Parse(string_t str, ParseResult &result);
 
 	bool TryParseDate(string_t str, date_t &result, string &error_message);