duckdb 0.7.2-dev1684.0 → 0.7.2-dev1803.0

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/common/string_util.hpp

@@ -38,6 +38,13 @@ public:
 		throw InvalidInputException("Invalid input for hex digit: %s", string(c, 1));
 	}
 
+	static uint8_t GetBinaryValue(char c) {
+		if (c >= '0' && c <= '1') {
+			return c - '0';
+		}
+		throw InvalidInputException("Invalid input for binary digit: %s", string(c, 1));
+	}
+
 	DUCKDB_API static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}

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

@@ -387,7 +387,7 @@ public:
 	DUCKDB_API static LogicalType DECIMAL(int width, int scale);                 // NOLINT
 	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
 	DUCKDB_API static LogicalType LIST(const LogicalType &child);                       // NOLINT
-	DUCKDB_API static LogicalType STRUCT(const child_list_t<LogicalType> &children);    // NOLINT
+	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
 	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
 	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT

package/src/duckdb/src/include/duckdb/function/scalar/math_functions.hpp

@@ -30,6 +30,10 @@ struct FloorFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct TruncFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct RoundFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -12,21 +12,21 @@
 #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 };
 
 struct BufferPoolReservation {
 	idx_t size {0};
+	BufferPool &pool;
 
-	BufferPoolReservation() {
+	BufferPoolReservation(BufferPool &pool) : pool(pool) {
 	}
 	BufferPoolReservation(const BufferPoolReservation &) = delete;
 	BufferPoolReservation &operator=(const BufferPoolReservation &) = delete;
@@ -36,18 +36,17 @@ struct BufferPoolReservation {
 
 	~BufferPoolReservation();
 
-	void Resize(atomic<idx_t> &counter, idx_t new_size);
+	void Resize(idx_t new_size);
 	void Merge(BufferPoolReservation &&src);
 };
 
 struct TempBufferPoolReservation : BufferPoolReservation {
-	atomic<idx_t> &counter;
-	TempBufferPoolReservation(atomic<idx_t> &counter, idx_t size) : counter(counter) {
-		Resize(counter, size);
+	TempBufferPoolReservation(BufferPool &pool, idx_t size) : BufferPoolReservation(pool) {
+		Resize(size);
 	}
 	TempBufferPoolReservation(TempBufferPoolReservation &&) = default;
 	~TempBufferPoolReservation() {
-		Resize(counter, 0);
+		Resize(0);
 	}
 };
 

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

@@ -0,0 +1,79 @@
+#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);
+
+	void IncreaseUsedMemory(idx_t size);
+
+	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/include/duckdb/storage/compression/chimp/algorithm/chimp128.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/common/likely.hpp"
 #include "duckdb/storage/compression/chimp/algorithm/packed_data.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/bit_utils.hpp"
 
 #include "duckdb/storage/compression/chimp/algorithm/bit_reader.hpp"
 #include "duckdb/storage/compression/chimp/algorithm/output_bit_stream.hpp"

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp

@@ -10,68 +10,6 @@
 
 #include "duckdb.h"
 
-#ifdef _MSC_VER
-#define __restrict__
-#define __BYTE_ORDER__          __ORDER_LITTLE_ENDIAN__
-#define __ORDER_LITTLE_ENDIAN__ 2
-#include <intrin.h>
-static inline int __builtin_ctzll(unsigned long long x) {
-#ifdef _WIN64
-	unsigned long ret;
-	_BitScanForward64(&ret, x);
-	return (int)ret;
-#else
-	unsigned long low, high;
-	bool low_set = _BitScanForward(&low, (unsigned __int32)(x)) != 0;
-	_BitScanForward(&high, (unsigned __int32)(x >> 32));
-	high += 32;
-	return low_set ? low : high;
-#endif
-}
-static inline int __builtin_clzll(unsigned long long mask) {
-	unsigned long where;
-// BitScanReverse scans from MSB to LSB for first set bit.
-// Returns 0 if no set bit is found.
-#if defined(_WIN64)
-	if (_BitScanReverse64(&where, mask))
-		return static_cast<int>(63 - where);
-#elif defined(_WIN32)
-	// Scan the high 32 bits.
-	if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
-		return static_cast<int>(63 - (where + 32)); // Create a bit offset from the MSB.
-	// Scan the low 32 bits.
-	if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
-		return static_cast<int>(63 - where);
-#else
-#error "Implementation of __builtin_clzll required"
-#endif
-	return 64; // Undefined Behavior.
-}
-
-static inline int __builtin_ctz(unsigned int value) {
-	unsigned long trailing_zero = 0;
-
-	if (_BitScanForward(&trailing_zero, value)) {
-		return trailing_zero;
-	} else {
-		// This is undefined, I better choose 32 than 0
-		return 32;
-	}
-}
-
-static inline int __builtin_clz(unsigned int value) {
-	unsigned long leading_zero = 0;
-
-	if (_BitScanReverse(&leading_zero, value)) {
-		return 31 - leading_zero;
-	} else {
-		// Same remarks as above
-		return 32;
-	}
-}
-
-#endif
-
 namespace duckdb {
 
 template <class T>
@@ -89,41 +27,6 @@ struct SignificantBits<uint32_t> {
 	static constexpr uint8_t mask = ((uint8_t)1 << size) - 1;
 };
 
-template <class T>
-struct CountZeros {};
-
-template <>
-struct CountZeros<uint32_t> {
-	inline static int Leading(uint32_t value) {
-		if (!value) {
-			return 32;
-		}
-		return __builtin_clz(value);
-	}
-	inline static int Trailing(uint32_t value) {
-		if (!value) {
-			return 32;
-		}
-		return __builtin_ctz(value);
-	}
-};
-
-template <>
-struct CountZeros<uint64_t> {
-	inline static int Leading(uint64_t value) {
-		if (!value) {
-			return 64;
-		}
-		return __builtin_clzll(value);
-	}
-	inline static int Trailing(uint64_t value) {
-		if (!value) {
-			return 64;
-		}
-		return __builtin_ctzll(value);
-	}
-};
-
 struct ChimpConstants {
 	struct Compression {
 		static constexpr uint8_t LEADING_ROUND[] = {0,  0,  0,  0,  0,  0,  0,  0,  8,  8,  8,  8,  12, 12, 12, 12,

package/src/duckdb/src/include/duckdb/storage/compression/patas/algorithm/patas.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/storage/compression/chimp/algorithm/chimp_utils.hpp"
 #include "duckdb/storage/compression/chimp/algorithm/packed_data.hpp"
 #include "duckdb/storage/compression/patas/shared.hpp"
+#include "duckdb/common/bit_utils.hpp"
 
 namespace duckdb {
 

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);