duckdb 0.5.2-dev671.0 → 0.5.2-dev678.0

package/package.json

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

package/src/duckdb.cpp

@@ -29017,7 +29017,7 @@ struct RowOperations {
 namespace duckdb {
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&...args) {
+RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&... args) {
 	D_ASSERT(radix_bits <= sizeof(hash_t) * 8);
 	switch (radix_bits) {
 	case 1:
@@ -29046,7 +29046,7 @@ RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&...args) {
 }
 
 template <class OP, class RETURN_TYPE, idx_t radix_bits_1, typename... ARGS>
-RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&...args) {
+RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&... args) {
 	D_ASSERT(radix_bits_2 <= sizeof(hash_t) * 8);
 	switch (radix_bits_2) {
 	case 1:
@@ -29075,7 +29075,7 @@ RETURN_TYPE DoubleRadixBitsSwitch2(idx_t radix_bits_2, ARGS &&...args) {
 }
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE DoubleRadixBitsSwitch1(idx_t radix_bits_1, idx_t radix_bits_2, ARGS &&...args) {
+RETURN_TYPE DoubleRadixBitsSwitch1(idx_t radix_bits_1, idx_t radix_bits_2, ARGS &&... args) {
 	D_ASSERT(radix_bits_1 <= sizeof(hash_t) * 8);
 	switch (radix_bits_1) {
 	case 1:
@@ -35158,7 +35158,8 @@ namespace duckdb {
 
 class BufferedFileReader : public Deserializer {
 public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileOpener *opener = nullptr);
+	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
+	                   FileOpener *opener = nullptr);
 
 	FileSystem &fs;
 	unique_ptr<data_t[]> data;
@@ -35175,6 +35176,9 @@ public:
 		return file_size;
 	}
 
+	void Seek(uint64_t location);
+	uint64_t CurrentOffset();
+
 private:
 	idx_t file_size;
 	idx_t total_read;
@@ -35190,10 +35194,9 @@ private:
 
 namespace duckdb {
 
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileOpener *opener)
+BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type, FileOpener *opener)
     : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0) {
-	handle =
-	    fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, FileLockType::READ_LOCK, FileSystem::DEFAULT_COMPRESSION, opener);
+	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener);
 	file_size = fs.GetFileSize(*handle);
 }
 
@@ -35227,6 +35230,17 @@ bool BufferedFileReader::Finished() {
 	return total_read + offset == file_size;
 }
 
+void BufferedFileReader::Seek(uint64_t location) {
+	D_ASSERT(location <= file_size);
+	handle->Seek(location);
+	total_read = location;
+	read_data = offset = 0;
+}
+
+uint64_t BufferedFileReader::CurrentOffset() {
+	return total_read + offset;
+}
+
 } // namespace duckdb
 
 
@@ -35244,7 +35258,7 @@ BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, uin
 }
 
 int64_t BufferedFileWriter::GetFileSize() {
-	return fs.GetFileSize(*handle);
+	return fs.GetFileSize(*handle) + offset;
 }
 
 idx_t BufferedFileWriter::GetTotalWritten() {
@@ -35281,10 +35295,17 @@ void BufferedFileWriter::Sync() {
 }
 
 void BufferedFileWriter::Truncate(int64_t size) {
-	// truncate the physical file on disk
-	handle->Truncate(size);
-	// reset anything written in the buffer
-	offset = 0;
+	uint64_t persistent = fs.GetFileSize(*handle);
+	D_ASSERT((uint64_t)size <= persistent + offset);
+	if (persistent <= (uint64_t)size) {
+		// truncating into the pending write buffer.
+		offset = size - persistent;
+	} else {
+		// truncate the physical file on disk
+		handle->Truncate(size);
+		// reset anything written in the buffer
+		offset = 0;
+	}
 }
 
 } // namespace duckdb
@@ -139886,8 +139907,12 @@ inline std::string GetDLError(void) {
 namespace duckdb_mbedtls {
 class MbedTlsWrapper {
 public:
+	static void ComputeSha256Hash(const char* in, size_t in_len, char* out);
 	static std::string ComputeSha256Hash(const std::string& file_content);
 	static bool IsValidSha256Signature(const std::string& pubkey, const std::string& signature, const std::string& sha256_hash);
+	static void Hmac256(const char* key, size_t key_len, const char* message, size_t message_len, char* out);
+
+	static constexpr size_t SHA256_HASH_BYTES = 32;
 };
 }
 
@@ -328632,16 +328657,20 @@ openssl pkeyutl -sign -in hash -inkey private.pem -pkeyopt digest:sha256 -out du
 */
 
 
-string MbedTlsWrapper::ComputeSha256Hash(const string& file_content) {
-	string hash;
-	hash.resize(32);
+void MbedTlsWrapper::ComputeSha256Hash(const char* in, size_t in_len, char* out) {
 
 	mbedtls_sha256_context sha_context;
 	mbedtls_sha256_init(&sha_context);
-	if(mbedtls_sha256_starts(&sha_context, false) || mbedtls_sha256_update(&sha_context, (const unsigned char*) file_content.data(), file_content.size()) || mbedtls_sha256_finish(&sha_context, (unsigned char*)hash.data())) {
+	if(mbedtls_sha256_starts(&sha_context, false) || mbedtls_sha256_update(&sha_context, (const unsigned char*) in, in_len) || mbedtls_sha256_finish(&sha_context, (unsigned char*)out)) {
 		throw runtime_error("SHA256 Error");
 	}
 	mbedtls_sha256_free(&sha_context);
+}
+
+string MbedTlsWrapper::ComputeSha256Hash(const string& file_content) {
+	string hash;
+	hash.resize(MbedTlsWrapper::SHA256_HASH_BYTES);
+	ComputeSha256Hash(file_content.data(), file_content.size(), (char*)hash.data());
 	return hash;
 }
 
@@ -328668,6 +328697,22 @@ bool MbedTlsWrapper::IsValidSha256Signature(const std::string &pubkey, const std
 	return valid;
 }
 
+// used in s3fs
+void MbedTlsWrapper::Hmac256(const char* key, size_t key_len, const char* message, size_t message_len, char* out) {
+	mbedtls_md_context_t hmac_ctx;
+	const mbedtls_md_info_t *md_type = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
+	if (!md_type) {
+		throw runtime_error("failed to init hmac");
+	}
+
+	if (mbedtls_md_setup(&hmac_ctx, md_type, 1) ||
+	    mbedtls_md_hmac_starts(&hmac_ctx, (const unsigned char *) key, key_len) ||
+	    mbedtls_md_hmac_update(&hmac_ctx, (const unsigned char *)message, message_len) ||
+	    mbedtls_md_hmac_finish(&hmac_ctx, (unsigned char *) out)) {
+		throw runtime_error("HMAC256 Error");
+	}
+	mbedtls_md_free(&hmac_ctx);
+}
 
 // LICENSE_CHANGE_END
 

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 "91a9fc49a"
-#define DUCKDB_VERSION "v0.5.2-dev671"
+#define DUCKDB_SOURCE_ID "23b94dd87"
+#define DUCKDB_VERSION "v0.5.2-dev678"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1875,7 +1875,7 @@ public:
 	}
 
 	template <class T, typename... ARGS>
-	void ReadList(vector<unique_ptr<T>> &list, ARGS &&...args) {
+	void ReadList(vector<unique_ptr<T>> &list, ARGS &&... args) {
 		auto select_count = Read<uint32_t>();
 		for (uint32_t i = 0; i < select_count; i++) {
 			auto child = T::Deserialize(*this, std::forward<ARGS>(args)...);
@@ -1884,7 +1884,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = T, typename... ARGS>
-	unique_ptr<RETURN_TYPE> ReadOptional(ARGS &&...args) {
+	unique_ptr<RETURN_TYPE> ReadOptional(ARGS &&... args) {
 		auto has_entry = Read<bool>();
 		if (has_entry) {
 			return T::Deserialize(*this, std::forward<ARGS>(args)...);
@@ -2087,6 +2087,10 @@ public:
 	//! Closes the file handle.
 	DUCKDB_API virtual void Close() = 0;
 
+	string GetPath() const {
+		return path;
+	}
+
 public:
 	FileSystem &file_system;
 	string path;
@@ -13773,7 +13777,7 @@ public:
 	}
 
 	template <class T, typename... ARGS>
-	unique_ptr<T> ReadOptional(unique_ptr<T> default_value, ARGS &&...args) {
+	unique_ptr<T> ReadOptional(unique_ptr<T> default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -13795,7 +13799,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -13817,7 +13821,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read mandatory field, but field is missing");
@@ -13828,7 +13832,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	vector<RETURN_TYPE> ReadRequiredSerializableList(ARGS &&...args) {
+	vector<RETURN_TYPE> ReadRequiredSerializableList(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read mandatory field, but field is missing");