duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -130,14 +130,18 @@ public:
 	DUCKDB_API static Value TIMETZ(dtime_tz_t time);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
-	//! Create a timestamp Value from a specified date/time combination
+	//! Create a timestamp Value from a specified date/time combination.
 	DUCKDB_API static Value TIMESTAMP(date_t date, dtime_t time);
-	//! Create a timestamp Value from a specified timestamp
+	//! Create a timestamp Value from a specified value.
 	DUCKDB_API static Value TIMESTAMP(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPNS(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPMS(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPSEC(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPTZ(timestamp_t timestamp);
+	//! Create a timestamp_s Value from a specified value.
+	DUCKDB_API static Value TIMESTAMPSEC(timestamp_sec_t timestamp);
+	//! Create a timestamp_ms Value from a specified value.
+	DUCKDB_API static Value TIMESTAMPMS(timestamp_ms_t timestamp);
+	//! Create a timestamp_ns Value from a specified value.
+	DUCKDB_API static Value TIMESTAMPNS(timestamp_ns_t timestamp);
+	//! Create a timestamp_tz Value from a specified value.
+	DUCKDB_API static Value TIMESTAMPTZ(timestamp_tz_t timestamp);
 	//! Create a timestamp Value from a specified timestamp in separate values
 	DUCKDB_API static Value TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
 	                                  int32_t micros);
@@ -159,20 +163,13 @@ public:
 	//! Create a struct value with given list of entries
 	DUCKDB_API static Value STRUCT(child_list_t<Value> values);
 	DUCKDB_API static Value STRUCT(const LogicalType &type, vector<Value> struct_values);
-	//! Create a list value with the given entries, list type is inferred from children
-	//! Cannot be called with an empty list, use either EMPTYLIST or LIST with a type instead
-	DUCKDB_API static Value LIST(vector<Value> values);
 	//! Create a list value with the given entries
 	DUCKDB_API static Value LIST(const LogicalType &child_type, vector<Value> values);
-	//! Create an empty list with the specified child-type
-	DUCKDB_API static Value EMPTYLIST(const LogicalType &child_type);
-	//! Create an array value with the given entries. Array type is inferred from children
-	//! Cannot be called with an empty list, use either EMPTYARRAY or ARRAY with a type instead
-	DUCKDB_API static Value ARRAY(vector<Value> values);
+	//! Create a list value with the given entries
+	//! The type of the first value determines the list type. The list cannot be empty.
+	DUCKDB_API static Value LIST(vector<Value> values);
 	// Create an array value with the given entries
 	DUCKDB_API static Value ARRAY(const LogicalType &type, vector<Value> values);
-	//! Create an empty array of the given type and size
-	DUCKDB_API static Value EMPTYARRAY(const LogicalType &type, uint32_t size);
 	//! Create a map value with the given entries
 	DUCKDB_API static Value MAP(const LogicalType &child_type, vector<Value> values);
 	//! Create a map value with the given entries
@@ -301,6 +298,11 @@ public:
 	}
 	DUCKDB_API void Print() const;
 
+private:
+	void SerializeInternal(Serializer &serializer, bool serialize_type) const;
+	static void SerializeChildren(Serializer &serializer, const vector<Value> &children,
+	                              const LogicalType &parent_type);
+
 private:
 	//! The logical of the value
 	LogicalType type_; // NOLINT
@@ -329,6 +331,10 @@ private:
 		dtime_t time;
 		dtime_tz_t timetz;
 		timestamp_t timestamp;
+		timestamp_sec_t timestamp_s;
+		timestamp_ms_t timestamp_ms;
+		timestamp_ns_t timestamp_ns;
+		timestamp_tz_t timestamp_tz;
 		interval_t interval;
 	} value_; // NOLINT
 
@@ -412,6 +418,22 @@ struct TimestampValue {
 	DUCKDB_API static timestamp_t Get(const Value &value);
 };
 
+struct TimestampSValue {
+	DUCKDB_API static timestamp_sec_t Get(const Value &value);
+};
+
+struct TimestampMSValue {
+	DUCKDB_API static timestamp_ms_t Get(const Value &value);
+};
+
+struct TimestampNSValue {
+	DUCKDB_API static timestamp_ns_t Get(const Value &value);
+};
+
+struct TimestampTZValue {
+	DUCKDB_API static timestamp_tz_t Get(const Value &value);
+};
+
 struct IntervalValue {
 	DUCKDB_API static interval_t Get(const Value &value);
 };
@@ -534,6 +556,14 @@ DUCKDB_API dtime_tz_t Value::GetValue() const;
 template <>
 DUCKDB_API timestamp_t Value::GetValue() const;
 template <>
+DUCKDB_API timestamp_sec_t Value::GetValue() const;
+template <>
+DUCKDB_API timestamp_ms_t Value::GetValue() const;
+template <>
+DUCKDB_API timestamp_ns_t Value::GetValue() const;
+template <>
+DUCKDB_API timestamp_tz_t Value::GetValue() const;
+template <>
 DUCKDB_API interval_t Value::GetValue() const;
 template <>
 DUCKDB_API Value Value::GetValue() const;
@@ -577,6 +607,14 @@ DUCKDB_API dtime_tz_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
 template <>
+DUCKDB_API timestamp_sec_t Value::GetValueUnsafe() const;
+template <>
+DUCKDB_API timestamp_ms_t Value::GetValueUnsafe() const;
+template <>
+DUCKDB_API timestamp_ns_t Value::GetValueUnsafe() const;
+template <>
+DUCKDB_API timestamp_tz_t Value::GetValueUnsafe() const;
+template <>
 DUCKDB_API interval_t Value::GetValueUnsafe() const;
 
 template <>
@@ -592,5 +630,13 @@ template <>
 DUCKDB_API bool Value::IsFinite(date_t input);
 template <>
 DUCKDB_API bool Value::IsFinite(timestamp_t input);
+template <>
+DUCKDB_API bool Value::IsFinite(timestamp_sec_t input);
+template <>
+DUCKDB_API bool Value::IsFinite(timestamp_ms_t input);
+template <>
+DUCKDB_API bool Value::IsFinite(timestamp_ns_t input);
+template <>
+DUCKDB_API bool Value::IsFinite(timestamp_tz_t input);
 
 } // namespace duckdb

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

@@ -16,11 +16,22 @@
 #include "duckdb/function/cast/default_casts.hpp"
 
 namespace duckdb {
+using digit_t = uint32_t;
+using twodigit_t = uint64_t;
+
 //! The Varint class is a static class that holds helper functions for the Varint type.
 class Varint {
 public:
 	//! Header size of a Varint is always 3 bytes.
 	DUCKDB_API static constexpr uint8_t VARINT_HEADER_SIZE = 3;
+	//! Max(e such that 10**e fits in a digit_t)
+	DUCKDB_API static constexpr uint8_t DECIMAL_SHIFT = 9;
+	//! 10 ** DECIMAL_SHIFT
+	DUCKDB_API static constexpr digit_t DECIMAL_BASE = 1000000000;
+	//! Bytes of a digit_t
+	DUCKDB_API static constexpr uint8_t DIGIT_BYTES = sizeof(digit_t);
+	//! Bits of a digit_t
+	DUCKDB_API static constexpr uint8_t DIGIT_BITS = DIGIT_BYTES * 8;
 	//! Verifies if a Varint is valid. i.e., if it has 3 header bytes. The header correctly represents the number of
 	//! data bytes, and the data bytes has no leading zero bytes.
 	DUCKDB_API static void Verify(const string_t &input);
@@ -47,6 +58,8 @@ public:
 	DUCKDB_API static char DigitToChar(int digit);
 	//! Function to convert a string_t into a vector of bytes
 	DUCKDB_API static void GetByteArray(vector<uint8_t> &byte_array, bool &is_negative, const string_t &blob);
+	//! Function to create a VARINT blob from a byte array containing the absolute value, plus an is_negative bool
+	DUCKDB_API static string FromByteArray(uint8_t *data, idx_t size, bool is_negative);
 	//! Function to convert VARINT blob to a VARCHAR
 	DUCKDB_API static string VarIntToVarchar(const string_t &blob);
 	//! Function to convert Varchar to VARINT blob

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

@@ -109,9 +109,10 @@ public:
 	/*!
 	    Create a new vector
 	    If create_data is true, the vector will be an owning empty vector.
-	    If zero_data is true, the allocated data will be zero-initialized.
+	    If initialize_to_zero is true, the allocated data will be zero-initialized.
 	*/
-	DUCKDB_API Vector(LogicalType type, bool create_data, bool zero_data, idx_t capacity = STANDARD_VECTOR_SIZE);
+	DUCKDB_API Vector(LogicalType type, bool create_data, bool initialize_to_zero,
+	                  idx_t capacity = STANDARD_VECTOR_SIZE);
 	// implicit copying of Vectors is not allowed
 	Vector(const Vector &) = delete;
 	// but moving of vectors is allowed
@@ -144,10 +145,14 @@ public:
 	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count);
 	//! Slice the vector, keeping the result around in a cache or potentially using the cache instead of slicing
 	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count, SelCache &cache);
+	//! Turn this vector into a dictionary vector
+	DUCKDB_API void Dictionary(idx_t dictionary_size, const SelectionVector &sel, idx_t count);
+	//! Creates a reference to a dictionary of the other vector
+	DUCKDB_API void Dictionary(const Vector &dict, idx_t dictionary_size, const SelectionVector &sel, idx_t count);
 
 	//! Creates the data of this vector with the specified type. Any data that
 	//! is currently in the vector is destroyed.
-	DUCKDB_API void Initialize(bool zero_data = false, idx_t capacity = STANDARD_VECTOR_SIZE);
+	DUCKDB_API void Initialize(bool initialize_to_zero = false, idx_t capacity = STANDARD_VECTOR_SIZE);
 
 	//! Converts this Vector to a printable string representation
 	DUCKDB_API string ToString(idx_t count) const;
@@ -304,22 +309,44 @@ struct ConstantVector {
 };
 
 struct DictionaryVector {
-	static inline const SelectionVector &SelVector(const Vector &vector) {
+	static void VerifyDictionary(const Vector &vector) {
+#ifdef DUCKDB_DEBUG_NO_SAFETY
 		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
+#else
+		if (vector.GetVectorType() != VectorType::DICTIONARY_VECTOR) {
+			throw InternalException(
+			    "Operation requires a dictionary vector but a non-dictionary vector was encountered");
+		}
+#endif
+	}
+	static inline const SelectionVector &SelVector(const Vector &vector) {
+		VerifyDictionary(vector);
 		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
 	}
 	static inline SelectionVector &SelVector(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
+		VerifyDictionary(vector);
 		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
 	}
 	static inline const Vector &Child(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
+		VerifyDictionary(vector);
 		return vector.auxiliary->Cast<VectorChildBuffer>().data;
 	}
 	static inline Vector &Child(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
+		VerifyDictionary(vector);
 		return vector.auxiliary->Cast<VectorChildBuffer>().data;
 	}
+	static inline optional_idx DictionarySize(const Vector &vector) {
+		VerifyDictionary(vector);
+		return vector.buffer->Cast<DictionaryBuffer>().GetDictionarySize();
+	}
+	static inline const string &DictionaryId(const Vector &vector) {
+		VerifyDictionary(vector);
+		return vector.buffer->Cast<DictionaryBuffer>().GetDictionaryId();
+	}
+	static inline void SetDictionaryId(Vector &vector, string new_id) {
+		VerifyDictionary(vector);
+		vector.buffer->Cast<DictionaryBuffer>().SetDictionaryId(std::move(new_id));
+	}
 };
 
 struct FlatVector {

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

@@ -159,9 +159,24 @@ public:
 	void SetSelVector(const SelectionVector &vector) {
 		this->sel_vector.Initialize(vector);
 	}
+	void SetDictionarySize(idx_t dict_size) {
+		dictionary_size = dict_size;
+	}
+	optional_idx GetDictionarySize() const {
+		return dictionary_size;
+	}
+	void SetDictionaryId(string id) {
+		dictionary_id = std::move(id);
+	}
+	const string &GetDictionaryId() const {
+		return dictionary_id;
+	}
 
 private:
 	SelectionVector sel_vector;
+	optional_idx dictionary_size;
+	//! A unique identifier for the dictionary that can be used to check if two dictionaries are equivalent
+	string dictionary_id;
 };
 
 class VectorStringBuffer : public VectorBuffer {

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

@@ -234,6 +234,7 @@ enum class LogicalTypeId : uint8_t {
 };
 
 struct ExtraTypeInfo;
+struct ExtensionTypeInfo;
 
 struct aggregate_state_t; // NOLINT: mimic std casing
 
@@ -252,7 +253,7 @@ struct LogicalType {
 	inline PhysicalType InternalType() const {
 		return physical_type_;
 	}
-	inline const ExtraTypeInfo *AuxInfo() const {
+	inline const optional_ptr<ExtraTypeInfo> AuxInfo() const {
 		return type_info_.get();
 	}
 	inline bool IsNested() const {
@@ -323,11 +324,11 @@ struct LogicalType {
 	DUCKDB_API void SetAlias(string alias);
 	DUCKDB_API bool HasAlias() const;
 	DUCKDB_API string GetAlias() const;
-	DUCKDB_API void SetModifiers(vector<Value> modifiers);
-	DUCKDB_API bool HasModifiers() const;
-	DUCKDB_API vector<Value> GetModifiersCopy() const;
-	DUCKDB_API optional_ptr<vector<Value>> GetModifiers();
-	DUCKDB_API optional_ptr<const vector<Value>> GetModifiers() const;
+
+	DUCKDB_API bool HasExtensionInfo() const;
+	DUCKDB_API optional_ptr<const ExtensionTypeInfo> GetExtensionInfo() const;
+	DUCKDB_API optional_ptr<ExtensionTypeInfo> GetExtensionInfo();
+	DUCKDB_API void SetExtensionInfo(unique_ptr<ExtensionTypeInfo> info);
 
 	//! Returns the maximum logical type when combining the two types - or throws an exception if combining is not possible
 	DUCKDB_API static LogicalType MaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right);
@@ -338,12 +339,16 @@ struct LogicalType {
 	DUCKDB_API static LogicalType NormalizeType(const LogicalType &type);
 
 
-		//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
+	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
 	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
 
 	DUCKDB_API void Verify() const;
 
 	DUCKDB_API bool IsValid() const;
+	DUCKDB_API bool IsComplete() const;
+
+	//! True, if this type supports in-place updates.
+	bool SupportsRegularUpdate() const;
 
 
 private:

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

@@ -79,3 +79,13 @@ public:
 };
 
 } // namespace duckdb
+
+namespace std {
+template <>
+struct hash<duckdb::uhugeint_t> {
+	size_t operator()(const duckdb::uhugeint_t &val) const {
+		using std::hash;
+		return hash<uint64_t> {}(val.upper) ^ hash<uint64_t> {}(val.lower);
+	}
+};
+} // namespace std

package/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp

@@ -31,6 +31,7 @@ using SubFrames = vector<FrameBounds>;
 
 class AggregateExecutor {
 private:
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class STATE_TYPE, class OP>
 	static inline void NullaryFlatLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
 	                                   idx_t count) {
@@ -38,6 +39,7 @@ private:
 			OP::template Operation<STATE_TYPE, OP>(*states[i], aggr_input_data, i);
 		}
 	}
+#endif
 
 	template <class STATE_TYPE, class OP>
 	static inline void NullaryScatterLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
@@ -49,6 +51,7 @@ private:
 		}
 	}
 
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
 	static inline void UnaryFlatLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                 STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count) {
@@ -88,6 +91,7 @@ private:
 			}
 		}
 	}
+#endif
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
 	static inline void UnaryScatterLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
@@ -114,6 +118,7 @@ private:
 		}
 	}
 
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
 	static inline void UnaryFlatUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                       STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask) {
@@ -144,6 +149,7 @@ private:
 			}
 		}
 	}
+#endif
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
 	static inline void UnaryUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
@@ -230,9 +236,11 @@ public:
 		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 			OP::template ConstantOperation<STATE_TYPE, OP>(**sdata, aggr_input_data, count);
+#ifndef DUCKDB_SMALLER_BINARY
 		} else if (states.GetVectorType() == VectorType::FLAT_VECTOR) {
 			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
 			NullaryFlatLoop<STATE_TYPE, OP>(sdata, aggr_input_data, count);
+#endif
 		} else {
 			UnifiedVectorFormat sdata;
 			states.ToUnifiedFormat(count, sdata);
@@ -258,12 +266,14 @@ public:
 			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 			AggregateUnaryInput input_data(aggr_input_data, ConstantVector::Validity(input));
 			OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(**sdata, *idata, input_data, count);
+#ifndef DUCKDB_SMALLER_BINARY
 		} else if (input.GetVectorType() == VectorType::FLAT_VECTOR &&
 		           states.GetVectorType() == VectorType::FLAT_VECTOR) {
 			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
 			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
 			UnaryFlatLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, sdata, FlatVector::Validity(input),
 			                                          count);
+#endif
 		} else {
 			UnifiedVectorFormat idata, sdata;
 			input.ToUnifiedFormat(count, idata);
@@ -287,12 +297,14 @@ public:
 			                                                           input_data, count);
 			break;
 		}
+#ifndef DUCKDB_SMALLER_BINARY
 		case VectorType::FLAT_VECTOR: {
 			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
 			UnaryFlatUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, (STATE_TYPE *)state, count,
 			                                                FlatVector::Validity(input));
 			break;
 		}
+#endif
 		default: {
 			UnifiedVectorFormat idata;
 			input.ToUnifiedFormat(count, idata);
@@ -387,19 +399,6 @@ public:
 		}
 	}
 
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(const Vector &input, const ValidityMask &ifilter, AggregateInputData &aggr_input_data,
-	                        data_ptr_t state_p, const SubFrames &frames, Vector &result, idx_t ridx,
-	                        const_data_ptr_t gstate_p) {
-
-		auto idata = FlatVector::GetData<const INPUT_TYPE>(input);
-		const auto &ivalid = FlatVector::Validity(input);
-		auto &state = *reinterpret_cast<STATE *>(state_p);
-		auto gstate = reinterpret_cast<const STATE *>(gstate_p);
-		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ifilter, ivalid, aggr_input_data, state, frames,
-		                                                    result, ridx, gstate);
-	}
-
 	template <typename OP>
 	static void IntersectFrames(const SubFrames &lefts, const SubFrames &rights, OP &op) {
 		const auto cover_start = MinValue(rights[0].start, lefts[0].start);

package/src/duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp

@@ -68,6 +68,7 @@ struct BinaryLambdaWrapperWithNulls {
 };
 
 struct BinaryExecutor {
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
 	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
 	static void ExecuteFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
@@ -121,6 +122,7 @@ struct BinaryExecutor {
 			}
 		}
 	}
+#endif
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
 	static void ExecuteConstant(Vector &left, Vector &right, Vector &result, FUNC fun) {
@@ -138,6 +140,7 @@ struct BinaryExecutor {
 		    fun, *ldata, *rdata, ConstantVector::Validity(result), 0);
 	}
 
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
 	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
 	static void ExecuteFlat(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
@@ -182,6 +185,7 @@ struct BinaryExecutor {
 		ExecuteFlatLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, LEFT_CONSTANT, RIGHT_CONSTANT>(
 		    ldata, rdata, result_data, count, result_validity, fun);
 	}
+#endif
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
 	static void ExecuteGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
@@ -232,6 +236,7 @@ struct BinaryExecutor {
 		auto right_vector_type = right.GetVectorType();
 		if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
 			ExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, fun);
+#ifndef DUCKDB_SMALLER_BINARY
 		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
 			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, true>(left, right, result,
 			                                                                                  count, fun);
@@ -241,6 +246,7 @@ struct BinaryExecutor {
 		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
 			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, false>(left, right, result,
 			                                                                                   count, fun);
+#endif
 		} else {
 			ExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, count, fun);
 		}
@@ -299,6 +305,7 @@ public:
 		}
 	}
 
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL,
 	          bool HAS_FALSE_SEL>
 	static inline idx_t SelectFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
@@ -417,14 +424,24 @@ public:
 			    ldata, rdata, sel, count, combined_mask, true_sel, false_sel);
 		}
 	}
+#endif
 
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
+#else
+	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
+#endif
 	static inline idx_t
 	SelectGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                  const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
 	                  const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
 	                  ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
 		idx_t true_count = 0, false_count = 0;
+#ifdef DUCKDB_SMALLER_BINARY
+		const bool HAS_TRUE_SEL = true_sel;
+		const bool HAS_FALSE_SEL = false_sel;
+		const bool NO_NULL = false;
+#endif
 		for (idx_t i = 0; i < count; i++) {
 			auto result_idx = result_sel->get_index(i);
 			auto lindex = lsel->get_index(i);
@@ -446,6 +463,8 @@ public:
 			return count - false_count;
 		}
 	}
+
+#ifndef DUCKDB_SMALLER_BINARY
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
 	static inline idx_t
 	SelectGenericLoopSelSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
@@ -464,6 +483,7 @@ public:
 			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
 		}
 	}
+#endif
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
 	static inline idx_t
@@ -471,6 +491,7 @@ public:
 	                        const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
 	                        const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
 	                        ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
+#ifndef DUCKDB_SMALLER_BINARY
 		if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
 			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
 			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
@@ -478,6 +499,10 @@ public:
 			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
 			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
 		}
+#else
+		return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP>(ldata, rdata, lsel, rsel, result_sel, count, lvalidity,
+		                                                    rvalidity, true_sel, false_sel);
+#endif
 	}
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
@@ -502,6 +527,7 @@ public:
 		if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
 		    right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			return SelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
+#ifndef DUCKDB_SMALLER_BINARY
 		} else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
 		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
 			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
@@ -511,6 +537,7 @@ public:
 		} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
 		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
 			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel, false_sel);
+#endif
 		} else {
 			return SelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
 		}