duckdb 0.3.2-dev903.0 → 0.3.2-dev930.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "de4145741"
-#define DUCKDB_VERSION "0.3.2-dev903"
+#define DUCKDB_SOURCE_ID "7e441464b"
+#define DUCKDB_VERSION "0.3.2-dev930"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -109,6 +109,25 @@ using std::string;
 
 namespace duckdb {
 
+// API versions
+// if no explicit API version is defined, the latest API version is used
+// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
+// These will not be supported long-term, and will be removed in future versions.
+
+#ifndef DUCKDB_API_0_3_1
+#define DUCKDB_API_0_3_1 1
+#endif
+#ifndef DUCKDB_API_0_3_2
+#define DUCKDB_API_0_3_2 2
+#endif
+#ifndef DUCKDB_API_LATEST
+#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
+#endif
+
+#ifndef DUCKDB_API_VERSION
+#define DUCKDB_API_VERSION DUCKDB_API_LATEST
+#endif
+
 //! inline std directives that we use frequently
 using std::move;
 using std::shared_ptr;
@@ -972,7 +991,7 @@ struct LogicalType {
 		return *this;
 	}
 	// move assignment
-	inline LogicalType& operator=(LogicalType&& other) {
+	inline LogicalType& operator=(LogicalType&& other) noexcept {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		type_info_ = move(other.type_info_);
@@ -2549,7 +2568,9 @@ class Serializer;
 //! The Value object holds a single arbitrary value of any type that can be
 //! stored in the database.
 class Value {
-	friend class Vector;
+	friend struct StringValue;
+	friend struct StructValue;
+	friend struct ListValue;
 
 public:
 	//! Create an empty NULL value of the specified type
@@ -2570,10 +2591,24 @@ public:
 	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
 	//! Create a VARCHAR value
 	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
+	//! Copy constructor
+	DUCKDB_API Value(const Value &other);
+	//! Move constructor
+	DUCKDB_API Value(Value &&other) noexcept;
+	//! Destructor
+	DUCKDB_API ~Value();
+
+	// copy assignment
+	DUCKDB_API Value &operator=(const Value &other);
+	// move assignment
+	DUCKDB_API Value &operator=(Value &&other) noexcept;
 
 	inline const LogicalType &type() const {
 		return type_;
 	}
+	inline bool IsNull() const {
+		return is_null;
+	}
 
 	//! Create the lowest possible value of a given type (numeric only)
 	DUCKDB_API static Value MinimumValue(const LogicalType &type);
@@ -2653,7 +2688,7 @@ public:
 	DUCKDB_API static Value LIST(vector<Value> values);
 	//! Create a list value with the given entries
 	DUCKDB_API static Value LIST(LogicalType child_type, vector<Value> values);
-	//! Create an empty list with the specified type
+	//! Create an empty list with the specified child-type
 	DUCKDB_API static Value EMPTYLIST(LogicalType child_type);
 	//! Creat a map value from a (key, value) pair
 	DUCKDB_API static Value MAP(Value key, Value value);
@@ -2668,17 +2703,22 @@ public:
 
 	template <class T>
 	T GetValue() const {
-		throw NotImplementedException("Unimplemented template type for Value::GetValue");
+		throw InternalException("Unimplemented template type for Value::GetValue");
 	}
 	template <class T>
 	static Value CreateValue(T value) {
-		throw NotImplementedException("Unimplemented template type for Value::CreateValue");
+		throw InternalException("Unimplemented template type for Value::CreateValue");
 	}
 	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
 	// type of the value. Only use this if you know what you are doing.
 	template <class T>
-	T &GetValueUnsafe() {
-		throw NotImplementedException("Unimplemented template type for Value::GetValueUnsafe");
+	T GetValueUnsafe() const {
+		throw InternalException("Unimplemented template type for Value::GetValueUnsafe");
+	}
+	//! Returns a reference to the internal value. This can only be used for primitive types.
+	template <class T>
+	T &GetReferenceUnsafe() {
+		throw InternalException("Unimplemented template type for Value::GetReferenceUnsafe");
 	}
 
 	//! Return a copy of this value
@@ -2686,6 +2726,8 @@ public:
 		return Value(*this);
 	}
 
+	//! Hashes the Value
+	DUCKDB_API hash_t Hash() const;
 	//! Convert this value to a string
 	DUCKDB_API string ToString() const;
 
@@ -2704,15 +2746,6 @@ public:
 	//! Deserializes a Value from a blob
 	DUCKDB_API static Value Deserialize(Deserializer &source);
 
-	//===--------------------------------------------------------------------===//
-	// Numeric Operators
-	//===--------------------------------------------------------------------===//
-	DUCKDB_API Value operator+(const Value &rhs) const;
-	DUCKDB_API Value operator-(const Value &rhs) const;
-	DUCKDB_API Value operator*(const Value &rhs) const;
-	DUCKDB_API Value operator/(const Value &rhs) const;
-	DUCKDB_API Value operator%(const Value &rhs) const;
-
 	//===--------------------------------------------------------------------===//
 	// Comparison Operators
 	//===--------------------------------------------------------------------===//
@@ -2756,7 +2789,9 @@ private:
 	//! The logical of the value
 	LogicalType type_;
 
+#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
 public:
+#endif
 	//! Whether or not the value is NULL
 	bool is_null;
 
@@ -2791,17 +2826,93 @@ public:
 private:
 	template <class T>
 	T GetValueInternal() const;
-	//! Templated helper function for casting
-	template <class DST, class OP>
-	static DST _cast(const Value &v);
+};
 
-	//! Templated helper function for binary operations
-	template <class OP>
-	static void _templated_binary_operation(const Value &left, const Value &right, Value &result, bool ignore_null);
+//===--------------------------------------------------------------------===//
+// Type-specific getters
+//===--------------------------------------------------------------------===//
+// Note that these are equivalent to calling GetValueUnsafe<X>, meaning no cast will be performed
+// instead, an assertion will be triggered if the value is not of the correct type
+struct BooleanValue {
+	DUCKDB_API static bool Get(const Value &value);
+};
 
-	//! Templated helper function for boolean operations
-	template <class OP>
-	static bool _templated_boolean_operation(const Value &left, const Value &right);
+struct TinyIntValue {
+	DUCKDB_API static int8_t Get(const Value &value);
+};
+
+struct SmallIntValue {
+	DUCKDB_API static int16_t Get(const Value &value);
+};
+
+struct IntegerValue {
+	DUCKDB_API static int32_t Get(const Value &value);
+};
+
+struct BigIntValue {
+	DUCKDB_API static int64_t Get(const Value &value);
+};
+
+struct HugeIntValue {
+	DUCKDB_API static hugeint_t Get(const Value &value);
+};
+
+struct UTinyIntValue {
+	DUCKDB_API static uint8_t Get(const Value &value);
+};
+
+struct USmallIntValue {
+	DUCKDB_API static uint16_t Get(const Value &value);
+};
+
+struct UIntegerValue {
+	DUCKDB_API static uint32_t Get(const Value &value);
+};
+
+struct UBigIntValue {
+	DUCKDB_API static uint64_t Get(const Value &value);
+};
+
+struct FloatValue {
+	DUCKDB_API static float Get(const Value &value);
+};
+
+struct DoubleValue {
+	DUCKDB_API static double Get(const Value &value);
+};
+
+struct StringValue {
+	DUCKDB_API static const string &Get(const Value &value);
+};
+
+struct DateValue {
+	DUCKDB_API static date_t Get(const Value &value);
+};
+
+struct TimeValue {
+	DUCKDB_API static dtime_t Get(const Value &value);
+};
+
+struct TimestampValue {
+	DUCKDB_API static timestamp_t Get(const Value &value);
+};
+
+struct IntervalValue {
+	DUCKDB_API static interval_t Get(const Value &value);
+};
+
+struct StructValue {
+	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
+};
+
+struct ListValue {
+	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
+};
+
+//! Return the internal integral value for any type that is stored as an integral value internally
+//! This can be used on values of type integer, uinteger, but also date, timestamp, decimal, etc
+struct IntegralValue {
+	static hugeint_t Get(const Value &value);
 };
 
 template <>
@@ -2881,37 +2992,72 @@ template <>
 DUCKDB_API interval_t Value::GetValue() const;
 
 template <>
-DUCKDB_API int8_t &Value::GetValueUnsafe();
+DUCKDB_API bool Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API int16_t &Value::GetValueUnsafe();
+DUCKDB_API int8_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API int32_t &Value::GetValueUnsafe();
+DUCKDB_API int16_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API int64_t &Value::GetValueUnsafe();
+DUCKDB_API int32_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API hugeint_t &Value::GetValueUnsafe();
+DUCKDB_API int64_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API uint8_t &Value::GetValueUnsafe();
+DUCKDB_API hugeint_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API uint16_t &Value::GetValueUnsafe();
+DUCKDB_API uint8_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API uint32_t &Value::GetValueUnsafe();
+DUCKDB_API uint16_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API uint64_t &Value::GetValueUnsafe();
+DUCKDB_API uint32_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API string &Value::GetValueUnsafe();
+DUCKDB_API uint64_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API float &Value::GetValueUnsafe();
+DUCKDB_API string Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API double &Value::GetValueUnsafe();
+DUCKDB_API string_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API date_t &Value::GetValueUnsafe();
+DUCKDB_API float Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API dtime_t &Value::GetValueUnsafe();
+DUCKDB_API double Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API timestamp_t &Value::GetValueUnsafe();
+DUCKDB_API date_t Value::GetValueUnsafe() const;
 template <>
-DUCKDB_API interval_t &Value::GetValueUnsafe();
+DUCKDB_API dtime_t Value::GetValueUnsafe() const;
+template <>
+DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
+template <>
+DUCKDB_API interval_t Value::GetValueUnsafe() const;
+
+template <>
+DUCKDB_API int8_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API int16_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API int32_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API int64_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API hugeint_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint8_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint16_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint32_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint64_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API float &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API double &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API date_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API dtime_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API timestamp_t &Value::GetReferenceUnsafe();
+template <>
+DUCKDB_API interval_t &Value::GetReferenceUnsafe();
 
 template <>
 DUCKDB_API bool Value::IsValid(float value);
@@ -3274,7 +3420,7 @@ public:
 	void Append(const Vector &to_append, idx_t to_append_size, idx_t source_offset = 0);
 	void Append(const Vector &to_append, const SelectionVector &sel, idx_t to_append_size, idx_t source_offset = 0);
 
-	void PushBack(Value &insert);
+	void PushBack(const Value &insert);
 
 	idx_t capacity = 0;
 	idx_t size = 0;
@@ -3592,8 +3738,8 @@ struct ListVector {
 	DUCKDB_API static void Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset = 0);
 	DUCKDB_API static void Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
 	                              idx_t source_offset = 0);
-	DUCKDB_API static void PushBack(Vector &target, Value &insert);
-	DUCKDB_API static vector<idx_t> Search(Vector &list, Value &key, idx_t row);
+	DUCKDB_API static void PushBack(Vector &target, const Value &insert);
+	DUCKDB_API static vector<idx_t> Search(Vector &list, const Value &key, idx_t row);
 	DUCKDB_API static Value GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets);
 	//! Share the entry of the other list vector
 	DUCKDB_API static void ReferenceEntry(Vector &vector, Vector &other);
@@ -20098,31 +20244,12 @@ public:
 	}
 
 	template <class T>
-	static inline void Update(SegmentStatistics &stats, T new_value);
+	static inline void Update(SegmentStatistics &stats, T new_value) {
+		auto &nstats = (NumericStatistics &)*stats.statistics;
+		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
+	}
 };
 
-template <>
-void NumericStatistics::Update<int8_t>(SegmentStatistics &stats, int8_t new_value);
-template <>
-void NumericStatistics::Update<int16_t>(SegmentStatistics &stats, int16_t new_value);
-template <>
-void NumericStatistics::Update<int32_t>(SegmentStatistics &stats, int32_t new_value);
-template <>
-void NumericStatistics::Update<int64_t>(SegmentStatistics &stats, int64_t new_value);
-template <>
-void NumericStatistics::Update<uint8_t>(SegmentStatistics &stats, uint8_t new_value);
-template <>
-void NumericStatistics::Update<uint16_t>(SegmentStatistics &stats, uint16_t new_value);
-template <>
-void NumericStatistics::Update<uint32_t>(SegmentStatistics &stats, uint32_t new_value);
-template <>
-void NumericStatistics::Update<uint64_t>(SegmentStatistics &stats, uint64_t new_value);
-template <>
-void NumericStatistics::Update<hugeint_t>(SegmentStatistics &stats, hugeint_t new_value);
-template <>
-void NumericStatistics::Update<float>(SegmentStatistics &stats, float new_value);
-template <>
-void NumericStatistics::Update<double>(SegmentStatistics &stats, double new_value);
 template <>
 void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value);
 template <>