| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| from __future__ import annotations |
|
|
| import uuid |
| from abc import ABC, abstractmethod |
| from dataclasses import dataclass |
| from datetime import date, datetime, time |
| from functools import cached_property, singledispatch |
| from typing import ( |
| Any, |
| Dict, |
| Generic, |
| List, |
| Optional, |
| Tuple, |
| TypeVar, |
| ) |
| from urllib.parse import quote |
|
|
| from pydantic import ( |
| BeforeValidator, |
| Field, |
| PlainSerializer, |
| WithJsonSchema, |
| ) |
| from typing_extensions import Annotated |
|
|
| from pyiceberg.schema import Schema |
| from pyiceberg.transforms import ( |
| BucketTransform, |
| DayTransform, |
| HourTransform, |
| IdentityTransform, |
| Transform, |
| TruncateTransform, |
| UnknownTransform, |
| VoidTransform, |
| YearTransform, |
| parse_transform, |
| ) |
| from pyiceberg.typedef import IcebergBaseModel, Record |
| from pyiceberg.types import ( |
| DateType, |
| IcebergType, |
| NestedField, |
| PrimitiveType, |
| StructType, |
| TimestampType, |
| TimestamptzType, |
| TimeType, |
| UUIDType, |
| ) |
| from pyiceberg.utils.datetime import date_to_days, datetime_to_micros, time_to_micros |
|
|
| INITIAL_PARTITION_SPEC_ID = 0 |
| PARTITION_FIELD_ID_START: int = 1000 |
|
|
|
|
| class PartitionField(IcebergBaseModel): |
| """PartitionField represents how one partition value is derived from the source column via transformation. |
| |
| Attributes: |
| source_id(int): The source column id of table's schema. |
| field_id(int): The partition field id across all the table partition specs. |
| transform(Transform): The transform used to produce partition values from source column. |
| name(str): The name of this partition field. |
| """ |
|
|
| source_id: int = Field(alias="source-id") |
| field_id: int = Field(alias="field-id") |
| transform: Annotated[ |
| Transform, |
| BeforeValidator(parse_transform), |
| PlainSerializer(lambda c: str(c), return_type=str), |
| WithJsonSchema({"type": "string"}, mode="serialization"), |
| ] = Field() |
| name: str = Field() |
|
|
| def __init__( |
| self, |
| source_id: Optional[int] = None, |
| field_id: Optional[int] = None, |
| transform: Optional[Transform[Any, Any]] = None, |
| name: Optional[str] = None, |
| **data: Any, |
| ): |
| if source_id is not None: |
| data["source-id"] = source_id |
| if field_id is not None: |
| data["field-id"] = field_id |
| if transform is not None: |
| data["transform"] = transform |
| if name is not None: |
| data["name"] = name |
|
|
| super().__init__(**data) |
|
|
| def __str__(self) -> str: |
| """Return the string representation of the PartitionField class.""" |
| return f"{self.field_id}: {self.name}: {self.transform}({self.source_id})" |
|
|
|
|
| class PartitionSpec(IcebergBaseModel): |
| """ |
| PartitionSpec captures the transformation from table data to partition values. |
| |
| Attributes: |
| spec_id(int): any change to PartitionSpec will produce a new specId. |
| fields(Tuple[PartitionField): list of partition fields to produce partition values. |
| """ |
|
|
| spec_id: int = Field(alias="spec-id", default=INITIAL_PARTITION_SPEC_ID) |
| fields: Tuple[PartitionField, ...] = Field(default_factory=tuple) |
|
|
| def __init__( |
| self, |
| *fields: PartitionField, |
| **data: Any, |
| ): |
| if fields: |
| data["fields"] = tuple(fields) |
| super().__init__(**data) |
|
|
| def __eq__(self, other: Any) -> bool: |
| """ |
| Produce a boolean to return True if two objects are considered equal. |
| |
| Note: |
| Equality of PartitionSpec is determined by spec_id and partition fields only. |
| """ |
| if not isinstance(other, PartitionSpec): |
| return False |
| return self.spec_id == other.spec_id and self.fields == other.fields |
|
|
| def __str__(self) -> str: |
| """ |
| Produce a human-readable string representation of PartitionSpec. |
| |
| Note: |
| Only include list of partition fields in the PartitionSpec's string representation. |
| """ |
| result_str = "[" |
| if self.fields: |
| result_str += "\n " + "\n ".join([str(field) for field in self.fields]) + "\n" |
| result_str += "]" |
| return result_str |
|
|
| def __repr__(self) -> str: |
| """Return the string representation of the PartitionSpec class.""" |
| fields = f"{', '.join(repr(column) for column in self.fields)}, " if self.fields else "" |
| return f"PartitionSpec({fields}spec_id={self.spec_id})" |
|
|
| def is_unpartitioned(self) -> bool: |
| return not self.fields |
|
|
| @property |
| def last_assigned_field_id(self) -> int: |
| if self.fields: |
| return max(pf.field_id for pf in self.fields) |
| return PARTITION_FIELD_ID_START - 1 |
|
|
| @cached_property |
| def source_id_to_fields_map(self) -> Dict[int, List[PartitionField]]: |
| source_id_to_fields_map: Dict[int, List[PartitionField]] = {} |
| for partition_field in self.fields: |
| existing = source_id_to_fields_map.get(partition_field.source_id, []) |
| existing.append(partition_field) |
| source_id_to_fields_map[partition_field.source_id] = existing |
| return source_id_to_fields_map |
|
|
| def fields_by_source_id(self, field_id: int) -> List[PartitionField]: |
| return self.source_id_to_fields_map.get(field_id, []) |
|
|
| def compatible_with(self, other: PartitionSpec) -> bool: |
| """Produce a boolean to return True if two PartitionSpec are considered compatible.""" |
| if self == other: |
| return True |
| if len(self.fields) != len(other.fields): |
| return False |
| return all( |
| this_field.source_id == that_field.source_id |
| and this_field.transform == that_field.transform |
| and this_field.name == that_field.name |
| for this_field, that_field in zip(self.fields, other.fields) |
| ) |
|
|
| def partition_type(self, schema: Schema) -> StructType: |
| """Produce a struct of the PartitionSpec. |
| |
| The partition fields should be optional: |
| |
| - All partition transforms are required to produce null if the input value is null, so it can |
| happen when the source column is optional. |
| - Partition fields may be added later, in which case not all files would have the result field, |
| and it may be null. |
| |
| There is a case where we can guarantee that a partition field in the first and only partition spec |
| that uses a required source column will never be null, but it doesn't seem worth tracking this case. |
| |
| :param schema: The schema to bind to. |
| :return: A StructType that represents the PartitionSpec, with a NestedField for each PartitionField. |
| """ |
| nested_fields = [] |
| for field in self.fields: |
| source_type = schema.find_type(field.source_id) |
| result_type = field.transform.result_type(source_type) |
| required = schema.find_field(field.source_id).required |
| nested_fields.append(NestedField(field.field_id, field.name, result_type, required=required)) |
| return StructType(*nested_fields) |
|
|
| def partition_to_path(self, data: Record, schema: Schema) -> str: |
| partition_type = self.partition_type(schema) |
| field_types = partition_type.fields |
|
|
| field_strs = [] |
| value_strs = [] |
| for pos in range(len(self.fields)): |
| partition_field = self.fields[pos] |
| value_str = partition_field.transform.to_human_string(field_types[pos].field_type, value=data[pos]) |
|
|
| value_str = quote(value_str, safe="") |
| value_strs.append(value_str) |
| field_strs.append(partition_field.name) |
|
|
| path = "/".join([field_str + "=" + value_str for field_str, value_str in zip(field_strs, value_strs)]) |
| return path |
|
|
|
|
| UNPARTITIONED_PARTITION_SPEC = PartitionSpec(spec_id=0) |
|
|
|
|
| def assign_fresh_partition_spec_ids(spec: PartitionSpec, old_schema: Schema, fresh_schema: Schema) -> PartitionSpec: |
| partition_fields = [] |
| for pos, field in enumerate(spec.fields): |
| original_column_name = old_schema.find_column_name(field.source_id) |
| if original_column_name is None: |
| raise ValueError(f"Could not find in old schema: {field}") |
| fresh_field = fresh_schema.find_field(original_column_name) |
| if fresh_field is None: |
| raise ValueError(f"Could not find field in fresh schema: {original_column_name}") |
| partition_fields.append( |
| PartitionField( |
| name=field.name, |
| source_id=fresh_field.field_id, |
| field_id=PARTITION_FIELD_ID_START + pos, |
| transform=field.transform, |
| ) |
| ) |
| return PartitionSpec(*partition_fields, spec_id=INITIAL_PARTITION_SPEC_ID) |
|
|
|
|
| T = TypeVar("T") |
|
|
|
|
| class PartitionSpecVisitor(Generic[T], ABC): |
| @abstractmethod |
| def identity(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit identity partition field.""" |
|
|
| @abstractmethod |
| def bucket(self, field_id: int, source_name: str, source_id: int, num_buckets: int) -> T: |
| """Visit bucket partition field.""" |
|
|
| @abstractmethod |
| def truncate(self, field_id: int, source_name: str, source_id: int, width: int) -> T: |
| """Visit truncate partition field.""" |
|
|
| @abstractmethod |
| def year(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit year partition field.""" |
|
|
| @abstractmethod |
| def month(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit month partition field.""" |
|
|
| @abstractmethod |
| def day(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit day partition field.""" |
|
|
| @abstractmethod |
| def hour(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit hour partition field.""" |
|
|
| @abstractmethod |
| def always_null(self, field_id: int, source_name: str, source_id: int) -> T: |
| """Visit void partition field.""" |
|
|
| @abstractmethod |
| def unknown(self, field_id: int, source_name: str, source_id: int, transform: str) -> T: |
| """Visit unknown partition field.""" |
| raise ValueError(f"Unknown transform is not supported: {transform}") |
|
|
|
|
| class _PartitionNameGenerator(PartitionSpecVisitor[str]): |
| def identity(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name |
|
|
| def bucket(self, field_id: int, source_name: str, source_id: int, num_buckets: int) -> str: |
| return f"{source_name}_bucket_{num_buckets}" |
|
|
| def truncate(self, field_id: int, source_name: str, source_id: int, width: int) -> str: |
| return source_name + "_trunc_" + str(width) |
|
|
| def year(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name + "_year" |
|
|
| def month(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name + "_month" |
|
|
| def day(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name + "_day" |
|
|
| def hour(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name + "_hour" |
|
|
| def always_null(self, field_id: int, source_name: str, source_id: int) -> str: |
| return source_name + "_null" |
|
|
| def unknown(self, field_id: int, source_name: str, source_id: int, transform: str) -> str: |
| return super().unknown(field_id, source_name, source_id, transform) |
|
|
|
|
| R = TypeVar("R") |
|
|
|
|
| @singledispatch |
| def _visit(spec: PartitionSpec, schema: Schema, visitor: PartitionSpecVisitor[R]) -> List[R]: |
| return [_visit_partition_field(schema, field, visitor) for field in spec.fields] |
|
|
|
|
| def _visit_partition_field(schema: Schema, field: PartitionField, visitor: PartitionSpecVisitor[R]) -> R: |
| source_name = schema.find_column_name(field.source_id) |
| if not source_name: |
| raise ValueError(f"Could not find field with id {field.source_id}") |
|
|
| transform = field.transform |
| if isinstance(transform, IdentityTransform): |
| return visitor.identity(field.field_id, source_name, field.source_id) |
| elif isinstance(transform, BucketTransform): |
| return visitor.bucket(field.field_id, source_name, field.source_id, transform.num_buckets) |
| elif isinstance(transform, TruncateTransform): |
| return visitor.truncate(field.field_id, source_name, field.source_id, transform.width) |
| elif isinstance(transform, DayTransform): |
| return visitor.day(field.field_id, source_name, field.source_id) |
| elif isinstance(transform, HourTransform): |
| return visitor.hour(field.field_id, source_name, field.source_id) |
| elif isinstance(transform, YearTransform): |
| return visitor.year(field.field_id, source_name, field.source_id) |
| elif isinstance(transform, VoidTransform): |
| return visitor.always_null(field.field_id, source_name, field.source_id) |
| elif isinstance(transform, UnknownTransform): |
| return visitor.unknown(field.field_id, source_name, field.source_id, repr(transform)) |
| else: |
| raise ValueError(f"Unknown transform {transform}") |
|
|
|
|
| @dataclass(frozen=True) |
| class PartitionFieldValue: |
| field: PartitionField |
| value: Any |
|
|
|
|
| @dataclass(frozen=True) |
| class PartitionKey: |
| raw_partition_field_values: List[PartitionFieldValue] |
| partition_spec: PartitionSpec |
| schema: Schema |
|
|
| @cached_property |
| def partition(self) -> Record: |
| iceberg_typed_key_values = {} |
| for raw_partition_field_value in self.raw_partition_field_values: |
| partition_fields = self.partition_spec.source_id_to_fields_map[raw_partition_field_value.field.source_id] |
| if len(partition_fields) != 1: |
| raise ValueError(f"Cannot have redundant partitions: {partition_fields}") |
| partition_field = partition_fields[0] |
| iceberg_typed_key_values[partition_field.name] = partition_record_value( |
| partition_field=partition_field, |
| value=raw_partition_field_value.value, |
| schema=self.schema, |
| ) |
| return Record(**iceberg_typed_key_values) |
|
|
| def to_path(self) -> str: |
| return self.partition_spec.partition_to_path(self.partition, self.schema) |
|
|
|
|
| def partition_record_value(partition_field: PartitionField, value: Any, schema: Schema) -> Any: |
| """ |
| Return the Partition Record representation of the value. |
| |
| The value is first converted to internal partition representation. |
| For example, UUID is converted to bytes[16], DateType to days since epoch, etc. |
| |
| Then the corresponding PartitionField's transform is applied to return |
| the final partition record value. |
| """ |
| iceberg_type = schema.find_field(name_or_id=partition_field.source_id).field_type |
| iceberg_typed_value = _to_partition_representation(iceberg_type, value) |
| transformed_value = partition_field.transform.transform(iceberg_type)(iceberg_typed_value) |
| return transformed_value |
|
|
|
|
| @singledispatch |
| def _to_partition_representation(type: IcebergType, value: Any) -> Any: |
| return TypeError(f"Unsupported partition field type: {type}") |
|
|
|
|
| @_to_partition_representation.register(TimestampType) |
| @_to_partition_representation.register(TimestamptzType) |
| def _(type: IcebergType, value: Optional[datetime]) -> Optional[int]: |
| return datetime_to_micros(value) if value is not None else None |
|
|
|
|
| @_to_partition_representation.register(DateType) |
| def _(type: IcebergType, value: Optional[date]) -> Optional[int]: |
| return date_to_days(value) if value is not None else None |
|
|
|
|
| @_to_partition_representation.register(TimeType) |
| def _(type: IcebergType, value: Optional[time]) -> Optional[int]: |
| return time_to_micros(value) if value is not None else None |
|
|
|
|
| @_to_partition_representation.register(UUIDType) |
| def _(type: IcebergType, value: Optional[uuid.UUID]) -> Optional[str]: |
| return str(value) if value is not None else None |
|
|
|
|
| @_to_partition_representation.register(PrimitiveType) |
| def _(type: IcebergType, value: Optional[Any]) -> Optional[Any]: |
| return value |
|
|
