duckdb 0.7.2-dev1671.0 → 0.7.2-dev1734.0

package/src/duckdb/src/function/table/system/duckdb_extensions.cpp

@@ -75,7 +75,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		installed_extensions[info.name] = std::move(info);
 	}
-
+#ifndef WASM_LOADABLE_EXTENSIONS
 	// scan the install directory for installed extensions
 	auto ext_directory = ExtensionHelper::ExtensionDirectory(context);
 	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
@@ -96,7 +96,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 			entry->second.installed = true;
 		}
 	});
-
+#endif
 	// now check the list of currently loaded extensions
 	auto &loaded_extensions = db.LoadedExtensions();
 	for (auto &ext_name : loaded_extensions) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1671"
+#define DUCKDB_VERSION "0.7.2-dev1734"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "846a32b4c8"
+#define DUCKDB_SOURCE_ID "e8610c85fb"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp

@@ -0,0 +1,247 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/partition_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/sort/sort.hpp"
+#include "duckdb/common/types/partitioned_column_data.hpp"
+#include "duckdb/common/radix_partitioning.hpp"
+#include "duckdb/parallel/base_pipeline_event.hpp"
+
+namespace duckdb {
+
+class PartitionGlobalHashGroup {
+public:
+	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
+	using LocalSortStatePtr = unique_ptr<LocalSortState>;
+	using Orders = vector<BoundOrderByNode>;
+	using Types = vector<LogicalType>;
+
+	PartitionGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
+	                         const Types &payload_types, bool external);
+
+	void ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask);
+
+	GlobalSortStatePtr global_sort;
+	atomic<idx_t> count;
+
+	// Mask computation
+	SortLayout partition_layout;
+};
+
+class PartitionGlobalSinkState {
+public:
+	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
+	using Orders = vector<BoundOrderByNode>;
+	using Types = vector<LogicalType>;
+
+	using GroupingPartition = unique_ptr<PartitionedColumnData>;
+	using GroupingAppend = unique_ptr<PartitionedColumnDataAppendState>;
+
+	PartitionGlobalSinkState(ClientContext &context, const vector<unique_ptr<Expression>> &partitions_p,
+	                         const vector<BoundOrderByNode> &orders_p, const Types &payload_types,
+	                         const vector<unique_ptr<BaseStatistics>> &partitions_stats, idx_t estimated_cardinality);
+
+	void UpdateLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+	void CombineLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+
+	void BuildSortState(ColumnDataCollection &group_data, PartitionGlobalHashGroup &global_sort);
+
+	ClientContext &context;
+	BufferManager &buffer_manager;
+	Allocator &allocator;
+	mutex lock;
+
+	// OVER(PARTITION BY...) (hash grouping)
+	unique_ptr<RadixPartitionedColumnData> grouping_data;
+	//! Payload plus hash column
+	Types grouping_types;
+
+	// OVER(...) (sorting)
+	Orders partitions;
+	Orders orders;
+	const Types payload_types;
+	vector<HashGroupPtr> hash_groups;
+	bool external;
+
+	// OVER() (no sorting)
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> strings;
+
+	// Threading
+	idx_t memory_per_thread;
+	atomic<idx_t> count;
+
+private:
+	void ResizeGroupingData(idx_t cardinality);
+	void SyncLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append);
+};
+
+class PartitionLocalSinkState {
+public:
+	PartitionLocalSinkState(ClientContext &context, PartitionGlobalSinkState &gstate_p);
+
+	// Global state
+	PartitionGlobalSinkState &gstate;
+	Allocator &allocator;
+
+	// OVER(PARTITION BY...) (hash grouping)
+	ExpressionExecutor executor;
+	DataChunk group_chunk;
+	DataChunk payload_chunk;
+	unique_ptr<PartitionedColumnData> local_partition;
+	unique_ptr<PartitionedColumnDataAppendState> local_append;
+
+	// OVER(...) (sorting)
+	size_t sort_cols;
+
+	// OVER() (no sorting)
+	RowLayout payload_layout;
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> strings;
+
+	//! Compute the hash values
+	void Hash(DataChunk &input_chunk, Vector &hash_vector);
+	//! Sink an input chunk
+	void Sink(DataChunk &input_chunk);
+	//! Merge the state into the global state.
+	void Combine();
+};
+
+enum class PartitionSortStage : uint8_t { INIT, PREPARE, MERGE, SORTED };
+
+class PartitionLocalMergeState;
+
+class PartitionGlobalMergeState {
+public:
+	using GroupDataPtr = unique_ptr<ColumnDataCollection>;
+
+	explicit PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data);
+
+	bool IsSorted() const {
+		lock_guard<mutex> guard(lock);
+		return stage == PartitionSortStage::SORTED;
+	}
+
+	bool AssignTask(PartitionLocalMergeState &local_state);
+	bool TryPrepareNextStage();
+	void CompleteTask();
+
+	PartitionGlobalSinkState &sink;
+	GroupDataPtr group_data;
+	PartitionGlobalHashGroup *hash_group;
+	GlobalSortState *global_sort;
+
+private:
+	mutable mutex lock;
+	PartitionSortStage stage;
+	idx_t total_tasks;
+	idx_t tasks_assigned;
+	idx_t tasks_completed;
+};
+
+class PartitionLocalMergeState {
+public:
+	PartitionLocalMergeState() : merge_state(nullptr), stage(PartitionSortStage::INIT) {
+		finished = true;
+	}
+
+	bool TaskFinished() {
+		return finished;
+	}
+
+	void Prepare();
+	void Merge();
+
+	void ExecuteTask();
+
+	PartitionGlobalMergeState *merge_state;
+	PartitionSortStage stage;
+	atomic<bool> finished;
+};
+
+class PartitionGlobalMergeStates {
+public:
+	using PartitionGlobalMergeStatePtr = unique_ptr<PartitionGlobalMergeState>;
+
+	explicit PartitionGlobalMergeStates(PartitionGlobalSinkState &sink);
+
+	vector<PartitionGlobalMergeStatePtr> states;
+};
+
+class PartitionMergeEvent : public BasePipelineEvent {
+public:
+	PartitionMergeEvent(PartitionGlobalSinkState &gstate_p, Pipeline &pipeline_p)
+	    : BasePipelineEvent(pipeline_p), gstate(gstate_p), merge_states(gstate_p) {
+	}
+
+	PartitionGlobalSinkState &gstate;
+	PartitionGlobalMergeStates merge_states;
+
+public:
+	void Schedule() override;
+};
+
+class PartitionGlobalSourceState {
+public:
+	explicit PartitionGlobalSourceState(PartitionGlobalSinkState &gsink_p) : gsink(gsink_p), next_bin(0) {
+	}
+
+	PartitionGlobalSinkState &gsink;
+	//! The output read position.
+	atomic<idx_t> next_bin;
+
+public:
+	idx_t MaxThreads() {
+		// If there is only one partition, we have to process it on one thread.
+		if (!gsink.grouping_data) {
+			return 1;
+		}
+
+		// If there is not a lot of data, process serially.
+		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
+			return 1;
+		}
+
+		return gsink.hash_groups.size();
+	}
+};
+
+// Per-thread read state
+class PartitionLocalSourceState {
+public:
+	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
+
+	explicit PartitionLocalSourceState(PartitionGlobalSinkState &gstate_p);
+
+	void MaterializeSortedData();
+	idx_t GeneratePartition(const idx_t hash_bin);
+
+	PartitionGlobalSinkState &gstate;
+
+	//! The read partition
+	idx_t hash_bin;
+	HashGroupPtr hash_group;
+
+	//! The generated input chunks
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> heap;
+	RowLayout layout;
+	//! The partition boundary mask
+	vector<validity_t> partition_bits;
+	ValidityMask partition_mask;
+	//! The order boundary mask
+	vector<validity_t> order_bits;
+	ValidityMask order_mask;
+	//! The read cursor
+	unique_ptr<RowDataCollectionScanner> scanner;
+	//! Buffer for the inputs
+	DataChunk input_chunk;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -29,7 +29,6 @@ struct ExpressionState {
 	vector<unique_ptr<ExpressionState>> child_states;
 	vector<LogicalType> types;
 	DataChunk intermediate_chunk;
-	string name;
 	CycleCounter profiler;
 
 public:
@@ -55,12 +54,11 @@ public:
 };
 
 struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
+	ExpressionExecutorState();
 
 	unique_ptr<ExpressionState> root_state;
 	ExpressionExecutor *executor = nullptr;
 	CycleCounter profiler;
-	string name;
 
 	void Verify();
 };

package/src/duckdb/src/include/duckdb/planner/pragma_handler.hpp

@@ -29,8 +29,9 @@ private:
 	ClientContext &context;
 
 private:
-	//! Handles a pragma statement, (potentially) returning a new statement to replace the current one
-	string HandlePragma(SQLStatement *statement);
+	//! Handles a pragma statement, returns whether the statement was expanded, if it was expanded the 'resulting_query'
+	//! contains the statement(s) to replace the current one
+	bool HandlePragma(SQLStatement *statement, string &resulting_query);
 
 	void HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements);
 };

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -12,14 +12,13 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/file_buffer.hpp"
 
 namespace duckdb {
 class BlockManager;
 class BufferHandle;
-class BufferManager;
 class BufferPool;
 class DatabaseInstance;
-class FileBuffer;
 
 enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
 

package/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/file_buffer.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+
+namespace duckdb {
+
+struct EvictionQueue;
+
+struct BufferEvictionNode {
+	BufferEvictionNode() {
+	}
+	BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t timestamp_p)
+	    : handle(std::move(handle_p)), timestamp(timestamp_p) {
+		D_ASSERT(!handle.expired());
+	}
+
+	weak_ptr<BlockHandle> handle;
+	idx_t timestamp;
+
+	bool CanUnload(BlockHandle &handle_p);
+
+	shared_ptr<BlockHandle> TryGetBlockHandle();
+};
+
+//! The BufferPool is in charge of handling memory management for one or more databases. It defines memory limits
+//! and implements priority eviction among all users of the pool.
+class BufferPool {
+	friend class BlockHandle;
+	friend class BlockManager;
+	friend class BufferManager;
+
+public:
+	explicit BufferPool(idx_t maximum_memory);
+	virtual ~BufferPool();
+
+	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	void SetLimit(idx_t limit, const char *exception_postscript);
+
+	idx_t GetUsedMemory();
+
+	idx_t GetMaxMemory();
+
+protected:
+	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
+	//! (i.e. not enough blocks could be evicted)
+	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
+	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
+	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
+	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
+	struct EvictionResult {
+		bool success;
+		TempBufferPoolReservation reservation;
+	};
+	virtual EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit,
+	                                   unique_ptr<FileBuffer> *buffer = nullptr);
+
+	//! Garbage collect eviction queue
+	void PurgeQueue();
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
+
+private:
+	//! The lock for changing the memory limit
+	mutex limit_lock;
+	//! The current amount of memory that is occupied by the buffer manager (in bytes)
+	atomic<idx_t> current_memory;
+	//! The maximum amount of memory that the buffer manager can keep (in bytes)
+	atomic<idx_t> maximum_memory;
+	//! Eviction queue
+	unique_ptr<EvictionQueue> queue;
+	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
+	atomic<uint32_t> queue_insertions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/temporary_file_information.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+struct TemporaryFileInformation {
+	string path;
+	idx_t size;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp

@@ -16,6 +16,8 @@
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
+#include "duckdb/storage/buffer/temporary_file_information.hpp"
 
 namespace duckdb {
 class BlockManager;
@@ -23,65 +25,7 @@ class DatabaseInstance;
 class TemporaryDirectoryHandle;
 struct EvictionQueue;
 
-//! The BufferPool is in charge of handling memory management for one or more databases. It defines memory limits
-//! and implements priority eviction among all users of the pool.
-class BufferPool {
-	friend class BlockHandle;
-	friend class BlockManager;
-	friend class BufferManager;
-
-public:
-	explicit BufferPool(idx_t maximum_memory);
-	virtual ~BufferPool();
-
-	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit, const char *exception_postscript);
-
-	idx_t GetUsedMemory() {
-		return current_memory;
-	}
-	idx_t GetMaxMemory() {
-		return maximum_memory;
-	}
-
-protected:
-	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
-	//! (i.e. not enough blocks could be evicted)
-	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
-	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
-	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
-	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
-	struct EvictionResult {
-		bool success;
-		TempBufferPoolReservation reservation;
-	};
-	virtual EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit,
-	                                   unique_ptr<FileBuffer> *buffer = nullptr);
-
-	//! Garbage collect eviction queue
-	void PurgeQueue();
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-
-private:
-	//! The lock for changing the memory limit
-	mutex limit_lock;
-	//! The current amount of memory that is occupied by the buffer manager (in bytes)
-	atomic<idx_t> current_memory;
-	//! The maximum amount of memory that the buffer manager can keep (in bytes)
-	atomic<idx_t> maximum_memory;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
-	//! Total number of insertions into the eviction queue. This guides the schedule for calling PurgeQueue.
-	atomic<uint32_t> queue_insertions;
-};
-
-struct TemporaryFileInformation {
-	string path;
-	idx_t size;
-};
-
-//! The BufferManager is in charge of handling memory management for a singke database. It cooperatively shares a
+//! The BufferManager is in charge of handling memory management for a single database. It cooperatively shares a
 //! BufferPool with other BufferManagers, belonging to different databases. It hands out memory buffers that can
 //! be used by the database internally, and offers configuration options specific to a database, which need not be
 //! shared by the BufferPool, including whether to support swapping temp buffers to disk, and where to swap them to.

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

@@ -39,6 +39,9 @@ const vector<string> ExtensionHelper::PathComponents() {
 }
 
 string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs, FileOpener *opener) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	static_assertion(0, "ExtensionDirectory functionality is not supported in duckdb-wasm");
+#endif
 	string extension_directory;
 	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
 		extension_directory = config.options.extension_directory;
@@ -111,11 +114,19 @@ bool ExtensionHelper::CreateSuggestions(const string &extension_name, string &me
 }
 
 void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	// Install is currently a no-op
+	return;
+#endif
 	string local_path = ExtensionDirectory(config, fs, nullptr);
 	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install);
 }
 
 void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install) {
+#ifdef WASM_LOADABLE_EXTENSIONS
+	// Install is currently a no-op
+	return;
+#endif
 	auto &config = DBConfig::GetConfig(context);
 	auto &fs = FileSystem::GetFileSystem(context);
 	string local_path = ExtensionDirectory(context);

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

@@ -4,6 +4,10 @@
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
 
+#ifdef WASM_LOADABLE_EXTENSIONS
+#include <emscripten.h>
+#endif
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -86,13 +90,35 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 			throw IOException(config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename));
 		}
 	}
-	auto lib_hdl = dlopen(filename.c_str(), RTLD_NOW | RTLD_LOCAL);
+	auto basename = fs.ExtractBaseName(filename);
+
+#ifdef WASM_LOADABLE_EXTENSIONS
+	EM_ASM(
+	    {
+		    // Next few lines should argubly in separate JavaScript-land function call
+		    // TODO: move them out / have them configurable
+		    const xhr = new XMLHttpRequest();
+		    xhr.open("GET", UTF8ToString($0), false);
+		    xhr.responseType = "arraybuffer";
+		    xhr.send(null);
+		    var uInt8Array = xhr.response;
+		    WebAssembly.validate(uInt8Array);
+		    console.log('Loading extension ', UTF8ToString($1));
+
+		    // Here we add the uInt8Array to Emscripten's filesystem, for it to be found by dlopen
+		    FS.writeFile(UTF8ToString($1), new Uint8Array(uInt8Array));
+	    },
+	    filename.c_str(), basename.c_str());
+	auto dopen_from = basename;
+#else
+	auto dopen_from = filename;
+#endif
+
+	auto lib_hdl = dlopen(dopen_from.c_str(), RTLD_NOW | RTLD_LOCAL);
 	if (!lib_hdl) {
 		throw IOException("Extension \"%s\" could not be loaded: %s", filename, GetDLError());
 	}
 
-	auto basename = fs.ExtractBaseName(filename);
-
 	ext_version_fun_t version_fun;
 	auto version_fun_name = basename + "_version";
 

package/src/duckdb/src/main/query_profiler.cpp

@@ -690,7 +690,7 @@ ExpressionExecutorInfo::ExpressionExecutorInfo(ExpressionExecutor &executor, con
 ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string name)
     : current_count(state.profiler.current_count), sample_count(state.profiler.sample_count),
       sample_tuples_count(state.profiler.sample_tuples_count), tuples_count(state.profiler.tuples_count),
-      name(state.name), time(state.profiler.time) {
+      name("expression"), time(state.profiler.time) {
 	// Use the name of expression-tree as extra-info
 	extra_info = std::move(name);
 	auto expression_info_p = make_uniq<ExpressionInfo>();

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -32,8 +32,9 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
 			// PRAGMA statement: check if we need to replace it by a new set of statements
 			PragmaHandler handler(context);
-			auto new_query = handler.HandlePragma(statements[i].get());
-			if (!new_query.empty()) {
+			string new_query;
+			bool expanded = handler.HandlePragma(statements[i].get(), new_query);
+			if (expanded) {
 				// this PRAGMA statement gets replaced by a new query string
 				// push the new query string through the parser again and add it to the transformer
 				Parser parser(context.GetParserOptions());
@@ -67,7 +68,7 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 	context.RunFunctionInTransactionInternal(lock, [&]() { HandlePragmaStatementsInternal(statements); });
 }
 
-string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &info
+bool PragmaHandler::HandlePragma(SQLStatement *statement, string &resulting_query) { // PragmaInfo &info
 	auto info = *(statement->Cast<PragmaStatement>()).info;
 	auto entry =
 	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name, false);
@@ -84,9 +85,10 @@ string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &inf
 		Binder::BindNamedParameters(bound_function.named_parameters, info.named_parameters, error_context,
 		                            bound_function.name);
 		FunctionParameters parameters {info.parameters, info.named_parameters};
-		return bound_function.query(context, parameters);
+		resulting_query = bound_function.query(context, parameters);
+		return true;
 	}
-	return string();
+	return false;
 }
 
 } // namespace duckdb