duckdb 0.8.2-dev157.0 → 0.8.2-dev1573.0

package/src/duckdb/src/include/duckdb/common/enums/cte_materialize.hpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/cte_materialize.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class CTEMaterialize : uint8_t {
+	CTE_MATERIALIZE_DEFAULT = 1, /* no option specified */
+	CTE_MATERIALIZE_ALWAYS = 2,  /* MATERIALIZED */
+	CTE_MATERIALIZE_NEVER = 3    /* NOT MATERIALIZED */
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp

@@ -20,7 +20,8 @@ enum class JoinRefType : uint8_t {
 	NATURAL,    // Implied conditions
 	CROSS,      // No condition
 	POSITIONAL, // Positional condition
-	ASOF        // AsOf conditions
+	ASOF,       // AsOf conditions
+	DEPENDENT,  // Dependent join conditions
 };
 
 const char *ToString(JoinRefType value);

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -51,6 +51,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_CROSS_PRODUCT = 54,
 	LOGICAL_POSITIONAL_JOIN = 55,
 	LOGICAL_ASOF_JOIN = 56,
+	LOGICAL_DEPENDENT_JOIN = 57,
 	// -----------------------------
 	// SetOps
 	// -----------------------------
@@ -58,6 +59,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_EXCEPT = 76,
 	LOGICAL_INTERSECT = 77,
 	LOGICAL_RECURSIVE_CTE = 78,
+	LOGICAL_MATERIALIZED_CTE = 79,
 
 	// -----------------------------
 	// Updates

package/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp

@@ -28,6 +28,8 @@ enum class OptimizerType : uint32_t {
 	COMMON_AGGREGATE,
 	COLUMN_LIFETIME,
 	TOP_N,
+	COMPRESSED_MATERIALIZATION,
+	DUPLICATE_GROUPS,
 	REORDER_FILTER,
 	EXTENSION
 };

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -45,6 +45,7 @@ enum class PhysicalOperatorType : uint8_t {
 	COLUMN_DATA_SCAN,
 	CHUNK_SCAN,
 	RECURSIVE_CTE_SCAN,
+	CTE_SCAN,
 	DELIM_SCAN,
 	EXPRESSION_SCAN,
 	POSITIONAL_SCAN,
@@ -66,6 +67,7 @@ enum class PhysicalOperatorType : uint8_t {
 	// -----------------------------
 	UNION,
 	RECURSIVE_CTE,
+	CTE,
 
 	// -----------------------------
 	// Updates

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/extra_operator_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include "duckdb/common/operator/comparison_operators.hpp"
+
+namespace duckdb {
+
+class ExtraOperatorInfo {
+public:
+	ExtraOperatorInfo() : file_filters("") {
+	}
+	ExtraOperatorInfo(ExtraOperatorInfo &extra_info) : file_filters(extra_info.file_filters) {
+	}
+	string file_filters;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,219 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/extra_type_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/types/vector.hpp"
+
+namespace duckdb {
+
+class FieldReader;
+
+//! Extra Type Info Type
+enum class ExtraTypeInfoType : uint8_t {
+	INVALID_TYPE_INFO = 0,
+	GENERIC_TYPE_INFO = 1,
+	DECIMAL_TYPE_INFO = 2,
+	STRING_TYPE_INFO = 3,
+	LIST_TYPE_INFO = 4,
+	STRUCT_TYPE_INFO = 5,
+	ENUM_TYPE_INFO = 6,
+	USER_TYPE_INFO = 7,
+	AGGREGATE_STATE_TYPE_INFO = 8
+};
+
+struct ExtraTypeInfo {
+	explicit ExtraTypeInfo(ExtraTypeInfoType type);
+	explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias);
+	virtual ~ExtraTypeInfo();
+
+	ExtraTypeInfoType type;
+	string alias;
+	optional_ptr<TypeCatalogEntry> catalog_entry;
+
+public:
+	bool Equals(ExtraTypeInfo *other_p) const;
+	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
+	virtual void Serialize(FieldWriter &writer) const;
+	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
+	static void Serialize(ExtraTypeInfo *info, FieldWriter &writer);
+	//! Deserializes a blob back into an ExtraTypeInfo
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
+protected:
+	virtual bool EqualsInternal(ExtraTypeInfo *other_p) const;
+};
+
+struct DecimalTypeInfo : public ExtraTypeInfo {
+	DecimalTypeInfo(uint8_t width_p, uint8_t scale_p);
+
+	uint8_t width;
+	uint8_t scale;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	DecimalTypeInfo();
+};
+
+struct StringTypeInfo : public ExtraTypeInfo {
+	explicit StringTypeInfo(string collation_p);
+
+	string collation;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	StringTypeInfo();
+};
+
+struct ListTypeInfo : public ExtraTypeInfo {
+	explicit ListTypeInfo(LogicalType child_type_p);
+
+	LogicalType child_type;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	ListTypeInfo();
+};
+
+struct StructTypeInfo : public ExtraTypeInfo {
+	explicit StructTypeInfo(child_list_t<LogicalType> child_types_p);
+
+	child_list_t<LogicalType> child_types;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	StructTypeInfo();
+};
+
+struct AggregateStateTypeInfo : public ExtraTypeInfo {
+	explicit AggregateStateTypeInfo(aggregate_state_t state_type_p);
+
+	aggregate_state_t state_type;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	AggregateStateTypeInfo();
+};
+
+struct UserTypeInfo : public ExtraTypeInfo {
+	explicit UserTypeInfo(string name_p);
+
+	string user_type_name;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+
+protected:
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+private:
+	UserTypeInfo();
+};
+
+// If this type is primarily stored in the catalog or not. Enums from Pandas/Factors are not in the catalog.
+enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 };
+
+struct EnumTypeInfo : public ExtraTypeInfo {
+	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p);
+	EnumTypeInfo(const EnumTypeInfo &) = delete;
+	EnumTypeInfo &operator=(const EnumTypeInfo &) = delete;
+
+public:
+	const EnumDictType &GetEnumDictType() const;
+	const string &GetEnumName() const;
+	const string GetSchemaName() const;
+	const Vector &GetValuesInsertOrder() const;
+	const idx_t &GetDictSize() const;
+	static PhysicalType DictType(idx_t size);
+
+	static LogicalType CreateType(const string &enum_name, Vector &ordered_data, idx_t size);
+
+	void Serialize(FieldWriter &writer) const override;
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
+
+protected:
+	// Equalities are only used in enums with different catalog entries
+	bool EqualsInternal(ExtraTypeInfo *other_p) const override;
+
+	Vector values_insert_order;
+
+private:
+	EnumDictType dict_type;
+	string enum_name;
+	idx_t dict_size;
+};
+
+} // namespace duckdb

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

@@ -246,6 +246,8 @@ public:
 
 	//! Whether or not a file is remote or local, based only on file path
 	DUCKDB_API static bool IsRemoteFile(const string &path);
+
+	DUCKDB_API virtual void SetDisabledFileSystems(const vector<string> &names);
 };
 
 } // namespace duckdb

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

@@ -31,7 +31,7 @@ public:
 	//! evaluate to true.
 	DUCKDB_API static void 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);
 
 	//! Returns the compiled regex pattern to match hive partitions

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

@@ -87,7 +87,8 @@ struct MultiFileReader {
 	DUCKDB_API static vector<string> GetFileList(ClientContext &context, const Value &input, const string &name,
 	                                             FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
 	//! Parse the named parameters of a multi-file reader
-	DUCKDB_API static bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options);
+	DUCKDB_API static bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options,
+	                                   ClientContext &context);
 	//! Perform complex filter pushdown into the multi-file reader, potentially filtering out files that should be read
 	//! If "true" the first file has been eliminated
 	DUCKDB_API static bool ComplexFilterPushdown(ClientContext &context, vector<string> &files,
@@ -102,7 +103,7 @@ struct MultiFileReader {
 	                                    const MultiFileReaderBindData &options, const string &filename,
 	                                    const vector<string> &local_names, const vector<LogicalType> &global_types,
 	                                    const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                                    MultiFileReaderData &reader_data);
+	                                    MultiFileReaderData &reader_data, ClientContext &context);
 	//! Create all required mappings from the global types/names to the file-local types/names
 	DUCKDB_API static void CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
 	                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
@@ -157,9 +158,10 @@ struct MultiFileReader {
 	static void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options,
 	                             const MultiFileReaderBindData &bind_data, const vector<LogicalType> &global_types,
 	                             const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                             optional_ptr<TableFilterSet> table_filters, const string &initial_file) {
+	                             optional_ptr<TableFilterSet> table_filters, const string &initial_file,
+	                             ClientContext &context) {
 		FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetNames(), global_types, global_names,
-		             global_column_ids, reader.reader_data);
+		             global_column_ids, reader.reader_data, context);
 		CreateMapping(reader.GetFileName(), reader.GetTypes(), reader.GetNames(), global_types, global_names,
 		              global_column_ids, table_filters, reader.reader_data, initial_file);
 		reader.reader_data.filters = table_filters;

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

@@ -9,8 +9,9 @@
 #pragma once
 
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/hive_partitioning.hpp"
-#include "re2/re2.h"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 class Serializer;
@@ -22,51 +23,18 @@ struct MultiFileReaderOptions {
 	bool hive_partitioning = false;
 	bool auto_detect_hive_partitioning = true;
 	bool union_by_name = false;
+	bool hive_types_autocast = true;
+	case_insensitive_map_t<LogicalType> hive_types_schema;
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
-
-	static bool AutoDetectHivePartitioning(const vector<string> &files) {
-		if (files.empty()) {
-			return false;
-		}
-
-		std::unordered_set<string> uset;
-		idx_t splits_size;
-		{
-			//	front file
-			auto splits = StringUtil::Split(files.front(), FileSystem::PathSeparator());
-			splits_size = splits.size();
-			if (splits.size() < 2) {
-				return false;
-			}
-			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
-				auto part = StringUtil::Split(*it, "=");
-				if (part.size() == 2) {
-					uset.insert(part.front());
-				}
-			}
-		}
-		if (uset.empty()) {
-			return false;
-		}
-		for (auto &file : files) {
-			auto splits = StringUtil::Split(file, FileSystem::PathSeparator());
-			if (splits.size() != splits_size) {
-				return false;
-			}
-			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
-				auto part = StringUtil::Split(*it, "=");
-				if (part.size() == 2) {
-					if (uset.find(part.front()) == uset.end()) {
-						return false;
-					}
-				}
-			}
-		}
-		return true;
-	}
+	DUCKDB_API void AutoDetectHivePartitioning(const vector<string> &files, ClientContext &context);
+	DUCKDB_API static bool AutoDetectHivePartitioningInternal(const vector<string> &files);
+	DUCKDB_API void AutoDetectHiveTypesInternal(const string &file, ClientContext &context);
+	DUCKDB_API void VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const;
+	DUCKDB_API LogicalType GetHiveLogicalType(const string &hive_partition_column) const;
+	DUCKDB_API Value GetHivePartitionValue(const string &base, const string &entry, ClientContext &context) const;
 };
 
 } // namespace duckdb

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

@@ -8,6 +8,9 @@
 
 #pragma once
 
+#ifdef __MVS__
+#include <time.h>
+#endif
 #include <mutex>
 
 namespace duckdb {

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

@@ -8,13 +8,18 @@
 
 #pragma once
 
+#include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/operator/convert_to_string.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/common/types/vector.hpp"
 
 namespace duckdb {
 struct ValidityMask;
@@ -652,6 +657,15 @@ struct CastFromBlob {
 template <>
 duckdb::string_t CastFromBlob::Operation(duckdb::string_t input, Vector &vector);
 
+struct CastFromBlobToBit {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		throw NotImplementedException("Cast from blob could not be performed!");
+	}
+};
+template <>
+string_t CastFromBlobToBit::Operation(string_t input, Vector &result);
+
 struct TryCastToBlob {
 	template <class SRC, class DST>
 	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
@@ -659,7 +673,6 @@ struct TryCastToBlob {
 		throw InternalException("Unsupported type for try cast to blob");
 	}
 };
-
 template <>
 bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
                               bool strict);
@@ -667,14 +680,41 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 //===--------------------------------------------------------------------===//
 // Bits
 //===--------------------------------------------------------------------===//
-struct CastFromBit {
+struct CastFromBitToString {
 	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);
+duckdb::string_t CastFromBitToString::Operation(duckdb::string_t input, Vector &vector);
+
+struct CastFromBitToNumeric {
+	template <class SRC = string_t, class DST>
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
+		D_ASSERT(input.GetSize() > 1);
+
+		// TODO: Allow conversion if the significant bytes of the bitstring can be cast to the target type
+		// Currently only allows bitstring -> numeric if the full bitstring fits inside the numeric type
+		if (input.GetSize() - 1 > sizeof(DST)) {
+			throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<DST>());
+		}
+		Bit::BitToNumeric(input, result);
+		return (true);
+	}
+};
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict);
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict);
+
+struct CastFromBitToBlob {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		D_ASSERT(input.GetSize() > 1);
+		return StringVector::AddStringOrBlob(result, Bit::BitToBlob(input));
+	}
+};
 
 struct TryCastToBit {
 	template <class SRC, class DST>

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

@@ -9,8 +9,11 @@
 #pragma once
 
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/common/types/vector.hpp"
 #include <cmath>
 
 namespace duckdb {
@@ -442,6 +445,13 @@ bool TryCastWithOverflowCheck(hugeint_t value, double &result) {
 	return Hugeint::TryCast(value, result);
 }
 
+struct NumericTryCastToBit {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		return StringVector::AddStringOrBlob(result, Bit::NumericToBit(input));
+	}
+};
+
 struct NumericTryCast {
 	template <class SRC, class DST>
 	static inline bool Operation(SRC input, DST &result, bool strict = false) {

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/bswap.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types.hpp"
@@ -20,18 +21,6 @@
 
 namespace duckdb {
 
-#define BSWAP16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8)))
-
-#define BSWAP32(x)                                                                                                     \
-	((uint32_t)((((uint32_t)(x)&0xff000000) >> 24) | (((uint32_t)(x)&0x00ff0000) >> 8) |                               \
-	            (((uint32_t)(x)&0x0000ff00) << 8) | (((uint32_t)(x)&0x000000ff) << 24)))
-
-#define BSWAP64(x)                                                                                                     \
-	((uint64_t)((((uint64_t)(x)&0xff00000000000000ull) >> 56) | (((uint64_t)(x)&0x00ff000000000000ull) >> 40) |        \
-	            (((uint64_t)(x)&0x0000ff0000000000ull) >> 24) | (((uint64_t)(x)&0x000000ff00000000ull) >> 8) |         \
-	            (((uint64_t)(x)&0x00000000ff000000ull) << 8) | (((uint64_t)(x)&0x0000000000ff0000ull) << 24) |         \
-	            (((uint64_t)(x)&0x000000000000ff00ull) << 40) | (((uint64_t)(x)&0x00000000000000ffull) << 56)))
-
 struct Radix {
 public:
 	static inline bool IsLittleEndian() {
@@ -134,19 +123,19 @@ inline void Radix::EncodeData(data_ptr_t dataptr, int8_t value) {
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, int16_t value) {
-	Store<uint16_t>(BSWAP16(value), dataptr);
+	Store<uint16_t>(BSwap<uint16_t>(value), dataptr);
 	dataptr[0] = FlipSign(dataptr[0]);
 }
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, int32_t value) {
-	Store<uint32_t>(BSWAP32(value), dataptr);
+	Store<uint32_t>(BSwap<uint32_t>(value), dataptr);
 	dataptr[0] = FlipSign(dataptr[0]);
 }
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, int64_t value) {
-	Store<uint64_t>(BSWAP64(value), dataptr);
+	Store<uint64_t>(BSwap<uint64_t>(value), dataptr);
 	dataptr[0] = FlipSign(dataptr[0]);
 }
 
@@ -157,17 +146,17 @@ inline void Radix::EncodeData(data_ptr_t dataptr, uint8_t value) {
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, uint16_t value) {
-	Store<uint16_t>(BSWAP16(value), dataptr);
+	Store<uint16_t>(BSwap<uint16_t>(value), dataptr);
 }
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, uint32_t value) {
-	Store<uint32_t>(BSWAP32(value), dataptr);
+	Store<uint32_t>(BSwap<uint32_t>(value), dataptr);
 }
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, uint64_t value) {
-	Store<uint64_t>(BSWAP64(value), dataptr);
+	Store<uint64_t>(BSwap<uint64_t>(value), dataptr);
 }
 
 template <>
@@ -179,13 +168,13 @@ inline void Radix::EncodeData(data_ptr_t dataptr, hugeint_t value) {
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, float value) {
 	uint32_t converted_value = EncodeFloat(value);
-	Store<uint32_t>(BSWAP32(converted_value), dataptr);
+	Store<uint32_t>(BSwap<uint32_t>(converted_value), dataptr);
 }
 
 template <>
 inline void Radix::EncodeData(data_ptr_t dataptr, double value) {
 	uint64_t converted_value = EncodeDouble(value);
-	Store<uint64_t>(BSWAP64(converted_value), dataptr);
+	Store<uint64_t>(BSwap<uint64_t>(converted_value), dataptr);
 }
 
 template <>