duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/common/types.cpp

@@ -7,7 +7,11 @@
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/extra_type_info.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/numeric_utils.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/type_visitor.hpp"
 #include "duckdb/common/types/decimal.hpp"
@@ -16,6 +20,7 @@
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/uhugeint.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/cast_rules.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -25,7 +30,6 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 #include "duckdb/parser/parser.hpp"
-#include "duckdb/main/settings.hpp"
 
 #include <cmath>
 
@@ -74,7 +78,6 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::UINT32;
 	case LogicalTypeId::BIGINT:
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_NS:
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_NS:
@@ -111,16 +114,15 @@ PhysicalType LogicalType::GetInternalType() {
 			                        width, DecimalType::MaxWidth());
 		}
 	}
-	case LogicalTypeId::BIGNUM:
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::CHAR:
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::BIT:
+	case LogicalTypeId::VARINT:
 		return PhysicalType::VARCHAR;
 	case LogicalTypeId::INTERVAL:
 		return PhysicalType::INTERVAL;
 	case LogicalTypeId::UNION:
-	case LogicalTypeId::VARIANT:
 	case LogicalTypeId::STRUCT:
 		return PhysicalType::STRUCT;
 	case LogicalTypeId::LIST:
@@ -153,7 +155,6 @@ PhysicalType LogicalType::GetInternalType() {
 	case LogicalTypeId::UNKNOWN:
 	case LogicalTypeId::STRING_LITERAL:
 	case LogicalTypeId::INTEGER_LITERAL:
-	case LogicalTypeId::TEMPLATE:
 		return PhysicalType::INVALID;
 	case LogicalTypeId::USER:
 		return PhysicalType::UNKNOWN;
@@ -194,7 +195,6 @@ constexpr const LogicalTypeId LogicalType::TIMESTAMP_NS;
 constexpr const LogicalTypeId LogicalType::TIMESTAMP_S;
 
 constexpr const LogicalTypeId LogicalType::TIME;
-constexpr const LogicalTypeId LogicalType::TIME_NS;
 
 constexpr const LogicalTypeId LogicalType::TIME_TZ;
 constexpr const LogicalTypeId LogicalType::TIMESTAMP_TZ;
@@ -206,7 +206,7 @@ constexpr const LogicalTypeId LogicalType::VARCHAR;
 
 constexpr const LogicalTypeId LogicalType::BLOB;
 constexpr const LogicalTypeId LogicalType::BIT;
-constexpr const LogicalTypeId LogicalType::BIGNUM;
+constexpr const LogicalTypeId LogicalType::VARINT;
 
 constexpr const LogicalTypeId LogicalType::INTERVAL;
 constexpr const LogicalTypeId LogicalType::ROW_TYPE;
@@ -244,7 +244,7 @@ const vector<LogicalType> LogicalType::AllTypes() {
 	    LogicalType::BOOLEAN,  LogicalType::TINYINT,      LogicalType::SMALLINT,  LogicalType::INTEGER,
 	    LogicalType::BIGINT,   LogicalType::DATE,         LogicalType::TIMESTAMP, LogicalType::DOUBLE,
 	    LogicalType::FLOAT,    LogicalType::VARCHAR,      LogicalType::BLOB,      LogicalType::BIT,
-	    LogicalType::BIGNUM,   LogicalType::INTERVAL,     LogicalType::HUGEINT,   LogicalTypeId::DECIMAL,
+	    LogicalType::VARINT,   LogicalType::INTERVAL,     LogicalType::HUGEINT,   LogicalTypeId::DECIMAL,
 	    LogicalType::UTINYINT, LogicalType::USMALLINT,    LogicalType::UINTEGER,  LogicalType::UBIGINT,
 	    LogicalType::UHUGEINT, LogicalType::TIME,         LogicalTypeId::LIST,    LogicalTypeId::STRUCT,
 	    LogicalType::TIME_TZ,  LogicalType::TIMESTAMP_TZ, LogicalTypeId::MAP,     LogicalTypeId::UNION,
@@ -517,12 +517,6 @@ string LogicalType::ToString() const {
 	case LogicalTypeId::SQLNULL: {
 		return "\"NULL\"";
 	}
-	case LogicalTypeId::TEMPLATE: {
-		if (!type_info_) {
-			return "T";
-		}
-		return TemplateType::GetName(*this);
-	}
 	default:
 		return EnumUtil::ToString(id_);
 	}
@@ -624,10 +618,6 @@ LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context
 	if (type.id() == LogicalTypeId::LIST) {
 		return LogicalType::LIST(GetUserTypeRecursive(ListType::GetChildType(type), context));
 	}
-	if (type.id() == LogicalTypeId::ARRAY) {
-		return LogicalType::ARRAY(GetUserTypeRecursive(ArrayType::GetChildType(type), context),
-		                          ArrayType::GetSize(type));
-	}
 	if (type.id() == LogicalTypeId::MAP) {
 		return LogicalType::MAP(GetUserTypeRecursive(MapType::KeyType(type), context),
 		                        GetUserTypeRecursive(MapType::ValueType(type), context));
@@ -748,7 +738,6 @@ bool LogicalType::IsComplete() const {
 		case LogicalTypeId::INVALID:
 		case LogicalTypeId::UNKNOWN:
 		case LogicalTypeId::ANY:
-		case LogicalTypeId::TEMPLATE:
 			return true; // These are incomplete by default
 		case LogicalTypeId::LIST:
 		case LogicalTypeId::MAP:
@@ -758,7 +747,6 @@ bool LogicalType::IsComplete() const {
 			break;
 		case LogicalTypeId::STRUCT:
 		case LogicalTypeId::UNION:
-		case LogicalTypeId::VARIANT:
 			if (!type.AuxInfo() || type.AuxInfo()->type != ExtraTypeInfoType::STRUCT_TYPE_INFO) {
 				return true; // Missing or incorrect type info
 			}
@@ -796,10 +784,6 @@ bool LogicalType::IsComplete() const {
 	});
 }
 
-bool LogicalType::IsTemplated() const {
-	return TypeVisitor::Contains(*this, LogicalTypeId::TEMPLATE);
-}
-
 bool LogicalType::SupportsRegularUpdate() const {
 	switch (id()) {
 	case LogicalTypeId::LIST:
@@ -978,16 +962,6 @@ LogicalType LogicalType::NormalizeType(const LogicalType &type) {
 
 template <class OP>
 static bool CombineUnequalTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) {
-	D_ASSERT(right.id() != left.id());
-	if (right.id() == LogicalTypeId::VARIANT) {
-		result = right;
-		return true;
-	}
-	if (left.id() == LogicalTypeId::VARIANT) {
-		result = left;
-		return true;
-	}
-
 	// left and right are not equal
 	// NULL/unknown (parameter) types always take the other type
 	LogicalTypeId other_types[] = {LogicalTypeId::SQLNULL, LogicalTypeId::UNKNOWN};
@@ -1024,12 +998,7 @@ static bool CombineUnequalTypes(const LogicalType &left, const LogicalType &righ
 		// we can implicitly cast left to right, return right
 		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
 		if (right.id() == LogicalTypeId::DECIMAL) {
-			if (left.id() == LogicalTypeId::VARIANT) {
-				//! Prefer VARIANT always
-				result = left;
-			} else {
-				result = DecimalSizeCheck(left, right);
-			}
+			result = DecimalSizeCheck(left, right);
 		} else {
 			result = right;
 		}
@@ -1039,12 +1008,7 @@ static bool CombineUnequalTypes(const LogicalType &left, const LogicalType &righ
 		// we can implicitly cast right to left, return left
 		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
 		if (left.id() == LogicalTypeId::DECIMAL) {
-			if (right.id() == LogicalTypeId::VARIANT) {
-				//! Prefer VARIANT always
-				result = right;
-			} else {
-				result = DecimalSizeCheck(right, left);
-			}
+			result = DecimalSizeCheck(right, left);
 		} else {
 			result = left;
 		}
@@ -1103,7 +1067,7 @@ static bool CombineStructTypes(const LogicalType &left, const LogicalType &right
 
 	// Create a super-set of the STRUCT fields.
 	// First, create a name->index map of the right children.
-	InsertionOrderPreservingMap<idx_t> right_children_map;
+	case_insensitive_map_t<idx_t> right_children_map;
 	for (idx_t i = 0; i < right_children.size(); i++) {
 		auto &name = right_children[i].first;
 		right_children_map[name] = i;
@@ -1263,7 +1227,7 @@ struct ForceGetTypeOperation {
 
 bool LogicalType::TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right,
                                        LogicalType &result) {
-	if (DBConfig::GetSetting<OldImplicitCastingSetting>(context)) {
+	if (DBConfig::GetConfig(context).options.old_implicit_casting) {
 		result = LogicalType::ForceMaxLogicalType(left, right);
 		return true;
 	}
@@ -1276,7 +1240,6 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) {
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::UNKNOWN:
 	case LogicalTypeId::ANY:
-	case LogicalTypeId::TEMPLATE:
 	case LogicalTypeId::STRING_LITERAL:
 	case LogicalTypeId::INTEGER_LITERAL:
 		return 0;
@@ -1313,21 +1276,19 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) {
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
 		return 50;
-	case LogicalTypeId::TIME_NS:
-		return 51;
 	case LogicalTypeId::DATE:
-		return 52;
+		return 51;
 	case LogicalTypeId::TIMESTAMP_SEC:
-		return 53;
+		return 52;
 	case LogicalTypeId::TIMESTAMP_MS:
-		return 54;
+		return 53;
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return 55;
+		return 54;
 	case LogicalTypeId::TIMESTAMP_NS:
-		return 56;
+		return 55;
 	case LogicalTypeId::INTERVAL:
-		return 58;
+		return 56;
 	// text/character strings
 	case LogicalTypeId::CHAR:
 		return 75;
@@ -1342,7 +1303,7 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) {
 		return 101;
 	case LogicalTypeId::UUID:
 		return 102;
-	case LogicalTypeId::BIGNUM:
+	case LogicalTypeId::VARINT:
 		return 103;
 	// nested types
 	case LogicalTypeId::STRUCT:
@@ -1352,7 +1313,6 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) {
 		return 126;
 	case LogicalTypeId::MAP:
 		return 127;
-	case LogicalTypeId::VARIANT:
 	case LogicalTypeId::UNION:
 	case LogicalTypeId::TABLE:
 		return 150;
@@ -1455,20 +1415,11 @@ bool ApproxEqual(double ldecimal, double rdecimal) {
 //===--------------------------------------------------------------------===//
 // Extra Type Info
 //===--------------------------------------------------------------------===//
-LogicalType LogicalType::Copy() const {
-	LogicalType copy = *this;
-	if (type_info_ && type_info_->type != ExtraTypeInfoType::ENUM_TYPE_INFO) {
-		// We copy (i.e., create new) type info, unless the type is an ENUM, otherwise we have to copy the whole dict
-		copy.type_info_ = type_info_->Copy();
-	}
-	return copy;
-}
 
 LogicalType LogicalType::DeepCopy() const {
 	LogicalType copy = *this;
-	if (type_info_ && type_info_->type != ExtraTypeInfoType::ENUM_TYPE_INFO) {
-		// We copy (i.e., create new) type info, unless the type is an ENUM, otherwise we have to copy the whole dict
-		copy.type_info_ = type_info_->DeepCopy();
+	if (type_info_) {
+		copy.type_info_ = type_info_->Copy();
 	}
 	return copy;
 }
@@ -1620,8 +1571,7 @@ const string AggregateStateType::GetTypeName(const LogicalType &type) {
 // Struct Type
 //===--------------------------------------------------------------------===//
 const child_list_t<LogicalType> &StructType::GetChildTypes(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION ||
-	         type.id() == LogicalTypeId::VARIANT);
+	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION);
 
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
@@ -1976,44 +1926,6 @@ LogicalType LogicalType::INTEGER_LITERAL(const Value &constant) { // NOLINT
 	return LogicalType(LogicalTypeId::INTEGER_LITERAL, std::move(type_info));
 }
 
-//===--------------------------------------------------------------------===//
-// Template Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::TEMPLATE(const string &name) {
-	D_ASSERT(!name.empty());
-	auto type_info = make_shared_ptr<TemplateTypeInfo>(name);
-	return LogicalType(LogicalTypeId::TEMPLATE, std::move(type_info));
-}
-
-const string &TemplateType::GetName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::TEMPLATE);
-	auto info = type.AuxInfo();
-	D_ASSERT(info->type == ExtraTypeInfoType::TEMPLATE_TYPE_INFO);
-	return info->Cast<TemplateTypeInfo>().name;
-}
-
-//===--------------------------------------------------------------------===//
-// Variant Type
-//===--------------------------------------------------------------------===//
-
-LogicalType LogicalType::VARIANT() {
-	child_list_t<LogicalType> children;
-	//! keys
-	children.emplace_back("keys", LogicalType::LIST(LogicalTypeId::VARCHAR));
-	//! children
-	children.emplace_back("children",
-	                      LogicalType::LIST(LogicalType::STRUCT(
-	                          {{"keys_index", LogicalType::UINTEGER}, {"values_index", LogicalType::UINTEGER}})));
-	//! values
-	children.emplace_back("values", LogicalType::LIST(LogicalType::STRUCT(
-	                                    {{"type_id", LogicalType::UTINYINT}, {"byte_offset", LogicalType::UINTEGER}})));
-	//! data
-	children.emplace_back("data", LogicalType::BLOB);
-
-	auto info = make_shared_ptr<StructTypeInfo>(std::move(children));
-	return LogicalType(LogicalTypeId::VARIANT, std::move(info));
-}
-
 //===--------------------------------------------------------------------===//
 // Logical Type
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/value_operations/comparison_operations.cpp

@@ -3,8 +3,6 @@
 #include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/function/scalar/variant_utils.hpp"
 
 namespace duckdb {
 
@@ -12,8 +10,6 @@ namespace duckdb {
 // Comparison Operations
 //===--------------------------------------------------------------------===//
 
-namespace {
-
 struct ValuePositionComparator {
 	// Return true if the positional Values definitely match.
 	// Default to the same as the final value
@@ -67,11 +63,38 @@ inline bool ValuePositionComparator::Final<duckdb::NotEquals>(const Value &lhs,
 	return ValueOperations::NotDistinctFrom(lhs, rhs);
 }
 
+// Non-strict inequalities must use strict comparisons for Definite
+template <>
+bool ValuePositionComparator::Definite<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
+	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(lhs, rhs);
+}
+
 template <>
 bool ValuePositionComparator::Final<duckdb::GreaterThan>(const Value &lhs, const Value &rhs) {
 	return ValueOperations::DistinctGreaterThan(lhs, rhs);
 }
 
+template <>
+bool ValuePositionComparator::Final<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
+	return !ValuePositionComparator::Final<duckdb::GreaterThan>(lhs, rhs);
+}
+
+template <>
+bool ValuePositionComparator::Definite<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
+	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(rhs, lhs);
+}
+
+template <>
+bool ValuePositionComparator::Final<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
+	return !ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
+}
+
+// Strict inequalities just use strict for both Definite and Final
+template <>
+bool ValuePositionComparator::Final<duckdb::LessThan>(const Value &lhs, const Value &rhs) {
+	return ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
+}
+
 template <class OP>
 static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	const auto &left_type = left.type();
@@ -119,24 +142,6 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	case PhysicalType::VARCHAR:
 		return OP::Operation(StringValue::Get(left), StringValue::Get(right));
 	case PhysicalType::STRUCT: {
-		if (left_type.id() == LogicalTypeId::VARIANT) {
-			Vector left_vec(left.type());
-			Vector right_vec(right.type());
-			left_vec.Reference(left);
-			right_vec.Reference(right);
-
-			RecursiveUnifiedVectorFormat left_format;
-			RecursiveUnifiedVectorFormat right_format;
-			Vector::RecursiveToUnifiedFormat(left_vec, 1, left_format);
-			Vector::RecursiveToUnifiedFormat(right_vec, 1, right_format);
-
-			UnifiedVariantVectorData left_variant_data(left_format);
-			UnifiedVariantVectorData right_variant_data(right_format);
-
-			auto left_value = VariantUtils::ConvertVariantToValue(left_variant_data, 0, 0);
-			auto right_value = VariantUtils::ConvertVariantToValue(right_variant_data, 0, 0);
-			return TemplatedBooleanOperation<OP>(left_value, right_value);
-		}
 		auto &left_children = StructValue::GetChildren(left);
 		auto &right_children = StructValue::GetChildren(right);
 		// this should be enforced by the type
@@ -190,8 +195,6 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	}
 }
 
-} // namespace
-
 bool ValueOperations::Equals(const Value &left, const Value &right) {
 	if (left.IsNull() || right.IsNull()) {
 		throw InternalException("Comparison on NULL values");

package/src/duckdb/src/common/vector_operations/boolean_operators.cpp

@@ -10,12 +10,11 @@
 
 namespace duckdb {
 
-namespace {
 //===--------------------------------------------------------------------===//
 // AND/OR
 //===--------------------------------------------------------------------===//
 template <class OP>
-void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result, idx_t count) {
+static void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result, idx_t count) {
 	D_ASSERT(left.GetType().id() == LogicalTypeId::BOOLEAN && right.GetType().id() == LogicalTypeId::BOOLEAN &&
 	         result.GetType().id() == LogicalTypeId::BOOLEAN);
 
@@ -106,6 +105,10 @@ struct TernaryAnd {
 	}
 };
 
+void VectorOperations::And(Vector &left, Vector &right, Vector &result, idx_t count) {
+	TemplatedBooleanNullmask<TernaryAnd>(left, right, result, count);
+}
+
 /*
 SQL OR Rules:
 
@@ -155,6 +158,10 @@ struct TernaryOr {
 	}
 };
 
+void VectorOperations::Or(Vector &left, Vector &right, Vector &result, idx_t count) {
+	TemplatedBooleanNullmask<TernaryOr>(left, right, result, count);
+}
+
 struct NotOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -162,16 +169,6 @@ struct NotOperator {
 	}
 };
 
-} // namespace
-
-void VectorOperations::And(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryAnd>(left, right, result, count);
-}
-
-void VectorOperations::Or(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryOr>(left, right, result, count);
-}
-
 void VectorOperations::Not(Vector &input, Vector &result, idx_t count) {
 	D_ASSERT(input.GetType() == LogicalType::BOOLEAN && result.GetType() == LogicalType::BOOLEAN);
 	UnaryExecutor::Execute<bool, bool, NotOperator>(input, result, count);

package/src/duckdb/src/common/vector_operations/comparison_operators.cpp

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 template <class T>
-static bool EqualsFloat(T left, T right) {
+bool EqualsFloat(T left, T right) {
 	if (DUCKDB_UNLIKELY(Value::IsNan(left) && Value::IsNan(right))) {
 		return true;
 	}
@@ -33,7 +33,7 @@ bool Equals::Operation(const double &left, const double &right) {
 }
 
 template <class T>
-static bool GreaterThanFloat(T left, T right) {
+bool GreaterThanFloat(T left, T right) {
 	// handle nans
 	// nan is always bigger than everything else
 	bool left_is_nan = Value::IsNan(left);
@@ -60,7 +60,7 @@ bool GreaterThan::Operation(const double &left, const double &right) {
 }
 
 template <class T>
-static bool GreaterThanEqualsFloat(T left, T right) {
+bool GreaterThanEqualsFloat(T left, T right) {
 	// handle nans
 	// nan is always bigger than everything else
 	bool left_is_nan = Value::IsNan(left);
@@ -86,7 +86,7 @@ template <>
 bool GreaterThanEquals::Operation(const double &left, const double &right) {
 	return GreaterThanEqualsFloat<double>(left, right);
 }
-namespace {
+
 struct ComparisonSelector {
 	template <typename OP>
 	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
@@ -280,7 +280,6 @@ public:
 		}
 	}
 };
-} // namespace
 
 void VectorOperations::Equals(Vector &left, Vector &right, Vector &result, idx_t count) {
 	ComparisonExecutor::Execute<duckdb::Equals>(left, right, result, count);

package/src/duckdb/src/common/vector_operations/generators.cpp

@@ -11,7 +11,7 @@
 namespace duckdb {
 
 template <class T>
-static void TemplatedGenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
+void TemplatedGenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
 	D_ASSERT(result.GetType().IsNumeric());
 	if (start > NumericLimits<T>::Maximum() || increment > NumericLimits<T>::Maximum()) {
 		throw InternalException("Sequence start or increment out of type range");