duckdb 0.8.2-dev1182.0 → 0.8.2-dev1435.0

package/binding.gyp

@@ -239,18 +239,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
                 "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu_extension.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1182.0",
+  "version": "0.8.2-dev1435.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -175,7 +175,6 @@ public:
 		table_function.serialize = ParquetScanSerialize;
 		table_function.deserialize = ParquetScanDeserialize;
 		table_function.get_batch_info = ParquetGetBatchInfo;
-
 		table_function.projection_pushdown = true;
 		table_function.filter_pushdown = true;
 		table_function.filter_prune = true;
@@ -520,6 +519,7 @@ public:
 	static void ParquetComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
 	                                         vector<unique_ptr<Expression>> &filters) {
 		auto &data = bind_data_p->Cast<ParquetReadBindData>();
+
 		auto reset_reader = MultiFileReader::ComplexFilterPushdown(context, data.files,
 		                                                           data.parquet_options.file_options, get, filters);
 		if (reset_reader) {

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -76,7 +76,7 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	}
 	// read four-byte footer length from just before the end magic bytes
 	auto footer_len = *reinterpret_cast<uint32_t *>(buf.ptr);
-	if (footer_len <= 0 || file_size < 12 + footer_len) {
+	if (footer_len == 0 || file_size < 12 + footer_len) {
 		throw InvalidInputException("Footer length error in file '%s'", file_handle.path);
 	}
 	auto metadata_pos = file_size - (footer_len + 8);

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -786,7 +786,6 @@ ArrowArray ArrowAppender::Finalize() {
 
 	// Configure root array
 	result.length = row_count;
-	result.n_children = types.size();
 	result.n_buffers = 1;
 	result.buffers = root_holder->buffers.data(); // there is no actual buffer there since we don't have NULLs
 	result.offset = 0;

package/src/duckdb/src/common/exception.cpp

@@ -62,11 +62,11 @@ string Exception::ConstructMessageRecursive(const string &msg, std::vector<Excep
 #ifdef DEBUG
 	// Verify that we have the required amount of values for the message
 	idx_t parameter_count = 0;
-	for (idx_t i = 0; i < msg.size(); i++) {
+	for (idx_t i = 0; i + 1 < msg.size(); i++) {
 		if (msg[i] != '%') {
 			continue;
 		}
-		if (i < msg.size() && msg[i + 1] == '%') {
+		if (msg[i + 1] == '%') {
 			i++;
 			continue;
 		}

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

@@ -385,6 +385,10 @@ void FileSystem::UnregisterSubSystem(const string &name) {
 	throw NotImplementedException("%s: Can't unregister a sub system on a non-virtual file system", GetName());
 }
 
+void FileSystem::SetDisabledFileSystems(const vector<string> &names) {
+	throw NotImplementedException("%s: Can't disable file systems 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());
 }

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

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "re2/re2.h"
 
@@ -86,12 +87,15 @@ std::map<string, string> HivePartitioning::Parse(const string &filename) {
 //		 currently, only expressions that cannot be evaluated during pushdown are removed.
 void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<string> &files,
                                               vector<unique_ptr<Expression>> &filters,
-                                              unordered_map<string, column_t> &column_map, idx_t table_index,
+                                              unordered_map<string, column_t> &column_map, LogicalGet &get,
                                               bool hive_enabled, bool filename_enabled) {
+
 	vector<string> pruned_files;
 	vector<bool> have_preserved_filter(filters.size(), false);
 	vector<unique_ptr<Expression>> pruned_filters;
+	unordered_set<idx_t> filters_applied_to_files;
 	duckdb_re2::RE2 regex(REGEX_STRING);
+	auto table_index = get.table_index;
 
 	if ((!filename_enabled && !hive_enabled) || filters.empty()) {
 		return;
@@ -121,11 +125,11 @@ void HivePartitioning::ApplyFiltersToFileList(ClientContext &context, vector<str
 			} else if (!result_value.GetValue<bool>()) {
 				// filter evaluates to false
 				should_prune_file = true;
-			}
-
-			// Use filter combiner to determine that this filter makes
-			if (!should_prune_file && combiner.AddFilter(std::move(filter_copy)) == FilterResult::UNSATISFIABLE) {
-				should_prune_file = true;
+				// convert the filter to a table filter.
+				if (filters_applied_to_files.find(j) == filters_applied_to_files.end()) {
+					get.extra_info.file_filters += filter->ToString();
+					filters_applied_to_files.insert(j);
+				}
 			}
 		}
 

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

@@ -375,7 +375,7 @@ int RemoveDirectoryRecursive(const char *path) {
 				continue;
 			}
 			len = path_len + (idx_t)strlen(p->d_name) + 2;
-			buf = new char[len];
+			buf = new (std::nothrow) char[len];
 			if (buf) {
 				struct stat statbuf;
 				snprintf(buf, len, "%s/%s", path, p->d_name);

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -106,8 +106,9 @@ bool MultiFileReader::ComplexFilterPushdown(ClientContext &context, vector<strin
 	}
 
 	auto start_files = files.size();
-	HivePartitioning::ApplyFiltersToFileList(context, files, filters, column_map, get.table_index,
-	                                         options.hive_partitioning, options.filename);
+	HivePartitioning::ApplyFiltersToFileList(context, files, filters, column_map, get, options.hive_partitioning,
+	                                         options.filename);
+
 	if (files.size() != start_files) {
 		// we have pruned files
 		return true;

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/operator/string_cast.hpp"
 #include "duckdb/common/operator/numeric_cast.hpp"
 #include "duckdb/common/operator/decimal_cast_operators.hpp"
@@ -1425,11 +1426,20 @@ string_t CastFromBlob::Operation(string_t input, Vector &vector) {
 	return result;
 }
 
+template <>
+string_t CastFromBlobToBit::Operation(string_t input, Vector &vector) {
+	idx_t result_size = input.GetSize() + 1;
+	if (result_size <= 1) {
+		throw ConversionException("Cannot cast empty BLOB to BIT");
+	}
+	return StringVector::AddStringOrBlob(vector, Bit::BlobToBit(input));
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From Bit
 //===--------------------------------------------------------------------===//
 template <>
-string_t CastFromBit::Operation(string_t input, Vector &vector) {
+string_t CastFromBitToString::Operation(string_t input, Vector &vector) {
 
 	idx_t result_size = Bit::BitLength(input);
 	string_t result = StringVector::EmptyString(vector, result_size);
@@ -1482,6 +1492,30 @@ bool TryCastToBit::Operation(string_t input, string_t &result, Vector &result_ve
 	return true;
 }
 
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict) {
+	D_ASSERT(input.GetSize() > 1);
+
+	uint8_t value;
+	bool success = CastFromBitToNumeric::Operation(input, value, strict);
+	result = (value > 0);
+	return (success);
+}
+
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict) {
+	D_ASSERT(input.GetSize() > 1);
+
+	if (input.GetSize() - 1 > sizeof(hugeint_t)) {
+		throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<hugeint_t>());
+	}
+	Bit::BitToNumeric(input, result);
+	if (result < NumericLimits<hugeint_t>::Minimum()) {
+		throw ConversionException("Minimum limit for HUGEINT is %s", NumericLimits<hugeint_t>::Minimum().ToString());
+	}
+	return (true);
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From UUID
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/re2_regex.cpp

@@ -54,7 +54,7 @@ duckdb::vector<Match> RegexFindAll(const std::string &input, const Regex &regex)
 	Match match;
 	while (RegexSearchInternal(input.c_str(), match, regex, RE2::UNANCHORED, position, input.size())) {
 		position += match.position(0) + match.length(0);
-		matches.emplace_back(std::move(match));
+		matches.emplace_back(match);
 	}
 	return matches;
 }

package/src/duckdb/src/common/types/bit.cpp

@@ -1,4 +1,6 @@
+#include "duckdb/common/assert.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/string_type.hpp"
 
@@ -34,6 +36,13 @@ static inline idx_t GetBitSize(const string_t &str) {
 	return str_len;
 }
 
+uint8_t Bit::GetFirstByte(const string_t &str) {
+	D_ASSERT(str.GetSize() > 1);
+
+	auto data = const_data_ptr_cast(str.GetData());
+	return data[1] & ((1 << (8 - data[0])) - 1);
+}
+
 void Bit::Finalize(string_t &str) {
 	// bit strings require all padding bits to be set to 1
 	// this method sets all padding bits to 1
@@ -146,6 +155,48 @@ string Bit::ToBit(string_t str) {
 	return output_str.GetString();
 }
 
+void Bit::BlobToBit(string_t blob, string_t &output_str) {
+	auto data = const_data_ptr_cast(blob.GetData());
+	auto output = output_str.GetDataWriteable();
+	idx_t size = blob.GetSize();
+
+	*output = 0; // No padding
+	memcpy(output + 1, data, size);
+}
+
+string Bit::BlobToBit(string_t blob) {
+	auto buffer = make_unsafe_uniq_array<char>(blob.GetSize() + 1);
+	string_t output_str(buffer.get(), blob.GetSize() + 1);
+	Bit::BlobToBit(blob, output_str);
+	return output_str.GetString();
+}
+
+void Bit::BitToBlob(string_t bit, string_t &output_blob) {
+	D_ASSERT(bit.GetSize() == output_blob.GetSize() + 1);
+
+	auto data = const_data_ptr_cast(bit.GetData());
+	auto output = output_blob.GetDataWriteable();
+	idx_t size = output_blob.GetSize();
+
+	output[0] = GetFirstByte(bit);
+	if (size > 2) {
+		++output;
+		// First byte in bitstring contains amount of padded bits,
+		// second byte in bitstring is the padded byte,
+		// therefore the rest of the data starts at data + 2 (third byte)
+		memcpy(output, data + 2, size - 1);
+	}
+}
+
+string Bit::BitToBlob(string_t bit) {
+	D_ASSERT(bit.GetSize() > 1);
+
+	auto buffer = make_unsafe_uniq_array<char>(bit.GetSize() - 1);
+	string_t output_str(buffer.get(), bit.GetSize() - 1);
+	Bit::BitToBlob(bit, output_str);
+	return output_str.GetString();
+}
+
 // **** scalar functions ****
 void Bit::BitString(const string_t &input, const idx_t &bit_length, string_t &result) {
 	char *res_buf = result.GetDataWriteable();

package/src/duckdb/src/common/types/uuid.cpp

@@ -49,7 +49,7 @@ bool UUID::FromString(string str, hugeint_t &result) {
 		count++;
 	}
 	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-	result.upper ^= (int64_t(1) << 63);
+	result.upper ^= (uint64_t(1) << 63);
 	return count == 32;
 }
 
@@ -61,7 +61,7 @@ void UUID::ToString(hugeint_t input, char *buf) {
 	};
 
 	// Flip back before convert to string
-	int64_t upper = input.upper ^ (int64_t(1) << 63);
+	int64_t upper = input.upper ^ (uint64_t(1) << 63);
 	idx_t pos = 0;
 	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
 	byte_to_hex(upper >> 48 & 0xFF, buf, pos);

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -28,7 +28,7 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 		}
 	}
 	// open the base file handle
-	auto file_handle = FindFileSystem(path)->OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
+	auto file_handle = FindFileSystem(path).OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
 	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
 		file_handle = PipeFileSystem::OpenPipe(std::move(file_handle));
 	} else if (compression != FileCompressionType::UNCOMPRESSED) {
@@ -42,4 +42,141 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 	return file_handle;
 }
 
+void VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
+	handle.file_system.Read(handle, buffer, nr_bytes, location);
+}
+
+void VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
+	handle.file_system.Write(handle, buffer, nr_bytes, location);
+}
+
+int64_t VirtualFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
+	return handle.file_system.Read(handle, buffer, nr_bytes);
+}
+
+int64_t VirtualFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
+	return handle.file_system.Write(handle, buffer, nr_bytes);
+}
+
+int64_t VirtualFileSystem::GetFileSize(FileHandle &handle) {
+	return handle.file_system.GetFileSize(handle);
+}
+time_t VirtualFileSystem::GetLastModifiedTime(FileHandle &handle) {
+	return handle.file_system.GetLastModifiedTime(handle);
+}
+FileType VirtualFileSystem::GetFileType(FileHandle &handle) {
+	return handle.file_system.GetFileType(handle);
+}
+
+void VirtualFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
+	handle.file_system.Truncate(handle, new_size);
+}
+
+void VirtualFileSystem::FileSync(FileHandle &handle) {
+	handle.file_system.FileSync(handle);
+}
+
+// need to look up correct fs for this
+bool VirtualFileSystem::DirectoryExists(const string &directory) {
+	return FindFileSystem(directory).DirectoryExists(directory);
+}
+void VirtualFileSystem::CreateDirectory(const string &directory) {
+	FindFileSystem(directory).CreateDirectory(directory);
+}
+
+void VirtualFileSystem::RemoveDirectory(const string &directory) {
+	FindFileSystem(directory).RemoveDirectory(directory);
+}
+
+bool VirtualFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+                                  FileOpener *opener) {
+	return FindFileSystem(directory).ListFiles(directory, callback, opener);
+}
+
+void VirtualFileSystem::MoveFile(const string &source, const string &target) {
+	FindFileSystem(source).MoveFile(source, target);
+}
+
+bool VirtualFileSystem::FileExists(const string &filename) {
+	return FindFileSystem(filename).FileExists(filename);
+}
+
+bool VirtualFileSystem::IsPipe(const string &filename) {
+	return FindFileSystem(filename).IsPipe(filename);
+}
+void VirtualFileSystem::RemoveFile(const string &filename) {
+	FindFileSystem(filename).RemoveFile(filename);
+}
+
+vector<string> VirtualFileSystem::Glob(const string &path, FileOpener *opener) {
+	return FindFileSystem(path).Glob(path, opener);
+}
+
+void VirtualFileSystem::RegisterSubSystem(unique_ptr<FileSystem> fs) {
+	sub_systems.push_back(std::move(fs));
+}
+
+void VirtualFileSystem::UnregisterSubSystem(const string &name) {
+	for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) {
+		if (sub_system->get()->GetName() == name) {
+			sub_systems.erase(sub_system);
+			return;
+		}
+	}
+	throw InvalidInputException("Could not find filesystem with name %s", name);
+}
+
+void VirtualFileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) {
+	compressed_fs[compression_type] = std::move(fs);
+}
+
+vector<string> VirtualFileSystem::ListSubSystems() {
+	vector<string> names(sub_systems.size());
+	for (idx_t i = 0; i < sub_systems.size(); i++) {
+		names[i] = sub_systems[i]->GetName();
+	}
+	return names;
+}
+
+std::string VirtualFileSystem::GetName() const {
+	return "VirtualFileSystem";
+}
+
+void VirtualFileSystem::SetDisabledFileSystems(const vector<string> &names) {
+	unordered_set<string> new_disabled_file_systems;
+	for (auto &name : names) {
+		if (name.empty()) {
+			continue;
+		}
+		if (new_disabled_file_systems.find(name) != new_disabled_file_systems.end()) {
+			throw InvalidInputException("Duplicate disabled file system \"%s\"", name);
+		}
+		new_disabled_file_systems.insert(name);
+	}
+	for (auto &disabled_fs : disabled_file_systems) {
+		if (new_disabled_file_systems.find(disabled_fs) == new_disabled_file_systems.end()) {
+			throw InvalidInputException("File system \"%s\" has been disabled previously, it cannot be re-enabled",
+			                            disabled_fs);
+		}
+	}
+	disabled_file_systems = std::move(new_disabled_file_systems);
+}
+
+FileSystem &VirtualFileSystem::FindFileSystem(const string &path) {
+	auto &fs = FindFileSystemInternal(path);
+	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs.GetName()) != disabled_file_systems.end()) {
+		throw PermissionException("File system %s has been disabled by configuration", fs.GetName());
+	}
+	return fs;
+}
+
+FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
+	for (auto &sub_system : sub_systems) {
+		if (sub_system->CanHandleFile(path)) {
+			return *sub_system;
+		}
+	}
+	return *default_fs;
+}
+
 } // namespace duckdb

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -21,8 +21,10 @@ struct ReservoirQuantileState {
 		if (new_len <= len) {
 			return;
 		}
+		T *old_v = v;
 		v = (T *)realloc(v, new_len * sizeof(T));
 		if (!v) {
+			free(old_v);
 			throw InternalException("Memory allocation failure");
 		}
 		len = new_len;

package/src/duckdb/src/core_functions/function_list.cpp

@@ -137,9 +137,9 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(EnumRangeFun),
 	DUCKDB_SCALAR_FUNCTION(EnumRangeBoundaryFun),
 	DUCKDB_SCALAR_FUNCTION_SET(EpochFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochNanosecondsFun),
-	DUCKDB_SCALAR_FUNCTION_SET(EpochMicrosecondsFun),
 	DUCKDB_SCALAR_FUNCTION_SET(EpochMsFun),
+	DUCKDB_SCALAR_FUNCTION_SET(EpochNsFun),
+	DUCKDB_SCALAR_FUNCTION_SET(EpochUsFun),
 	DUCKDB_SCALAR_FUNCTION_SET(EraFun),
 	DUCKDB_SCALAR_FUNCTION(ErrorFun),
 	DUCKDB_SCALAR_FUNCTION(EvenFun),

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -1591,7 +1591,7 @@ ScalarFunctionSet EpochFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::EpochOperator>();
 }
 
-ScalarFunctionSet EpochNanosecondsFun::GetFunctions() {
+ScalarFunctionSet EpochNsFun::GetFunctions() {
 	using OP = DatePart::EpochNanosecondsOperator;
 	auto operator_set = GetTimePartFunction<OP>();
 
@@ -1603,7 +1603,7 @@ ScalarFunctionSet EpochNanosecondsFun::GetFunctions() {
 	return operator_set;
 }
 
-ScalarFunctionSet EpochMicrosecondsFun::GetFunctions() {
+ScalarFunctionSet EpochUsFun::GetFunctions() {
 	using OP = DatePart::EpochMicrosecondsOperator;
 	auto operator_set = GetTimePartFunction<OP>();
 

package/src/duckdb/src/core_functions/scalar/date/epoch.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
+
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 
@@ -9,20 +8,24 @@ namespace duckdb {
 
 struct EpochSecOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return Timestamp::FromEpochSeconds(input);
+	static RESULT_TYPE Operation(INPUT_TYPE sec) {
+		int64_t result;
+		if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
+			throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE");
+		}
+		return timestamp_t(result);
 	}
 };
 
 static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
-	UnaryExecutor::Execute<int64_t, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
+	UnaryExecutor::Execute<double, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
 }
 
 ScalarFunction ToTimestampFun::GetFunction() {
 	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochSecFunction);
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/expression_executor.cpp

@@ -126,7 +126,7 @@ bool ExpressionExecutor::TryEvaluateScalar(ClientContext &context, const Express
 		result = EvaluateScalar(context, expr);
 		return true;
 	} catch (InternalException &ex) {
-		throw ex;
+		throw;
 	} catch (...) {
 		return false;
 	}

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -395,15 +395,15 @@ struct WindowColumnIterator {
 		return coll->GetCell<T>(pos + m);
 	}
 
-	friend inline iterator &operator+(const iterator &a, difference_type n) {
+	friend inline iterator operator+(const iterator &a, difference_type n) {
 		return iterator(a.coll, a.pos + n);
 	}
 
-	friend inline iterator &operator-(const iterator &a, difference_type n) {
+	friend inline iterator operator-(const iterator &a, difference_type n) {
 		return iterator(a.coll, a.pos - n);
 	}
 
-	friend inline iterator &operator+(difference_type n, const iterator &a) {
+	friend inline iterator operator+(difference_type n, const iterator &a) {
 		return a + n;
 	}
 	friend inline difference_type operator-(const iterator &a, const iterator &b) {

package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp

@@ -669,7 +669,7 @@ public:
 	//! The read cursor
 	unique_ptr<PayloadScanner> scanner;
 	//! Pointer to the matches
-	const bool *found_match;
+	const bool *found_match = {};
 };
 
 AsOfLocalSourceState::AsOfLocalSourceState(AsOfGlobalSourceState &gsource, const PhysicalAsOfJoin &op)

package/src/duckdb/src/execution/operator/join/physical_range_join.cpp

@@ -167,8 +167,8 @@ PhysicalRangeJoin::PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType t
 	// TODO: use stats to improve the choice?
 	// TODO: Prefer fixed length types?
 	if (conditions.size() > 1) {
-		auto conditions_p = std::move(conditions);
-		conditions.resize(conditions_p.size());
+		vector<JoinCondition> conditions_p(conditions.size());
+		std::swap(conditions_p, conditions);
 		idx_t range_position = 0;
 		idx_t other_position = conditions_p.size();
 		for (idx_t i = 0; i < conditions_p.size(); ++i) {

package/src/duckdb/src/execution/operator/persistent/csv_file_handle.cpp

@@ -13,7 +13,7 @@ CSVFileHandle::CSVFileHandle(FileSystem &fs, Allocator &allocator, unique_ptr<Fi
 
 unique_ptr<FileHandle> CSVFileHandle::OpenFileHandle(FileSystem &fs, Allocator &allocator, const string &path,
                                                      FileCompressionType compression) {
-	auto file_handle = fs.OpenFile(path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression);
+	auto file_handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression);
 	if (file_handle->CanSeek()) {
 		file_handle->Reset();
 	}

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -41,7 +41,7 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry &t
 		return;
 	}
 
-	D_ASSERT(set_expressions.size() == set_columns.size());
+	D_ASSERT(this->set_expressions.size() == this->set_columns.size());
 
 	// One or more columns are referenced from the existing table,
 	// we use the 'insert_types' to figure out which types these columns have