duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

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

@@ -23,120 +23,122 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 struct Equals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return left == right;
 	}
 };
 struct NotEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return !Equals::Operation(left, right);
 	}
 };
 
 struct GreaterThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return left > right;
 	}
 };
 
 struct GreaterThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
-		return left >= right;
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+		return !GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThan {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
 		return GreaterThan::Operation(right, left);
 	}
 };
 
 struct LessThanEquals {
 	template <class T>
-	DUCKDB_API static inline bool Operation(T left, T right) {
-		return GreaterThanEquals::Operation(right, left);
+	DUCKDB_API static inline bool Operation(const T &left, const T &right) {
+		return !GreaterThan::Operation(left, right);
 	}
 };
 
 template <>
-DUCKDB_API bool Equals::Operation(float left, float right);
+DUCKDB_API bool Equals::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool Equals::Operation(double left, double right);
+DUCKDB_API bool Equals::Operation(const double &left, const double &right);
 
 template <>
-DUCKDB_API bool GreaterThan::Operation(float left, float right);
+DUCKDB_API bool GreaterThan::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool GreaterThan::Operation(double left, double right);
+DUCKDB_API bool GreaterThan::Operation(const double &left, const double &right);
 
 template <>
-DUCKDB_API bool GreaterThanEquals::Operation(float left, float right);
+DUCKDB_API bool GreaterThanEquals::Operation(const float &left, const float &right);
 template <>
-DUCKDB_API bool GreaterThanEquals::Operation(double left, double right);
+DUCKDB_API bool GreaterThanEquals::Operation(const double &left, const double &right);
 
 // Distinct semantics are from Postgres record sorting. NULL = NULL and not-NULL < NULL
 // Deferring to the non-distinct operations removes the need for further specialisation.
 // TODO: To reverse the semantics, swap left_null and right_null for comparisons
 struct DistinctFrom {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null != right_null) || (!left_null && !right_null && NotEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (left_null || right_null) {
+			return left_null != right_null;
+		}
+		return NotEquals::Operation(left, right);
 	}
 };
 
 struct NotDistinctFrom {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null && right_null) || (!left_null && !right_null && Equals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctFrom::Operation(left, right, left_null, right_null);
 	}
 };
 
 struct DistinctGreaterThan {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (left_null || right_null) {
+			return !right_null;
+		}
+		return GreaterThan::Operation(left, right);
 	}
 };
 
 struct DistinctGreaterThanNullsFirst {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(left, right, right_null, left_null);
 	}
 };
 
 struct DistinctGreaterThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return left_null || (!left_null && !right_null && GreaterThanEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctGreaterThan::Operation(right, left, right_null, left_null);
 	}
 };
 
 struct DistinctLessThan {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(right, left, right_null, left_null);
 	}
 };
 
 struct DistinctLessThanNullsFirst {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctGreaterThan::Operation(right, left, left_null, right_null);
 	}
 };
 
 struct DistinctLessThanEquals {
 	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return right_null || (!left_null && !right_null && LessThanEquals::Operation(left, right));
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return !DistinctGreaterThan::Operation(left, right, left_null, right_null);
 	}
 };
 
@@ -144,124 +146,34 @@ struct DistinctLessThanEquals {
 // Specialized Boolean Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool GreaterThan::Operation(bool left, bool right) {
+inline bool GreaterThan::Operation(const bool &left, const bool &right) {
 	return !right && left;
 }
-template <>
-inline bool LessThan::Operation(bool left, bool right) {
-	return !left && right;
-}
 //===--------------------------------------------------------------------===//
 // Specialized String Comparison Operations
 //===--------------------------------------------------------------------===//
-struct StringComparisonOperators {
-	template <bool INVERSE>
-	static inline bool EqualsOrNot(const string_t a, const string_t b) {
-		if (a.IsInlined()) {
-			// small string: compare entire string
-			if (memcmp(&a, &b, sizeof(string_t)) == 0) {
-				// entire string is equal
-				return INVERSE ? false : true;
-			}
-		} else {
-			// large string: first check prefix and length
-			if (memcmp(&a, &b, string_t::HEADER_SIZE) == 0) {
-				// prefix and length are equal: check main string
-				if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
-					// entire string is equal
-					return INVERSE ? false : true;
-				}
-			}
-		}
-		// not equal
-		return INVERSE ? true : false;
-	}
-};
-
-template <>
-inline bool Equals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<false>(left, right);
-}
-template <>
-inline bool NotEquals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<true>(left, right);
-}
-
-template <>
-inline bool NotDistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<false>(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<true>(left, right));
-}
-
-// compare up to shared length. if still the same, compare lengths
-template <class OP>
-static bool templated_string_compare_op(string_t left, string_t right) {
-	auto memcmp_res =
-	    memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), MinValue<idx_t>(left.GetSize(), right.GetSize()));
-	auto final_res = memcmp_res == 0 ? OP::Operation(left.GetSize(), right.GetSize()) : OP::Operation(memcmp_res, 0);
-	return final_res;
-}
-
-template <>
-inline bool GreaterThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThan>(left, right);
-}
-
 template <>
-inline bool GreaterThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThanEquals>(left, right);
+inline bool Equals::Operation(const string_t &left, const string_t &right) {
+	return left == right;
 }
 
 template <>
-inline bool LessThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThan>(left, right);
+inline bool GreaterThan::Operation(const string_t &left, const string_t &right) {
+	return left > right;
 }
 
-template <>
-inline bool LessThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThanEquals>(left, right);
-}
 //===--------------------------------------------------------------------===//
 // Specialized Interval Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool Equals::Operation(interval_t left, interval_t right) {
+inline bool Equals::Operation(const interval_t &left, const interval_t &right) {
 	return Interval::Equals(left, right);
 }
 template <>
-inline bool NotEquals::Operation(interval_t left, interval_t right) {
-	return !Equals::Operation(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(interval_t left, interval_t right) {
+inline bool GreaterThan::Operation(const interval_t &left, const interval_t &right) {
 	return Interval::GreaterThan(left, right);
 }
-template <>
-inline bool GreaterThanEquals::Operation(interval_t left, interval_t right) {
-	return Interval::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(interval_t left, interval_t right) {
-	return GreaterThan::Operation(right, left);
-}
-template <>
-inline bool LessThanEquals::Operation(interval_t left, interval_t right) {
-	return GreaterThanEquals::Operation(right, left);
-}
 
-template <>
-inline bool NotDistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) || (!left_null && !right_null && Interval::Equals(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) || (!left_null && !right_null && !Equals::Operation(left, right));
-}
 inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
 	return LessThan::Operation(lhs, rhs);
 }
@@ -270,27 +182,11 @@ inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
 // Specialized Hugeint Comparison Operators
 //===--------------------------------------------------------------------===//
 template <>
-inline bool Equals::Operation(hugeint_t left, hugeint_t right) {
+inline bool Equals::Operation(const hugeint_t &left, const hugeint_t &right) {
 	return Hugeint::Equals(left, right);
 }
 template <>
-inline bool NotEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::NotEquals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(hugeint_t left, hugeint_t right) {
+inline bool GreaterThan::Operation(const hugeint_t &left, const hugeint_t &right) {
 	return Hugeint::GreaterThan(left, right);
 }
-template <>
-inline bool GreaterThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThan(left, right);
-}
-template <>
-inline bool LessThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThanEquals(left, right);
-}
 } // namespace duckdb

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

@@ -56,6 +56,8 @@ template <>
 bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
 template <>
 DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+DUCKDB_API bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
 
 struct MultiplyOperatorOverflowCheck {
 	template <class TA, class TB, class TR>

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

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/optional_ptr.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+
+template <class T>
+class optional_ptr {
+public:
+	optional_ptr() : ptr(nullptr) {
+	}
+	optional_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
+	}
+	optional_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
+	}
+
+	operator bool() const {
+		return ptr;
+	}
+	T &operator*() {
+		if (!ptr) {
+			throw InternalException("Attempting to dereference an optional pointer that is not set");
+		}
+		return *ptr;
+	}
+	T *operator->() {
+		if (!ptr) {
+			throw InternalException("Attempting to call a method on an optional pointer that is not set");
+		}
+		return ptr;
+	}
+
+private:
+	T *ptr;
+};
+
+} // namespace duckdb

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

@@ -19,7 +19,8 @@ public:
 	DUCKDB_API PreservedError();
 	//! From std::exception
 	PreservedError(const std::exception &ex)
-	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())) {
+	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())),
+	      exception_instance(nullptr) {
 	}
 	//! From a raw string
 	DUCKDB_API explicit PreservedError(const string &raw_message);
@@ -38,6 +39,9 @@ public:
 	//! Let's us do things like 'if (error)'
 	DUCKDB_API operator bool() const;
 	DUCKDB_API bool operator==(const PreservedError &other) const;
+	DUCKDB_API const shared_ptr<Exception> &GetError() {
+		return exception_instance;
+	}
 
 private:
 	//! Whether this PreservedError contains an exception or not
@@ -48,6 +52,7 @@ private:
 	string raw_message;
 	//! The final message (stored in the preserved error for compatibility reasons with C-API)
 	string final_message;
+	std::shared_ptr<Exception> exception_instance;
 
 private:
 	DUCKDB_API static string SanitizeErrorMessage(string error);

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

@@ -16,11 +16,13 @@
 
 namespace duckdb {
 
+struct ClientConfig;
 typedef unique_ptr<ProgressBarDisplay> (*progress_bar_display_create_func_t)();
 
 class ProgressBar {
 public:
 	static unique_ptr<ProgressBarDisplay> DefaultProgressBarDisplay();
+	static void SystemOverrideCheck(ClientConfig &config);
 
 	explicit ProgressBar(
 	    Executor &executor, idx_t show_progress_after,

package/src/duckdb/src/include/duckdb/common/serializer/buffered_deserializer.hpp

@@ -26,14 +26,16 @@ public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
 };
 
-class BufferentContextDeserializer : public BufferedDeserializer {
+class BufferedContextDeserializer : public BufferedDeserializer {
 public:
-	BufferentContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
+	BufferedContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
 	    : BufferedDeserializer(ptr, data_size), context(context_p) {
 	}
 
 public:
 	ClientContext &context;
+
+	ClientContext &GetContext() override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp

@@ -14,14 +14,16 @@ namespace duckdb {
 
 class BufferedFileReader : public Deserializer {
 public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
-	                   FileOpener *opener = nullptr);
+	BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context,
+	                   FileLockType lock_type = FileLockType::READ_LOCK, FileOpener *opener = nullptr);
 
 	FileSystem &fs;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t read_data;
 	unique_ptr<FileHandle> handle;
+	ClientContext *context;
+	Catalog *catalog = nullptr;
 
 public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
@@ -35,6 +37,10 @@ public:
 	void Seek(uint64_t location);
 	uint64_t CurrentOffset();
 
+	ClientContext &GetContext() override;
+
+	Catalog *GetCatalog() override;
+
 private:
 	idx_t file_size;
 	idx_t total_read;

package/src/duckdb/src/include/duckdb/common/serializer/enum_serializer.hpp

@@ -0,0 +1,113 @@
+#pragma once
+#include <stdint.h>
+
+namespace duckdb {
+
+struct EnumSerializer {
+	// String -> Enum
+	template <class T>
+	static T StringToEnum(const char *value) = delete;
+
+	// Enum -> String
+	template <class T>
+	static const char *EnumToString(T value) = delete;
+};
+
+enum class OrderType : uint8_t;
+enum class OrderByNullType : uint8_t;
+enum class ResultModifierType : uint8_t;
+enum class ExtraTypeInfoType : uint8_t;
+enum class TableReferenceType : uint8_t;
+enum class JoinRefType : uint8_t;
+enum class JoinType : uint8_t;
+enum class AggregateHandling : uint8_t;
+enum class QueryNodeType : uint8_t;
+enum class SetOperationType : uint8_t;
+enum class WindowBoundary : uint8_t;
+enum class SubqueryType : uint8_t;
+enum class ExpressionType : uint8_t;
+enum class ExpressionClass : uint8_t;
+enum class SampleMethod : uint8_t;
+enum class LogicalTypeId : uint8_t;
+
+template <>
+OrderType EnumSerializer::StringToEnum<OrderType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<OrderType>(OrderType value);
+
+template <>
+OrderByNullType EnumSerializer::StringToEnum<OrderByNullType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<OrderByNullType>(OrderByNullType value);
+
+template <>
+ResultModifierType EnumSerializer::StringToEnum<ResultModifierType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ResultModifierType>(ResultModifierType value);
+
+template <>
+ExtraTypeInfoType EnumSerializer::StringToEnum<ExtraTypeInfoType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExtraTypeInfoType>(ExtraTypeInfoType value);
+
+template <>
+TableReferenceType EnumSerializer::StringToEnum<TableReferenceType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<TableReferenceType>(TableReferenceType value);
+
+template <>
+JoinRefType EnumSerializer::StringToEnum<JoinRefType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<JoinRefType>(JoinRefType value);
+
+template <>
+JoinType EnumSerializer::StringToEnum<JoinType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<JoinType>(JoinType value);
+
+template <>
+AggregateHandling EnumSerializer::StringToEnum<AggregateHandling>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<AggregateHandling>(AggregateHandling value);
+
+template <>
+QueryNodeType EnumSerializer::StringToEnum<QueryNodeType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<QueryNodeType>(QueryNodeType value);
+
+template <>
+SetOperationType EnumSerializer::StringToEnum<SetOperationType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SetOperationType>(SetOperationType value);
+
+template <>
+WindowBoundary EnumSerializer::StringToEnum<WindowBoundary>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<WindowBoundary>(WindowBoundary value);
+
+template <>
+SubqueryType EnumSerializer::StringToEnum<SubqueryType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SubqueryType>(SubqueryType value);
+
+template <>
+ExpressionType EnumSerializer::StringToEnum<ExpressionType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExpressionType>(ExpressionType value);
+
+template <>
+ExpressionClass EnumSerializer::StringToEnum<ExpressionClass>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExpressionClass>(ExpressionClass value);
+
+template <>
+SampleMethod EnumSerializer::StringToEnum<SampleMethod>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SampleMethod>(SampleMethod value);
+
+template <>
+LogicalTypeId EnumSerializer::StringToEnum<LogicalTypeId>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<LogicalTypeId>(LogicalTypeId value);
+
+} // namespace duckdb