duckdb 0.7.2-dev1034.0 → 0.7.2-dev1146.0

package/src/duckdb/src/function/cast_rules.cpp

@@ -207,6 +207,15 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// if aliases are different, an implicit cast is not possible
 		return -1;
 	}
+	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
+		// Lists can be cast if their child types can be cast
+		auto child_cost = ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
+		if (child_cost >= 100) {
+			// subtract one from the cost because we prefer LIST[X] -> LIST[VARCHAR] over LIST[X] -> VARCHAR
+			child_cost--;
+		}
+		return child_cost;
+	}
 	if (from.id() == to.id()) {
 		// arguments match: do nothing
 		return 0;
@@ -219,10 +228,6 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// everything can be cast to VARCHAR, but this cast has a high cost
 		return TargetTypeCost(to);
 	}
-	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
-		// Lists can be cast if their child types can be cast
-		return ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
-	}
 
 	if (from.id() == LogicalTypeId::UNION && to.id() == LogicalTypeId::UNION) {
 		// Unions can be cast if the source tags are a subset of the target tags

package/src/duckdb/src/function/scalar/list/list_sort.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -243,28 +244,30 @@ static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunct
 	return make_unique<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
 }
 
-OrderByNullType GetNullOrder(ClientContext &context, vector<unique_ptr<Expression>> &arguments, idx_t idx) {
+static OrderByNullType GetNullOrder(ClientContext &context, vector<unique_ptr<Expression>> &arguments, idx_t idx) {
 
 	if (!arguments[idx]->IsFoldable()) {
 		throw InvalidInputException("Null sorting order must be a constant");
 	}
 	Value null_order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[idx]);
 	auto null_order_name = StringUtil::Upper(null_order_value.ToString());
-	if (null_order_name != "NULLS FIRST" && null_order_name != "NULLS LAST") {
-		throw InvalidInputException("Null sorting order must be either NULLS FIRST or NULLS LAST");
+	const auto null_order_arg = EnumSerializer::StringToEnum<OrderByNullType>(null_order_name.c_str());
+	switch (null_order_arg) {
+	case OrderByNullType::NULLS_FIRST:
+	case OrderByNullType::NULLS_LAST:
+		return null_order_arg;
+	case OrderByNullType::ORDER_DEFAULT:
+		return DBConfig::GetConfig(context).options.default_null_order;
+	default:
+		throw InvalidInputException("Null sorting order must be either NULLS FIRST, NULLS LAST or DEFAULT");
 	}
-
-	if (null_order_name == "NULLS LAST") {
-		return OrderByNullType::NULLS_LAST;
-	}
-	return OrderByNullType::NULLS_FIRST;
 }
 
 static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
 
-	D_ASSERT(bound_function.arguments.size() >= 1 && bound_function.arguments.size() <= 3);
-	D_ASSERT(arguments.size() >= 1 && arguments.size() <= 3);
+	D_ASSERT(!bound_function.arguments.empty() && bound_function.arguments.size() <= 3);
+	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
 
 	// set default values
 	auto &config = DBConfig::GetConfig(context);
@@ -278,14 +281,18 @@ static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, Scala
 			throw InvalidInputException("Sorting order must be a constant");
 		}
 		Value order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		auto order_name = StringUtil::Upper(order_value.ToString());
-		if (order_name != "DESC" && order_name != "ASC") {
-			throw InvalidInputException("Sorting order must be either ASC or DESC");
-		}
-		if (order_name == "DESC") {
-			order = OrderType::DESCENDING;
-		} else {
-			order = OrderType::ASCENDING;
+
+		const auto order_name = StringUtil::Upper(order_value.ToString());
+		const auto order_arg = EnumSerializer::StringToEnum<OrderType>(order_name.c_str());
+		switch (order_arg) {
+		case OrderType::ASCENDING:
+		case OrderType::DESCENDING:
+			order = order_arg;
+			break;
+		case OrderType::ORDER_DEFAULT:
+			break;
+		default:
+			throw InvalidInputException("Sorting order must be either ASC, DESC or DEFAULT");
 		}
 	}
 

package/src/duckdb/src/function/table/read_csv.cpp

@@ -861,6 +861,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["buffer_size"] = LogicalType::UBIGINT;
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
 }
 
 double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
@@ -928,6 +929,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	// read options
 	writer.WriteList<string>(names);
 	writer.WriteField<idx_t>(skip_rows);
+	writer.WriteField<bool>(skip_rows_set);
 	writer.WriteField<idx_t>(maximum_line_size);
 	writer.WriteField<bool>(normalize_names);
 	writer.WriteListNoReference<bool>(force_not_null);
@@ -939,6 +941,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(include_file_name);
 	writer.WriteField<bool>(include_parsed_hive_partitions);
 	writer.WriteString(decimal_separator);
+	writer.WriteField<bool>(null_padding);
 	// write options
 	writer.WriteListNoReference<bool>(force_quote);
 }
@@ -961,6 +964,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	// read options
 	names = reader.ReadRequiredList<string>();
 	skip_rows = reader.ReadRequired<idx_t>();
+	skip_rows_set = reader.ReadRequired<bool>();
 	maximum_line_size = reader.ReadRequired<idx_t>();
 	normalize_names = reader.ReadRequired<bool>();
 	force_not_null = reader.ReadRequiredList<bool>();
@@ -972,6 +976,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	include_file_name = reader.ReadRequired<bool>();
 	include_parsed_hive_partitions = reader.ReadRequired<bool>();
 	decimal_separator = reader.ReadRequired<string>();
+	null_padding = reader.ReadRequired<bool>();
 	// write options
 	force_quote = reader.ReadRequiredList<bool>();
 }

package/src/duckdb/src/function/table/table_scan.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/function/table/table_scan.hpp"
 
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/mutex.hpp"
@@ -15,6 +14,7 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 namespace duckdb {
 
@@ -40,17 +40,14 @@ static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
 }
 
 struct TableScanGlobalState : public GlobalTableFunctionState {
-	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) : row_count(0) {
+	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
 		D_ASSERT(bind_data_p);
 		auto &bind_data = (const TableScanBindData &)*bind_data_p;
 		max_threads = bind_data.table->GetStorage().MaxThreads(context);
 	}
 
 	ParallelTableScanState state;
-	mutex lock;
 	idx_t max_threads;
-	//! How many rows we already scanned
-	atomic<idx_t> row_count;
 
 	vector<idx_t> projection_ids;
 	vector<LogicalType> scanned_types;
@@ -131,7 +128,6 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 			storage.Scan(transaction, output, state.scan_state);
 		}
 		if (output.size() > 0) {
-			gstate.row_count += output.size();
 			return;
 		}
 		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
@@ -147,7 +143,6 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	auto &state = (TableScanLocalState &)*local_state;
 	auto &storage = bind_data.table->GetStorage();
 
-	lock_guard<mutex> parallel_lock(parallel_state.lock);
 	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
 }
 
@@ -161,7 +156,9 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
 	}
-	auto percentage = 100 * (double(gstate.row_count) / total_rows);
+	idx_t scanned_rows = gstate.state.scan_state.processed_rows;
+	scanned_rows += gstate.state.local_state.processed_rows;
+	auto percentage = 100 * (double(scanned_rows) / total_rows);
 	if (percentage > 100) {
 		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
 		//! It means we finished this table.
@@ -171,12 +168,12 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 }
 
 idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
-                             LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
+                             LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate_p) {
 	auto &state = (TableScanLocalState &)*local_state;
-	if (state.scan_state.table_state.row_group_state.row_group) {
+	if (state.scan_state.table_state.row_group) {
 		return state.scan_state.table_state.batch_index;
 	}
-	if (state.scan_state.local_state.row_group_state.row_group) {
+	if (state.scan_state.local_state.row_group) {
 		return state.scan_state.table_state.batch_index + state.scan_state.local_state.batch_index;
 	}
 	return 0;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1034"
+#define DUCKDB_VERSION "0.7.2-dev1146"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "18142dcc4b"
+#define DUCKDB_SOURCE_ID "b8cf6a98e2"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -114,7 +114,7 @@ const T Load(const_data_ptr_t ptr) {
 }
 
 template <typename T>
-void Store(const T val, data_ptr_t ptr) {
+void Store(const T &val, data_ptr_t ptr) {
 	memcpy(ptr, (void *)&val, sizeof(val));
 }
 

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/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/types/interval.hpp

@@ -101,8 +101,44 @@ public:
 	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
 
 	//! Comparison operators
-	static bool Equals(interval_t left, interval_t right);
-	static bool GreaterThan(interval_t left, interval_t right);
-	static bool GreaterThanEquals(interval_t left, interval_t right);
+	inline static bool Equals(const interval_t &left, const interval_t &right);
+	inline static bool GreaterThan(const interval_t &left, const interval_t &right);
 };
+static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
+	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
+	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
+	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
+	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
+
+	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;
+	input.micros -= extra_days_micros * Interval::MICROS_PER_DAY;
+
+	months = input.months + extra_months_d + extra_months_micros;
+	days = input.days + extra_days_micros;
+	micros = input.micros;
+}
+
+bool Interval::Equals(const interval_t &left, const interval_t &right) {
+	return left.months == right.months && left.days == right.days && left.micros == right.micros;
+}
+
+bool Interval::GreaterThan(const interval_t &left, const interval_t &right) {
+	int64_t lmonths, ldays, lmicros;
+	int64_t rmonths, rdays, rmicros;
+	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
+	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
+
+	if (lmonths > rmonths) {
+		return true;
+	} else if (lmonths < rmonths) {
+		return false;
+	}
+	if (ldays > rdays) {
+		return true;
+	} else if (ldays < rdays) {
+		return false;
+	}
+	return lmicros > rmicros;
+}
+
 } // namespace duckdb