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

package/src/duckdb/src/common/file_buffer.cpp

@@ -23,8 +23,6 @@ void FileBuffer::Init() {
 	size = 0;
 	internal_buffer = nullptr;
 	internal_size = 0;
-	malloced_buffer = nullptr;
-	malloced_size = 0;
 }
 
 FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p) : allocator(source.allocator), type(type_p) {
@@ -33,31 +31,29 @@ FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p) : allocator(so
 	size = source.size;
 	internal_buffer = source.internal_buffer;
 	internal_size = source.internal_size;
-	malloced_buffer = source.malloced_buffer;
-	malloced_size = source.malloced_size;
 
 	source.Init();
 }
 
 FileBuffer::~FileBuffer() {
-	if (!malloced_buffer) {
+	if (!internal_buffer) {
 		return;
 	}
-	allocator.FreeData(malloced_buffer, malloced_size);
+	allocator.FreeData(internal_buffer, internal_size);
 }
 
 void FileBuffer::ReallocBuffer(size_t new_size) {
-	if (malloced_buffer) {
-		malloced_buffer = allocator.ReallocateData(malloced_buffer, malloced_size, new_size);
+	data_ptr_t new_buffer;
+	if (internal_buffer) {
+		new_buffer = allocator.ReallocateData(internal_buffer, internal_size, new_size);
 	} else {
-		malloced_buffer = allocator.AllocateData(new_size);
+		new_buffer = allocator.AllocateData(new_size);
 	}
-	if (!malloced_buffer) {
+	if (!new_buffer) {
 		throw std::bad_alloc();
 	}
-	malloced_size = new_size;
-	internal_buffer = malloced_buffer;
-	internal_size = malloced_size;
+	internal_buffer = new_buffer;
+	internal_size = new_size;
 	// Caller must update these.
 	buffer = nullptr;
 	size = 0;
@@ -92,32 +88,11 @@ void FileBuffer::Read(FileHandle &handle, uint64_t location) {
 	handle.Read(internal_buffer, internal_size, location);
 }
 
-void FileBuffer::ReadAndChecksum(FileHandle &handle, uint64_t location) {
-	// read the buffer from disk
-	Read(handle, location);
-	// compute the checksum
-	auto stored_checksum = Load<uint64_t>(internal_buffer);
-	uint64_t computed_checksum = Checksum(buffer, size);
-	// verify the checksum
-	if (stored_checksum != computed_checksum) {
-		throw IOException("Corrupt database file: computed checksum %llu does not match stored checksum %llu in block",
-		                  computed_checksum, stored_checksum);
-	}
-}
-
 void FileBuffer::Write(FileHandle &handle, uint64_t location) {
 	D_ASSERT(type != FileBufferType::TINY_BUFFER);
 	handle.Write(internal_buffer, internal_size, location);
 }
 
-void FileBuffer::ChecksumAndWrite(FileHandle &handle, uint64_t location) {
-	// compute the checksum and write it to the start of the buffer (if not temp buffer)
-	uint64_t checksum = Checksum(buffer, size);
-	Store<uint64_t>(checksum, internal_buffer);
-	// now write the buffer
-	Write(handle, location);
-}
-
 void FileBuffer::Clear() {
 	memset(internal_buffer, 0, internal_size);
 }

package/src/duckdb/src/common/file_system.cpp

@@ -172,7 +172,7 @@ string FileSystem::ConvertSeparators(const string &path) {
 	return result;
 }
 
-string FileSystem::ExtractBaseName(const string &path) {
+string FileSystem::ExtractName(const string &path) {
 	if (path.empty()) {
 		return string();
 	}
@@ -180,7 +180,14 @@ string FileSystem::ExtractBaseName(const string &path) {
 	auto sep = PathSeparator();
 	auto splits = StringUtil::Split(normalized_path, sep);
 	D_ASSERT(!splits.empty());
-	auto vec = StringUtil::Split(splits.back(), ".");
+	return splits.back();
+}
+
+string FileSystem::ExtractBaseName(const string &path) {
+	if (path.empty()) {
+		return string();
+	}
+	auto vec = StringUtil::Split(ExtractName(path), ".");
 	D_ASSERT(!vec.empty());
 	return vec[0];
 }
@@ -239,6 +246,14 @@ int64_t FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
 	throw NotImplementedException("%s: Write is not implemented!", GetName());
 }
 
+string FileSystem::GetFileExtension(FileHandle &handle) {
+	auto dot_location = handle.path.rfind('.');
+	if (dot_location != std::string::npos) {
+		return handle.path.substr(dot_location + 1, std::string::npos);
+	}
+	return string();
+}
+
 int64_t FileSystem::GetFileSize(FileHandle &handle) {
 	throw NotImplementedException("%s: GetFileSize is not implemented!", GetName());
 }
@@ -267,7 +282,8 @@ void FileSystem::RemoveDirectory(const string &directory) {
 	throw NotImplementedException("%s: RemoveDirectory is not implemented!", GetName());
 }
 
-bool FileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
+bool FileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+                           FileOpener *opener) {
 	throw NotImplementedException("%s: ListFiles is not implemented!", GetName());
 }
 
@@ -307,6 +323,14 @@ void FileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_
 	throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName());
 }
 
+void FileSystem::UnregisterSubSystem(const string &name) {
+	throw NotImplementedException("%s: Can't unregister a sub system on a non-virtual file system", GetName());
+}
+
+vector<string> FileSystem::ListSubSystems() {
+	throw NotImplementedException("%s: Can't list sub systems on a non-virtual file system", GetName());
+}
+
 bool FileSystem::CanHandleFile(const string &fpath) {
 	throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName());
 }
@@ -336,7 +360,7 @@ 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(FileSystem &file_system, string path_p) : file_system(file_system), path(std::move(path_p)) {
 }
 
 FileHandle::~FileHandle() {

package/src/duckdb/src/common/gzip_file_system.cpp

@@ -90,7 +90,7 @@ MiniZStreamWrapper::~MiniZStreamWrapper() {
 		return;
 	}
 	try {
-		Close();
+		MiniZStreamWrapper::Close();
 	} catch (...) {
 	}
 }
@@ -239,7 +239,7 @@ void MiniZStreamWrapper::Close() {
 class GZipFile : public CompressedFile {
 public:
 	GZipFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
-	    : CompressedFile(gzip_fs, move(child_handle_p), path) {
+	    : CompressedFile(gzip_fs, std::move(child_handle_p), path) {
 		Initialize(write);
 	}
 
@@ -320,7 +320,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 
 unique_ptr<FileHandle> GZipFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
 	auto path = handle->path;
-	return make_unique<GZipFile>(move(handle), path, write);
+	return make_unique<GZipFile>(std::move(handle), path, write);
 }
 
 unique_ptr<StreamWrapper> GZipFileSystem::CreateStream() {

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -6,8 +6,6 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "re2/re2.h"
 
-#include <iostream>
-
 namespace duckdb {
 
 static unordered_map<column_t, string> GetKnownColumnValues(string &filename,
@@ -88,6 +86,7 @@ void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<str
                                               unordered_map<string, column_t> &column_map, idx_t table_index,
                                               bool hive_enabled, bool filename_enabled) {
 	vector<string> pruned_files;
+	vector<bool> have_preserved_filter(filters.size(), false);
 	vector<unique_ptr<Expression>> pruned_filters;
 	duckdb_re2::RE2 regex(REGEX_STRING);
 
@@ -101,15 +100,21 @@ void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<str
 		auto known_values = GetKnownColumnValues(file, column_map, regex, filename_enabled, hive_enabled);
 
 		FilterCombiner combiner(context);
-		for (auto &filter : filters) {
+
+		for (idx_t j = 0; j < filters.size(); j++) {
+			auto &filter = filters[j];
 			unique_ptr<Expression> filter_copy = filter->Copy();
 			ConvertKnownColRefToConstants(filter_copy, known_values, table_index);
 			// Evaluate the filter, if it can be evaluated here, we can not prune this filter
 			Value result_value;
+
 			if (!filter_copy->IsScalar() || !filter_copy->IsFoldable() ||
 			    !ExpressionExecutor::TryEvaluateScalar(context, *filter_copy, result_value)) {
 				// can not be evaluated only with the filename/hive columns added, we can not prune this filter
-				pruned_filters.emplace_back(filter->Copy());
+				if (!have_preserved_filter[j]) {
+					pruned_filters.emplace_back(filter->Copy());
+					have_preserved_filter[j] = true;
+				}
 			} else if (!result_value.GetValue<bool>()) {
 				// filter evaluates to false
 				should_prune_file = true;
@@ -126,8 +131,128 @@ void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<str
 		}
 	}
 
+	D_ASSERT(filters.size() >= pruned_filters.size());
+
 	filters = std::move(pruned_filters);
 	files = std::move(pruned_files);
 }
 
+HivePartitionedColumnData::HivePartitionedColumnData(const HivePartitionedColumnData &other)
+    : PartitionedColumnData(other) {
+	// Synchronize to ensure consistency of shared partition map
+	if (other.global_state) {
+		global_state = other.global_state;
+		unique_lock<mutex> lck(global_state->lock);
+		SynchronizeLocalMap();
+	}
+}
+
+void HivePartitionedColumnData::ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
+	Vector hashes(LogicalType::HASH, input.size());
+	input.Hash(group_by_columns, hashes);
+
+	for (idx_t i = 0; i < input.size(); i++) {
+		HivePartitionKey key;
+		key.hash = FlatVector::GetData<hash_t>(hashes)[i];
+		for (auto &col : group_by_columns) {
+			key.values.emplace_back(input.GetValue(col, i));
+		}
+
+		auto lookup = local_partition_map.find(key);
+		const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
+		if (lookup == local_partition_map.end()) {
+			idx_t new_partition_id = RegisterNewPartition(key, state);
+			partition_indices[i] = new_partition_id;
+		} else {
+			partition_indices[i] = lookup->second;
+		}
+	}
+}
+
+std::map<idx_t, const HivePartitionKey *> HivePartitionedColumnData::GetReverseMap() {
+	std::map<idx_t, const HivePartitionKey *> ret;
+	for (const auto &pair : local_partition_map) {
+		ret[pair.second] = &(pair.first);
+	}
+	return ret;
+}
+
+void HivePartitionedColumnData::GrowAllocators() {
+	unique_lock<mutex> lck_gstate(allocators->lock);
+
+	idx_t current_allocator_size = allocators->allocators.size();
+	idx_t required_allocators = local_partition_map.size();
+
+	allocators->allocators.reserve(current_allocator_size);
+	for (idx_t i = current_allocator_size; i < required_allocators; i++) {
+		CreateAllocator();
+	}
+
+	D_ASSERT(allocators->allocators.size() == local_partition_map.size());
+}
+
+void HivePartitionedColumnData::GrowAppendState(PartitionedColumnDataAppendState &state) {
+	idx_t current_append_state_size = state.partition_append_states.size();
+	idx_t required_append_state_size = local_partition_map.size();
+
+	for (idx_t i = current_append_state_size; i < required_append_state_size; i++) {
+		state.partition_append_states.emplace_back(make_unique<ColumnDataAppendState>());
+		state.partition_buffers.emplace_back(CreatePartitionBuffer());
+	}
+}
+
+void HivePartitionedColumnData::GrowPartitions(PartitionedColumnDataAppendState &state) {
+	idx_t current_partitions = partitions.size();
+	idx_t required_partitions = local_partition_map.size();
+
+	D_ASSERT(allocators->allocators.size() == required_partitions);
+
+	for (idx_t i = current_partitions; i < required_partitions; i++) {
+		partitions.emplace_back(CreatePartitionCollection(i));
+		partitions[i]->InitializeAppend(*state.partition_append_states[i]);
+	}
+	D_ASSERT(partitions.size() == local_partition_map.size());
+}
+
+void HivePartitionedColumnData::SynchronizeLocalMap() {
+	// Synchronise global map into local, may contain changes from other threads too
+	for (auto it = global_state->partitions.begin() + local_partition_map.size(); it < global_state->partitions.end();
+	     it++) {
+		local_partition_map[(*it)->first] = (*it)->second;
+	}
+}
+
+idx_t HivePartitionedColumnData::RegisterNewPartition(HivePartitionKey key, PartitionedColumnDataAppendState &state) {
+	if (global_state) {
+		idx_t partition_id;
+
+		// Synchronize Global state with our local state with the newly discoveren partition
+		{
+			unique_lock<mutex> lck_gstate(global_state->lock);
+
+			// Insert into global map, or return partition if already present
+			auto res =
+			    global_state->partition_map.emplace(std::make_pair(std::move(key), global_state->partition_map.size()));
+			auto it = res.first;
+			partition_id = it->second;
+
+			// Add iterator to vector to allow incrementally updating local states from global state
+			global_state->partitions.emplace_back(it);
+			SynchronizeLocalMap();
+		}
+
+		// After synchronizing with the global state, we need to grow the shared allocators to support
+		// the number of partitions, which guarantees that there's always enough allocators available to each thread
+		GrowAllocators();
+
+		// Grow local partition data
+		GrowAppendState(state);
+		GrowPartitions(state);
+
+		return partition_id;
+	} else {
+		return local_partition_map.emplace(std::make_pair(std::move(key), local_partition_map.size())).first->second;
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/local_file_system.cpp

@@ -120,10 +120,10 @@ bool LocalFileSystem::IsPipe(const string &filename) {
 
 struct UnixFileHandle : public FileHandle {
 public:
-	UnixFileHandle(FileSystem &file_system, string path, int fd) : FileHandle(file_system, move(path)), fd(fd) {
+	UnixFileHandle(FileSystem &file_system, string path, int fd) : FileHandle(file_system, std::move(path)), fd(fd) {
 	}
 	~UnixFileHandle() override {
-		Close();
+		UnixFileHandle::Close();
 	}
 
 	int fd;
@@ -407,7 +407,8 @@ void LocalFileSystem::RemoveFile(const string &filename) {
 	}
 }
 
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
+bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+                                FileOpener *opener) {
 	if (!DirectoryExists(directory)) {
 		return false;
 	}
@@ -488,7 +489,7 @@ public:
 	WindowsFileHandle(FileSystem &file_system, string path, HANDLE fd)
 	    : FileHandle(file_system, path), position(0), fd(fd) {
 	}
-	virtual ~WindowsFileHandle() {
+	~WindowsFileHandle() override {
 		Close();
 	}
 
@@ -552,7 +553,7 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 		auto file_size = GetFileSize(*handle);
 		SetFilePointer(*handle, file_size);
 	}
-	return move(handle);
+	return std::move(handle);
 }
 
 void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
@@ -734,7 +735,8 @@ void LocalFileSystem::RemoveFile(const string &filename) {
 	}
 }
 
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
+bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+                                FileOpener *opener) {
 	string search_dir = JoinPath(directory, "*");
 
 	auto unicode_path = WindowsUtil::UTF8ToUnicode(search_dir.c_str());
@@ -966,7 +968,7 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 		if (is_last_chunk) {
 			return result;
 		}
-		previous_directories = move(result);
+		previous_directories = std::move(result);
 	}
 	return vector<string>();
 }

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -20,6 +20,7 @@
 #include "duckdb/common/types.hpp"
 #include "fast_float/fast_float.h"
 #include "fmt/format.h"
+#include "duckdb/common/types/bit.hpp"
 
 #include <cctype>
 #include <cmath>
@@ -875,14 +876,27 @@ struct IntegerCastOperation {
 	}
 };
 
-template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
+template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation, char decimal_separator = '.'>
 static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict) {
-	idx_t start_pos = NEGATIVE || *buf == '+' ? 1 : 0;
+	idx_t start_pos;
+	if (NEGATIVE) {
+		start_pos = 1;
+	} else {
+		if (*buf == '+') {
+			if (strict) {
+				// leading plus is not allowed in strict mode
+				return false;
+			}
+			start_pos = 1;
+		} else {
+			start_pos = 0;
+		}
+	}
 	idx_t pos = start_pos;
 	while (pos < len) {
 		if (!StringUtil::CharacterIsDigit(buf[pos])) {
 			// not a digit!
-			if (buf[pos] == '.') {
+			if (buf[pos] == decimal_separator) {
 				if (strict) {
 					return false;
 				}
@@ -932,11 +946,13 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 					ExponentData exponent {0, false};
 					int negative = buf[pos] == '-';
 					if (negative) {
-						if (!IntegerCastLoop<ExponentData, true, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<ExponentData, true, false, IntegerCastOperation>(buf + pos, len - pos,
+						                                                                      exponent, strict)) {
 							return false;
 						}
 					} else {
-						if (!IntegerCastLoop<ExponentData, false, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<ExponentData, false, false, IntegerCastOperation>(buf + pos, len - pos,
+						                                                                       exponent, strict)) {
 							return false;
 						}
 					}
@@ -1024,7 +1040,7 @@ static bool IntegerBinaryCastLoop(const char *buf, idx_t len, T &result, bool st
 }
 
 template <class T, bool IS_SIGNED = true, bool ALLOW_EXPONENT = true, class OP = IntegerCastOperation,
-          bool ZERO_INITIALIZE = true>
+          bool ZERO_INITIALIZE = true, char decimal_separator = '.'>
 static bool TryIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
 	// skip any spaces at the start
 	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
@@ -1048,24 +1064,25 @@ static bool TryIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
 				}
 			}
 		}
-		return IntegerCastLoop<T, true, ALLOW_EXPONENT, OP>(buf, len, result, strict);
-	}
-	// If it starts with 0x or 0X, we parse it as a hex value
-	else if (len > 1 && *buf == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
-		// Skip the 0x
-		buf++;
-		len--;
-		return IntegerHexCastLoop<T, false, false, OP>(buf, len, result, strict);
-	}
-	// If it starts with 0b or 0B, we parse it as a binary value
-	else if (len > 1 && *buf == '0' && (buf[1] == 'b' || buf[1] == 'B')) {
-		// Skip the 0b
-		buf++;
-		len--;
-		return IntegerBinaryCastLoop<T, false, false, OP>(buf, len, result, strict);
-	} else {
-		return IntegerCastLoop<T, false, ALLOW_EXPONENT, OP>(buf, len, result, strict);
+		return IntegerCastLoop<T, true, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
+	}
+	if (len > 1 && *buf == '0') {
+		if (buf[1] == 'x' || buf[1] == 'X') {
+			// If it starts with 0x or 0X, we parse it as a hex value
+			buf++;
+			len--;
+			return IntegerHexCastLoop<T, false, false, OP>(buf, len, result, strict);
+		} else if (buf[1] == 'b' || buf[1] == 'B') {
+			// If it starts with 0b or 0B, we parse it as a binary value
+			buf++;
+			len--;
+			return IntegerBinaryCastLoop<T, false, false, OP>(buf, len, result, strict);
+		} else if (strict && StringUtil::CharacterIsDigit(buf[1])) {
+			// leading zeros are not allowed in strict mode
+			return false;
+		}
 	}
+	return IntegerCastLoop<T, false, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
 }
 
 template <typename T, bool IS_SIGNED = true>
@@ -1156,7 +1173,7 @@ bool TryCast::Operation(string_t input, uint64_t &result, bool strict) {
 	return TrySimpleIntegerCast<uint64_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
 }
 
-template <class T>
+template <class T, char decimal_separator = '.'>
 static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
 	// skip any spaces at the start
 	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
@@ -1167,11 +1184,21 @@ static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
 		return false;
 	}
 	if (*buf == '+') {
+		if (strict) {
+			// plus is not allowed in strict mode
+			return false;
+		}
 		buf++;
 		len--;
 	}
+	if (strict && len >= 2) {
+		if (buf[0] == '0' && StringUtil::CharacterIsDigit(buf[1])) {
+			// leading zeros are not allowed in strict mode
+			return false;
+		}
+	}
 	auto endptr = buf + len;
-	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result);
+	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result, decimal_separator);
 	if (parse_result.ec != std::errc()) {
 		return false;
 	}
@@ -1194,6 +1221,26 @@ bool TryCast::Operation(string_t input, double &result, bool strict) {
 	return TryDoubleCast<double>(input.GetDataUnsafe(), input.GetSize(), result, strict);
 }
 
+template <>
+bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message, bool strict) {
+	if (!TryDoubleCast<float, ','>(input.GetDataUnsafe(), input.GetSize(), result, strict)) {
+		HandleCastError::AssignError(StringUtil::Format("Could not cast string to float: \"%s\"", input.GetString()),
+		                             error_message);
+		return false;
+	}
+	return true;
+}
+
+template <>
+bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message, bool strict) {
+	if (!TryDoubleCast<double, ','>(input.GetDataUnsafe(), input.GetSize(), result, strict)) {
+		HandleCastError::AssignError(StringUtil::Format("Could not cast string to double: \"%s\"", input.GetString()),
+		                             error_message);
+		return false;
+	}
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From Date
 //===--------------------------------------------------------------------===//
@@ -1374,6 +1421,21 @@ string_t CastFromBlob::Operation(string_t input, Vector &vector) {
 	string_t result = StringVector::EmptyString(vector, result_size);
 	Blob::ToString(input, result.GetDataWriteable());
 	result.Finalize();
+
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// Cast From Bit
+//===--------------------------------------------------------------------===//
+template <>
+string_t CastFromBit::Operation(string_t input, Vector &vector) {
+
+	idx_t result_size = Bit::BitLength(input);
+	string_t result = StringVector::EmptyString(vector, result_size);
+	Bit::ToString(input, result.GetDataWriteable());
+	result.Finalize();
+
 	return result;
 }
 
@@ -1403,6 +1465,23 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 	return true;
 }
 
+//===--------------------------------------------------------------------===//
+// Cast To Bit
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
+                             bool strict) {
+	idx_t result_size;
+	if (!Bit::TryGetBitStringSize(input, result_size, error_message)) {
+		return false;
+	}
+
+	result = StringVector::EmptyString(result_vector, result_size);
+	Bit::ToBit(input, (data_ptr_t)result.GetDataWriteable());
+	result.Finalize();
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From UUID
 //===--------------------------------------------------------------------===//
@@ -1818,7 +1897,7 @@ struct DecimalCastOperation {
 	}
 };
 
-template <class T>
+template <class T, char decimal_separator = '.'>
 bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint8_t width, uint8_t scale) {
 	DecimalCastData<T> state;
 	state.result = 0;
@@ -1830,8 +1909,8 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint
 	state.exponent_type = DecimalCastData<T>::ExponentType::NONE;
 	state.round_set = false;
 	state.should_round = false;
-	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false>(input.GetDataUnsafe(),
-	                                                                                 input.GetSize(), state, false)) {
+	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
+	        input.GetDataUnsafe(), input.GetSize(), state, false)) {
 		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(),
 		                                  (int)width, (int)scale);
 		HandleCastError::AssignError(error, error_message);
@@ -1862,6 +1941,30 @@ bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *erro
 	return TryDecimalStringCast<hugeint_t>(input, result, error_message, width, scale);
 }
 
+template <>
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int16_t &result, string *error_message, uint8_t width,
+                                               uint8_t scale) {
+	return TryDecimalStringCast<int16_t, ','>(input, result, error_message, width, scale);
+}
+
+template <>
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int32_t &result, string *error_message, uint8_t width,
+                                               uint8_t scale) {
+	return TryDecimalStringCast<int32_t, ','>(input, result, error_message, width, scale);
+}
+
+template <>
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, int64_t &result, string *error_message, uint8_t width,
+                                               uint8_t scale) {
+	return TryDecimalStringCast<int64_t, ','>(input, result, error_message, width, scale);
+}
+
+template <>
+bool TryCastToDecimalCommaSeparated::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
+                                               uint8_t scale) {
+	return TryDecimalStringCast<hugeint_t, ','>(input, result, error_message, width, scale);
+}
+
 template <>
 string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result) {
 	return DecimalToString::Format<int16_t, uint16_t>(input, width, scale, result);