duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -39,14 +39,8 @@ public:
 public:
 	//! Read into the FileBuffer from the specified location.
 	void Read(FileHandle &handle, uint64_t location);
-	//! Read into the FileBuffer from the specified location. Automatically verifies the checksum, and throws an
-	//! exception if the checksum does not match correctly.
-	virtual void ReadAndChecksum(FileHandle &handle, uint64_t location);
 	//! Write the contents of the FileBuffer to the specified location.
 	void Write(FileHandle &handle, uint64_t location);
-	//! Write the contents of the FileBuffer to the specified location. Automatically adds a checksum of the contents of
-	//! the filebuffer in front of the written data.
-	virtual void ChecksumAndWrite(FileHandle &handle, uint64_t location);
 
 	void Clear();
 
@@ -57,6 +51,9 @@ public:
 	uint64_t AllocSize() const {
 		return internal_size;
 	}
+	data_ptr_t InternalBuffer() {
+		return internal_buffer;
+	}
 
 	struct MemoryRequirement {
 		idx_t alloc_size;
@@ -72,16 +69,6 @@ protected:
 	uint64_t internal_size;
 
 	void ReallocBuffer(size_t malloc_size);
-
-private:
-	//! The buffer that was actually malloc'd, i.e. the pointer that must be freed when the FileBuffer is destroyed
-	data_ptr_t malloced_buffer;
-	uint64_t malloced_size;
-
-protected:
-	uint64_t GetMallocedSize() {
-		return malloced_size;
-	}
 	void Init();
 };
 

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/string.hpp"
+#include "duckdb/common/winapi.hpp"
 
 namespace duckdb {
 
@@ -23,7 +24,9 @@ public:
 	virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0;
 	virtual ClientContext *TryGetClientContext() = 0;
 
-	static FileOpener *Get(ClientContext &context);
+	DUCKDB_API static FileOpener *Get(ClientContext &context);
+	DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener);
+	DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
 };
 
 } // namespace duckdb

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

@@ -9,11 +9,11 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/enums/file_compression_type.hpp"
+#include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_buffer.hpp"
-#include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/enums/file_compression_type.hpp"
+#include "duckdb/common/vector.hpp"
 
 #include <functional>
 
@@ -128,6 +128,8 @@ public:
 	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
 	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
 
+	//! Returns the extension of the file, or empty string if no extension was found.
+	DUCKDB_API string GetFileExtension(FileHandle &handle);
 	//! Returns the file size of a file handle, returns -1 on error
 	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
@@ -146,7 +148,9 @@ public:
 	DUCKDB_API virtual void RemoveDirectory(const string &directory);
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
 	DUCKDB_API virtual bool ListFiles(const string &directory,
-	                                  const std::function<void(const string &, bool)> &callback);
+	                                  const std::function<void(const string &, bool)> &callback,
+	                                  FileOpener *opener = nullptr);
+
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
 	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
@@ -176,8 +180,10 @@ public:
 	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)
 	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)
+	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is 'example')
 	DUCKDB_API static string ExtractBaseName(const string &path);
+	//! Extract the name of a file (e.g if the input is lib/example.dll the name is 'example.dll')
+	DUCKDB_API static string ExtractName(const string &path);
 
 	//! Runs a glob on the file system, returning a list of matching files
 	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
@@ -187,6 +193,12 @@ public:
 	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
 	DUCKDB_API virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
 
+	//! Unregister a sub-filesystem by name
+	DUCKDB_API virtual void UnregisterSubSystem(const string &name);
+
+	//! List registered sub-filesystems, including builtin ones
+	DUCKDB_API virtual vector<string> ListSubSystems();
+
 	//! Whether or not a sub-system can handle a specific file path
 	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
 
@@ -207,7 +219,6 @@ public:
 	//! Create a LocalFileSystem.
 	DUCKDB_API static unique_ptr<FileSystem> CreateLocal();
 
-protected:
 	//! Return the name of the filesytem. Used for forming diagnosis messages.
 	DUCKDB_API virtual std::string GetName() const = 0;
 };

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

@@ -14,7 +14,7 @@ namespace duckdb {
 
 class GZipFileSystem : public CompressedFileSystem {
 	// 32 KB
-	static constexpr const idx_t BUFFER_SIZE = 1 << 15;
+	static constexpr const idx_t BUFFER_SIZE = 1u << 15;
 
 public:
 	unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) override;

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

@@ -67,6 +67,14 @@ struct UniqueConstructor {
 	}
 };
 
+#ifdef DUCKDB_DEBUG_MOVE
+template<class T>
+typename std::remove_reference<T>::type&& move(T&& t) noexcept {
+	// the nonsensical sizeof check ensures this is never instantiated
+	static_assert(sizeof(T) == 0, "Use std::move instead of unqualified move or duckdb::move");
+}
+#endif
+
 template <typename T>
 T MaxValue(T a, T b) {
 	return a > b ? a : b;

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

@@ -8,13 +8,17 @@
 
 #pragma once
 
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/table_filter.hpp"
+#include "duckdb/common/types/partitioned_column_data.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/filter_combiner.hpp"
+#include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/table_filter.hpp"
 #include "re2/re2.h"
 
+#include <sstream>
+#include <iostream>
+
 namespace duckdb {
 
 class HivePartitioning {
@@ -34,4 +38,69 @@ public:
 	DUCKDB_API static const string REGEX_STRING;
 };
 
+struct HivePartitionKey {
+	//! Columns by which we want to partition
+	vector<Value> values;
+	//! Precomputed hash of values
+	hash_t hash;
+
+	struct Hash {
+		std::size_t operator()(const HivePartitionKey &k) const {
+			return k.hash;
+		}
+	};
+
+	struct Equality {
+		bool operator()(const HivePartitionKey &a, const HivePartitionKey &b) const {
+			return a.values == b.values;
+		}
+	};
+};
+
+//! Maps hive partitions to partition_ids
+typedef unordered_map<HivePartitionKey, idx_t, HivePartitionKey::Hash, HivePartitionKey::Equality> hive_partition_map_t;
+
+//! class shared between HivePartitionColumnData classes that synchronizes partition discovery between threads.
+//! each HivePartitionedColumnData will hold a local copy of the key->partition map
+class GlobalHivePartitionState {
+public:
+	mutex lock;
+	hive_partition_map_t partition_map;
+	//! Used for incremental updating local copies of the partition map;
+	std::vector<hive_partition_map_t::const_iterator> partitions;
+};
+
+class HivePartitionedColumnData : public PartitionedColumnData {
+public:
+	HivePartitionedColumnData(ClientContext &context, vector<LogicalType> types, vector<idx_t> partition_by_cols,
+	                          shared_ptr<GlobalHivePartitionState> global_state = nullptr)
+	    : PartitionedColumnData(PartitionedColumnDataType::HIVE, context, std::move(types)),
+	      global_state(std::move(global_state)), group_by_columns(partition_by_cols) {
+	}
+	HivePartitionedColumnData(const HivePartitionedColumnData &other);
+	void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) override;
+
+	//! Reverse lookup map to reconstruct keys from a partition id
+	std::map<idx_t, const HivePartitionKey *> GetReverseMap();
+
+protected:
+	//! Create allocators for all currently registered partitions
+	void GrowAllocators();
+	//! Create append states for all currently registered partitions
+	void GrowAppendState(PartitionedColumnDataAppendState &state);
+	//! Create and initialize partitions for all currently registered partitions
+	void GrowPartitions(PartitionedColumnDataAppendState &state);
+	//! Register a newly discovered partition
+	idx_t RegisterNewPartition(HivePartitionKey key, PartitionedColumnDataAppendState &state);
+	//! Copy the newly added entries in the global_state.map to the local_partition_map (requires lock!)
+	void SynchronizeLocalMap();
+
+	//! Shared HivePartitionedColumnData should always have a global state to allow parallel key discovery
+	shared_ptr<GlobalHivePartitionState> global_state;
+	//! Thread-local copy of the partition map
+	hive_partition_map_t local_partition_map;
+	//! The columns that make up the key
+	vector<idx_t> group_by_columns;
+};
+
 } // namespace duckdb

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

@@ -35,7 +35,7 @@ public:
 
 	//! helper function to get the HTTP
 	static HTTPStats *TryGetStats(FileOpener *opener) {
-		auto client_context = opener->TryGetClientContext();
+		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
 			return client_context->client_data->http_stats.get();
 		}

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

@@ -17,7 +17,7 @@ template <class T, class INDEX_TYPE>
 class IndexVector {
 public:
 	void push_back(T element) {
-		internal_vector.push_back(move(element));
+		internal_vector.push_back(std::move(element));
 	}
 
 	T &operator[](INDEX_TYPE idx) {

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

@@ -74,6 +74,7 @@ struct NumericLimits<int32_t> {
 		return 10;
 	}
 };
+
 template <>
 struct NumericLimits<int64_t> {
 	DUCKDB_API static constexpr int64_t Minimum() {
@@ -104,6 +105,7 @@ struct NumericLimits<hugeint_t> {
 		return 39;
 	}
 };
+
 template <>
 struct NumericLimits<uint8_t> {
 	DUCKDB_API static constexpr uint8_t Minimum() {
@@ -119,6 +121,7 @@ struct NumericLimits<uint8_t> {
 		return 3;
 	}
 };
+
 template <>
 struct NumericLimits<uint16_t> {
 	DUCKDB_API static constexpr uint16_t Minimum() {

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

@@ -47,7 +47,8 @@ public:
 	//! Recursively remove a directory and all files in it
 	void RemoveDirectory(const string &directory) override;
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) override;
+	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+	               FileOpener *opener = nullptr) override;
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
 	void MoveFile(const string &source, const string &target) override;

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -34,6 +34,13 @@ struct TryCastErrorMessage {
 	}
 };
 
+struct TryCastErrorMessageCommaSeparated {
+	template <class SRC, class DST>
+	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
+		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
+	}
+};
+
 template <class SRC, class DST>
 static string CastExceptionText(SRC input) {
 	if (std::is_same<SRC, string_t>()) {
@@ -434,6 +441,16 @@ template <>
 DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict);
 template <>
 DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict);
+template <>
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, float &result, string *error_message, bool strict);
+template <>
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, double &result, string *error_message, bool strict);
+template <>
+DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message,
+                                                             bool strict);
+template <>
+DUCKDB_API bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message,
+                                                             bool strict);
 
 //===--------------------------------------------------------------------===//
 // Date Casts
@@ -647,6 +664,30 @@ template <>
 bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
                               bool strict);
 
+//===--------------------------------------------------------------------===//
+// Bits
+//===--------------------------------------------------------------------===//
+struct CastFromBit {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		throw duckdb::NotImplementedException("Cast from bit could not be performed!");
+	}
+};
+template <>
+duckdb::string_t CastFromBit::Operation(duckdb::string_t input, Vector &vector);
+
+struct TryCastToBit {
+	template <class SRC, class DST>
+	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
+	                             bool strict = false) {
+		throw InternalException("Unsupported type for try cast to bit");
+	}
+};
+
+template <>
+bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
+                             bool strict);
+
 //===--------------------------------------------------------------------===//
 // UUID
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/operator/convert_to_string.hpp

@@ -17,44 +17,44 @@ namespace duckdb {
 
 struct ConvertToString {
 	template <class SRC>
-	static inline string Operation(SRC input) {
+	DUCKDB_API static inline string Operation(SRC input) {
 		throw InternalException("Unrecognized type for ConvertToString %s", GetTypeId<SRC>());
 	}
 };
 
 template <>
-string ConvertToString::Operation(bool input);
+DUCKDB_API string ConvertToString::Operation(bool input);
 template <>
-string ConvertToString::Operation(int8_t input);
+DUCKDB_API string ConvertToString::Operation(int8_t input);
 template <>
-string ConvertToString::Operation(int16_t input);
+DUCKDB_API string ConvertToString::Operation(int16_t input);
 template <>
-string ConvertToString::Operation(int32_t input);
+DUCKDB_API string ConvertToString::Operation(int32_t input);
 template <>
-string ConvertToString::Operation(int64_t input);
+DUCKDB_API string ConvertToString::Operation(int64_t input);
 template <>
-string ConvertToString::Operation(uint8_t input);
+DUCKDB_API string ConvertToString::Operation(uint8_t input);
 template <>
-string ConvertToString::Operation(uint16_t input);
+DUCKDB_API string ConvertToString::Operation(uint16_t input);
 template <>
-string ConvertToString::Operation(uint32_t input);
+DUCKDB_API string ConvertToString::Operation(uint32_t input);
 template <>
-string ConvertToString::Operation(uint64_t input);
+DUCKDB_API string ConvertToString::Operation(uint64_t input);
 template <>
-string ConvertToString::Operation(hugeint_t input);
+DUCKDB_API string ConvertToString::Operation(hugeint_t input);
 template <>
-string ConvertToString::Operation(float input);
+DUCKDB_API string ConvertToString::Operation(float input);
 template <>
-string ConvertToString::Operation(double input);
+DUCKDB_API string ConvertToString::Operation(double input);
 template <>
-string ConvertToString::Operation(interval_t input);
+DUCKDB_API string ConvertToString::Operation(interval_t input);
 template <>
-string ConvertToString::Operation(date_t input);
+DUCKDB_API string ConvertToString::Operation(date_t input);
 template <>
-string ConvertToString::Operation(dtime_t input);
+DUCKDB_API string ConvertToString::Operation(dtime_t input);
 template <>
-string ConvertToString::Operation(timestamp_t input);
+DUCKDB_API string ConvertToString::Operation(timestamp_t input);
 template <>
-string ConvertToString::Operation(string_t input);
+DUCKDB_API string ConvertToString::Operation(string_t input);
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/decimal_cast_operators.hpp

@@ -23,6 +23,14 @@ struct TryCastToDecimal {
 	}
 };
 
+struct TryCastToDecimalCommaSeparated {
+	template <class SRC, class DST>
+	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width,
+	                                        uint8_t scale) {
+		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
+	}
+};
+
 struct TryCastFromDecimal {
 	template <class SRC, class DST>
 	static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
@@ -367,6 +375,18 @@ DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int64_t &result, str
 template <>
 DUCKDB_API bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
                                             uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, string *error_message,
+                                                          uint8_t width, uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, string *error_message,
+                                                          uint8_t width, uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, string *error_message,
+                                                          uint8_t width, uint8_t scale);
+template <>
+DUCKDB_API bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, string *error_message,
+                                                          uint8_t width, uint8_t scale);
 
 struct StringCastFromDecimal {
 	template <class SRC>

package/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp

@@ -96,6 +96,26 @@ bool TryCastWithOverflowCheck(float value, int64_t &result) {
 	                                                     9223372036854775808.0f);
 }
 
+template <>
+bool TryCastWithOverflowCheck(float value, uint8_t &result) {
+	return TryCastWithOverflowCheckFloat<float, uint8_t>(value, result, 0.0f, 256.0f);
+}
+
+template <>
+bool TryCastWithOverflowCheck(float value, uint16_t &result) {
+	return TryCastWithOverflowCheckFloat<float, uint16_t>(value, result, 0.0f, 65536.0f);
+}
+
+template <>
+bool TryCastWithOverflowCheck(float value, uint32_t &result) {
+	return TryCastWithOverflowCheckFloat<float, uint32_t>(value, result, 0.0f, 4294967296.0f);
+}
+
+template <>
+bool TryCastWithOverflowCheck(float value, uint64_t &result) {
+	return TryCastWithOverflowCheckFloat<float, uint64_t>(value, result, 0.0f, 18446744073709551616.0f);
+}
+
 template <>
 bool TryCastWithOverflowCheck(double value, int8_t &result) {
 	return TryCastWithOverflowCheckFloat<double, int8_t>(value, result, -128.0, 128.0);
@@ -116,6 +136,25 @@ bool TryCastWithOverflowCheck(double value, int64_t &result) {
 	return TryCastWithOverflowCheckFloat<double, int64_t>(value, result, -9223372036854775808.0, 9223372036854775808.0);
 }
 
+template <>
+bool TryCastWithOverflowCheck(double value, uint8_t &result) {
+	return TryCastWithOverflowCheckFloat<double, uint8_t>(value, result, 0.0, 256.0);
+}
+
+template <>
+bool TryCastWithOverflowCheck(double value, uint16_t &result) {
+	return TryCastWithOverflowCheckFloat<double, uint16_t>(value, result, 0.0, 65536.0);
+}
+
+template <>
+bool TryCastWithOverflowCheck(double value, uint32_t &result) {
+	return TryCastWithOverflowCheckFloat<double, uint32_t>(value, result, 0.0, 4294967296.0);
+}
+
+template <>
+bool TryCastWithOverflowCheck(double value, uint64_t &result) {
+	return TryCastWithOverflowCheckFloat<double, uint64_t>(value, result, 0.0, 18446744073709551615.0);
+}
 template <>
 bool TryCastWithOverflowCheck(float input, float &result) {
 	result = input;

package/src/duckdb/src/include/duckdb/common/operator/subtract.hpp

@@ -72,7 +72,7 @@ bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &
 
 struct SubtractOperatorOverflowCheck {
 	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
+	DUCKDB_API static inline TR Operation(TA left, TB right) {
 		TR result;
 		if (!TrySubtractOperator::Operation(left, right, result)) {
 			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,

package/src/duckdb/src/include/duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/progress_bar/progress_bar_display.hpp"
+#include "duckdb/common/unicode_bar.hpp"
 
 namespace duckdb {
 
@@ -17,7 +18,7 @@ class TerminalProgressBarDisplay : public ProgressBarDisplay {
 public:
 	TerminalProgressBarDisplay() {
 	}
-	~TerminalProgressBarDisplay() override final {
+	~TerminalProgressBarDisplay() override {
 	}
 
 public:
@@ -25,18 +26,16 @@ public:
 	void Finish() override;
 
 private:
-	static constexpr const idx_t PARTIAL_BLOCK_COUNT = 8;
+	static constexpr const idx_t PARTIAL_BLOCK_COUNT = UnicodeBar::PartialBlocksCount();
 #ifndef DUCKDB_ASCII_TREE_RENDERER
 	const char *PROGRESS_EMPTY = " ";
-	const char *PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] {
-	    " ",           "\xE2\x96\x8F", "\xE2\x96\x8E", "\xE2\x96\x8D", "\xE2\x96\x8C", "\xE2\x96\x8B", "\xE2\x96\x8A",
-	    "\xE2\x96\x89"};
-	const char *PROGRESS_BLOCK = "\xE2\x96\x88";
+	const char *const *PROGRESS_PARTIAL = UnicodeBar::PartialBlocks();
+	const char *PROGRESS_BLOCK = UnicodeBar::FullBlock();
 	const char *PROGRESS_START = "\xE2\x96\x95";
 	const char *PROGRESS_END = "\xE2\x96\x8F";
 #else
 	const char *PROGRESS_EMPTY = " ";
-	const char *PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] {" ", " ", " ", " ", " ", " ", " ", " "};
+	const char *const PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] = {" ", " ", " ", " ", " ", " ", " ", " "};
 	const char *PROGRESS_BLOCK = "=";
 	const char *PROGRESS_START = "[";
 	const char *PROGRESS_END = "]";

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

@@ -64,6 +64,10 @@ public:
 	RadixPartitionedColumnData(const RadixPartitionedColumnData &other);
 	~RadixPartitionedColumnData() override;
 
+	idx_t GetRadixBits() const {
+		return radix_bits;
+	}
+
 protected:
 	//===--------------------------------------------------------------------===//
 	// Radix Partitioning interface implementation

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

@@ -119,16 +119,16 @@ 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)...);
-			list.push_back(move(child));
+			list.push_back(std::move(child));
 		}
 	}
 
 	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)...);

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

@@ -137,6 +137,8 @@ public:
 	DUCKDB_API static void LTrim(string &str);
 	//! Remove the whitespace char in the right end of the string
 	DUCKDB_API static void RTrim(string &str);
+	//! Remove the all chars from chars_to_trim char in the right end of the string
+	DUCKDB_API static void RTrim(string &str, const string &chars_to_trim);
 	//! Remove the whitespace char in the left and right end of the string
 	DUCKDB_API static void Trim(string &str);
 

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

@@ -89,7 +89,7 @@ struct TreeRendererConfig {
 
 class TreeRenderer {
 public:
-	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(move(config_p)) {
+	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(std::move(config_p)) {
 	}
 
 	string ToString(const LogicalOperator &op);