samredai commented on a change in pull request #3839:
URL: https://github.com/apache/iceberg/pull/3839#discussion_r783446761
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A boolean data type in Iceberg can be represented using an instance of
this class.
Example:
>>> column_foo = BooleanType()
>>> isinstance(column_foo, BooleanType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Date data type in Iceberg can be represented using an instance of this
class. Dates in Iceberg are
calendar dates without a timezone or time.
Example:
>>> column_foo = DateType()
>>> isinstance(column_foo, DateType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Long data type in Iceberg can be represented using an instance of this
class. Longs in Iceberg are
64-bit signed integers.
Example:
>>> column_foo = LongType()
>>> isinstance(column_foo, LongType)
True
Attributes:
max (int): The maximum allowed value for Longs, inherited from the
canonical Iceberg implementation
in Java. (returns `9223372036854775807`)
min (int): The minimum allowed value for Longs, inherited from the
canonical Iceberg implementation
in Java (returns `-9223372036854775808`)
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Double data type in Iceberg can be represented using an instance of
this class. Doubles in Iceberg are
64-bit IEEE 754 floating points.
Example:
>>> column_foo = DoubleType()
>>> isinstance(column_foo, DoubleType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Float data type in Iceberg can be represented using an instance of
this class. Floats in Iceberg are
32-bit IEEE 754 floating points and can be promoted to Doubles.
Example:
>>> column_foo = FloatType()
>>> isinstance(column_foo, FloatType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
An Integer data type in Iceberg can be represented using an instance of
this class. Integers in Iceberg are
32-bit signed and can be promoted to Longs.
Example:
>>> column_foo = IntegerType()
>>> isinstance(column_foo, IntegerType)
True
Attributes:
max (int): The maximum allowed value for Integers, inherited from
the canonical Iceberg implementation
in Java (returns `2147483647`)
min (int): The minimum allowed value for Integers, inherited from
the canonical Iceberg implementation
in Java (returns `-2147483648`)
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("time", "TimeType", is_primitive=True)
+
+
+class Timestamp(Type):
+ """`timestamp` type from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Timestamp data type in Iceberg can be represented using an instance of
this class. Timestamps in
Iceberg have microsecond precision and include a date and a time of day
without a timezone.
Example:
>>> column_foo = TimestampType()
>>> isinstance(column_foo, TimestampType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Time data type in Iceberg can be represented using an instance of this
class. Times in Iceberg
have microsecond precision and are a time of day without a date or
timezone.
Example:
>>> column_foo = TimeType()
>>> isinstance(column_foo, TimeType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("time", "TimeType", is_primitive=True)
+
+
+class Timestamp(Type):
+ """`timestamp` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamp", "TimestampType", is_primitive=True)
+
+
+class Timestamptz(Type):
+ """`timestamptz` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamptz", "TimestamptzType", is_primitive=True)
+
+
+class String(Type):
+ """Arbitrary-length character sequences Encoded with UTF-8: `string` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("string", "StringType", is_primitive=True)
+
+
+class UUID(Type):
+ """Universally unique identifiers: `uuid` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("uuid", "UUIDType", is_primitive=True)
+
+
+class Binary(Type):
+ """Arbitrary-length byte array from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Binary data type in Iceberg can be represented using an instance of
this class. Binarys in
Iceberg are arbitrary-length byte arrays.
Example:
>>> column_foo = BinaryType()
>>> isinstance(column_foo, BinaryType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("time", "TimeType", is_primitive=True)
+
+
+class Timestamp(Type):
+ """`timestamp` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamp", "TimestampType", is_primitive=True)
+
+
+class Timestamptz(Type):
+ """`timestamptz` type from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A Timestamptz data type in Iceberg can be represented using an instance
of this class. Timestamptzs in
Iceberg are stored as UTC and include a date and a time of day with a
timezone.
Example:
>>> column_foo = TimestamptzType()
>>> isinstance(column_foo, TimestamptzType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
Instead of including the link to the primitive types section of the
docstring for each class, I'm realizing it really applies to this entire file
so maybe it would be better as a module-level docstring on line 1. Something
like this:
```py
"""Data types used in describing Iceberg schemas
This module implements the data types described in the Iceberg specification
for Iceberg schemas. To
describe an Iceberg table schema, these classes can be used in the
construction of a StructType instance.
Example:
>>> StructType(
[
NestedField(True, 1, "required_field", StringType()),
NestedField(False, 2, "optional_field", IntegerType()),
]
)
Notes:
- https://iceberg.apache.org/#spec/#primitive-types
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("time", "TimeType", is_primitive=True)
+
+
+class Timestamp(Type):
+ """`timestamp` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamp", "TimestampType", is_primitive=True)
+
+
+class Timestamptz(Type):
+ """`timestamptz` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamptz", "TimestamptzType", is_primitive=True)
+
+
+class String(Type):
+ """Arbitrary-length character sequences Encoded with UTF-8: `string` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("string", "StringType", is_primitive=True)
+
+
+class UUID(Type):
+ """Universally unique identifiers: `uuid` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A UUID data type in Iceberg can be represented using an instance of this
class. UUIDs in
Iceberg are universally unique identifiers.
Example:
>>> column_foo = UUIDType()
>>> isinstance(column_foo, UUIDType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
##########
File path: python/src/iceberg/types.py
##########
@@ -157,15 +157,107 @@ def value(self) -> NestedField:
return self._value_field
-BooleanType = Type("boolean", "BooleanType", is_primitive=True)
-IntegerType = Type("int", "IntegerType", is_primitive=True)
-LongType = Type("long", "LongType", is_primitive=True)
-FloatType = Type("float", "FloatType", is_primitive=True)
-DoubleType = Type("double", "DoubleType", is_primitive=True)
-DateType = Type("date", "DateType", is_primitive=True)
-TimeType = Type("time", "TimeType", is_primitive=True)
-TimestampType = Type("timestamp", "TimestampType", is_primitive=True)
-TimestamptzType = Type("timestamptz", "TimestamptzType", is_primitive=True)
-StringType = Type("string", "StringType", is_primitive=True)
-UUIDType = Type("uuid", "UUIDType", is_primitive=True)
-BinaryType = Type("binary", "BinaryType", is_primitive=True)
+class Boolean(Type):
+ """`boolean` from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("boolean", "BooleanType", is_primitive=True)
+
+
+class Integer(Type):
+ """32-bit signed integers: `int` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 2147483647
+
+ min: int = -2147483648
+
+ def __init__(self):
+ super().__init__("int", "IntegerType", is_primitive=True)
+
+
+class Long(Type):
+ """64-bit signed integers: `long` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ max: int = 9223372036854775807
+
+ min: int = -9223372036854775808
+
+ def __init__(self):
+ super().__init__("long", "LongType", is_primitive=True)
+
+
+class Float(Type):
+ """32-bit IEEE 754 floating point: `float` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("float", "FloatType", is_primitive=True)
+
+
+class Double(Type):
+ """64-bit IEEE 754 floating point: `double` from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("double", "DoubleType", is_primitive=True)
+
+
+class Date(Type):
+ """`date` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("date", "DateType", is_primitive=True)
+
+
+class Time(Type):
+ """`time` type from https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("time", "TimeType", is_primitive=True)
+
+
+class Timestamp(Type):
+ """`timestamp` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamp", "TimestampType", is_primitive=True)
+
+
+class Timestamptz(Type):
+ """`timestamptz` type from
https://iceberg.apache.org/#spec/#primitive-types""";
+
+ def __init__(self):
+ super().__init__("timestamptz", "TimestamptzType", is_primitive=True)
+
+
+class String(Type):
+ """Arbitrary-length character sequences Encoded with UTF-8: `string` from
https://iceberg.apache.org/#spec/#primitive-types""";
Review comment:
```py
"""A primitive data type for an Iceberg schema
A String data type in Iceberg can be represented using an instance of
this class. Strings in
Iceberg are arbitrary-length character sequences and are encoded with
UTF-8.
Example:
>>> column_foo = StringType()
>>> isinstance(column_foo, StringType)
True
Attributes:
is_primitive (bool): Specifies whether this is a primitive Iceberg
schema data type (as opposed to a
nested Iceberg schema data type)
"""
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
