| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | """FileIO implementation for reading and writing table files that uses pyarrow.fs. |
| | |
| | This file contains a FileIO implementation that relies on the filesystem interface provided |
| | by PyArrow. It relies on PyArrow's `from_uri` method that infers the correct filesystem |
| | type to use. Theoretically, this allows the supported storage types to grow naturally |
| | with the pyarrow library. |
| | """ |
| |
|
| | from __future__ import annotations |
| |
|
| | import concurrent.futures |
| | import fnmatch |
| | import itertools |
| | import logging |
| | import os |
| | import re |
| | from abc import ABC, abstractmethod |
| | from concurrent.futures import Future |
| | from copy import copy |
| | from dataclasses import dataclass |
| | from enum import Enum |
| | from functools import lru_cache, singledispatch |
| | from typing import ( |
| | TYPE_CHECKING, |
| | Any, |
| | Callable, |
| | Dict, |
| | Generic, |
| | Iterable, |
| | Iterator, |
| | List, |
| | Optional, |
| | Set, |
| | Tuple, |
| | TypeVar, |
| | Union, |
| | cast, |
| | ) |
| | from urllib.parse import urlparse |
| |
|
| | import numpy as np |
| | import pyarrow as pa |
| | import pyarrow.compute as pc |
| | import pyarrow.dataset as ds |
| | import pyarrow.lib |
| | import pyarrow.parquet as pq |
| | from pyarrow import ChunkedArray |
| | from pyarrow.fs import ( |
| | FileInfo, |
| | FileSystem, |
| | FileType, |
| | FSSpecHandler, |
| | ) |
| | from sortedcontainers import SortedList |
| |
|
| | from pyiceberg.conversions import to_bytes |
| | from pyiceberg.exceptions import ResolveError |
| | from pyiceberg.expressions import ( |
| | AlwaysTrue, |
| | BooleanExpression, |
| | BoundTerm, |
| | ) |
| | from pyiceberg.expressions.literals import Literal |
| | from pyiceberg.expressions.visitors import ( |
| | BoundBooleanExpressionVisitor, |
| | bind, |
| | extract_field_ids, |
| | translate_column_names, |
| | ) |
| | from pyiceberg.expressions.visitors import visit as boolean_expression_visit |
| | from pyiceberg.io import ( |
| | GCS_DEFAULT_LOCATION, |
| | GCS_ENDPOINT, |
| | GCS_TOKEN, |
| | GCS_TOKEN_EXPIRES_AT_MS, |
| | HDFS_HOST, |
| | HDFS_KERB_TICKET, |
| | HDFS_PORT, |
| | HDFS_USER, |
| | S3_ACCESS_KEY_ID, |
| | S3_CONNECT_TIMEOUT, |
| | S3_ENDPOINT, |
| | S3_PROXY_URI, |
| | S3_REGION, |
| | S3_SECRET_ACCESS_KEY, |
| | S3_SESSION_TOKEN, |
| | FileIO, |
| | InputFile, |
| | InputStream, |
| | OutputFile, |
| | OutputStream, |
| | ) |
| | from pyiceberg.manifest import ( |
| | DataFile, |
| | DataFileContent, |
| | FileFormat, |
| | ) |
| | from pyiceberg.partitioning import PartitionField, PartitionSpec, partition_record_value |
| | from pyiceberg.schema import ( |
| | PartnerAccessor, |
| | PreOrderSchemaVisitor, |
| | Schema, |
| | SchemaVisitorPerPrimitiveType, |
| | SchemaWithPartnerVisitor, |
| | pre_order_visit, |
| | promote, |
| | prune_columns, |
| | sanitize_column_names, |
| | visit, |
| | visit_with_partner, |
| | ) |
| | from pyiceberg.table import PropertyUtil, TableProperties, WriteTask |
| | from pyiceberg.table.metadata import TableMetadata |
| | from pyiceberg.table.name_mapping import NameMapping |
| | from pyiceberg.transforms import TruncateTransform |
| | from pyiceberg.typedef import EMPTY_DICT, Properties, Record |
| | from pyiceberg.types import ( |
| | BinaryType, |
| | BooleanType, |
| | DateType, |
| | DecimalType, |
| | DoubleType, |
| | FixedType, |
| | FloatType, |
| | IcebergType, |
| | IntegerType, |
| | ListType, |
| | LongType, |
| | MapType, |
| | NestedField, |
| | PrimitiveType, |
| | StringType, |
| | StructType, |
| | TimestampType, |
| | TimestamptzType, |
| | TimeType, |
| | UUIDType, |
| | ) |
| | from pyiceberg.utils.concurrent import ExecutorFactory |
| | from pyiceberg.utils.datetime import millis_to_datetime |
| | from pyiceberg.utils.singleton import Singleton |
| | from pyiceberg.utils.truncate import truncate_upper_bound_binary_string, truncate_upper_bound_text_string |
| |
|
| | if TYPE_CHECKING: |
| | from pyiceberg.table import FileScanTask |
| |
|
| | logger = logging.getLogger(__name__) |
| |
|
| | ONE_MEGABYTE = 1024 * 1024 |
| | BUFFER_SIZE = "buffer-size" |
| | ICEBERG_SCHEMA = b"iceberg.schema" |
| | |
| | PYARROW_PARQUET_FIELD_ID_KEY = b"PARQUET:field_id" |
| | PYARROW_FIELD_DOC_KEY = b"doc" |
| | LIST_ELEMENT_NAME = "element" |
| | MAP_KEY_NAME = "key" |
| | MAP_VALUE_NAME = "value" |
| | DOC = "doc" |
| |
|
| | T = TypeVar("T") |
| |
|
| |
|
| | class PyArrowLocalFileSystem(pyarrow.fs.LocalFileSystem): |
| | def open_output_stream(self, path: str, *args: Any, **kwargs: Any) -> pyarrow.NativeFile: |
| | |
| | self.create_dir(os.path.dirname(path), recursive=True) |
| | return super().open_output_stream(path, *args, **kwargs) |
| |
|
| |
|
| | class PyArrowFile(InputFile, OutputFile): |
| | """A combined InputFile and OutputFile implementation that uses a pyarrow filesystem to generate pyarrow.lib.NativeFile instances. |
| | |
| | Args: |
| | location (str): A URI or a path to a local file. |
| | |
| | Attributes: |
| | location(str): The URI or path to a local file for a PyArrowFile instance. |
| | |
| | Examples: |
| | >>> from pyiceberg.io.pyarrow import PyArrowFile |
| | >>> # input_file = PyArrowFile("s3://foo/bar.txt") |
| | >>> # Read the contents of the PyArrowFile instance |
| | >>> # Make sure that you have permissions to read/write |
| | >>> # file_content = input_file.open().read() |
| | |
| | >>> # output_file = PyArrowFile("s3://baz/qux.txt") |
| | >>> # Write bytes to a file |
| | >>> # Make sure that you have permissions to read/write |
| | >>> # output_file.create().write(b'foobytes') |
| | """ |
| |
|
| | _filesystem: FileSystem |
| | _path: str |
| | _buffer_size: int |
| |
|
| | def __init__(self, location: str, path: str, fs: FileSystem, buffer_size: int = ONE_MEGABYTE): |
| | self._filesystem = fs |
| | self._path = path |
| | self._buffer_size = buffer_size |
| | super().__init__(location=location) |
| |
|
| | def _file_info(self) -> FileInfo: |
| | """Retrieve a pyarrow.fs.FileInfo object for the location. |
| | |
| | Raises: |
| | PermissionError: If the file at self.location cannot be accessed due to a permission error such as |
| | an AWS error code 15. |
| | """ |
| | try: |
| | file_info = self._filesystem.get_file_info(self._path) |
| | except OSError as e: |
| | if e.errno == 13 or "AWS Error [code 15]" in str(e): |
| | raise PermissionError(f"Cannot get file info, access denied: {self.location}") from e |
| | raise |
| |
|
| | if file_info.type == FileType.NotFound: |
| | raise FileNotFoundError(f"Cannot get file info, file not found: {self.location}") |
| | return file_info |
| |
|
| | def __len__(self) -> int: |
| | """Return the total length of the file, in bytes.""" |
| | file_info = self._file_info() |
| | return file_info.size |
| |
|
| | def exists(self) -> bool: |
| | """Check whether the location exists.""" |
| | try: |
| | self._file_info() |
| | return True |
| | except FileNotFoundError: |
| | return False |
| |
|
| | def open(self, seekable: bool = True) -> InputStream: |
| | """Open the location using a PyArrow FileSystem inferred from the location. |
| | |
| | Args: |
| | seekable: If the stream should support seek, or if it is consumed sequential. |
| | |
| | Returns: |
| | pyarrow.lib.NativeFile: A NativeFile instance for the file located at `self.location`. |
| | |
| | Raises: |
| | FileNotFoundError: If the file at self.location does not exist. |
| | PermissionError: If the file at self.location cannot be accessed due to a permission error such as |
| | an AWS error code 15. |
| | """ |
| | try: |
| | if seekable: |
| | input_file = self._filesystem.open_input_file(self._path) |
| | else: |
| | input_file = self._filesystem.open_input_stream(self._path, buffer_size=self._buffer_size) |
| | except FileNotFoundError: |
| | raise |
| | except PermissionError: |
| | raise |
| | except OSError as e: |
| | if e.errno == 2 or "Path does not exist" in str(e): |
| | raise FileNotFoundError(f"Cannot open file, does not exist: {self.location}") from e |
| | elif e.errno == 13 or "AWS Error [code 15]" in str(e): |
| | raise PermissionError(f"Cannot open file, access denied: {self.location}") from e |
| | raise |
| | return input_file |
| |
|
| | def create(self, overwrite: bool = False) -> OutputStream: |
| | """Create a writable pyarrow.lib.NativeFile for this PyArrowFile's location. |
| | |
| | Args: |
| | overwrite (bool): Whether to overwrite the file if it already exists. |
| | |
| | Returns: |
| | pyarrow.lib.NativeFile: A NativeFile instance for the file located at self.location. |
| | |
| | Raises: |
| | FileExistsError: If the file already exists at `self.location` and `overwrite` is False. |
| | |
| | Note: |
| | This retrieves a pyarrow NativeFile by opening an output stream. If overwrite is set to False, |
| | a check is first performed to verify that the file does not exist. This is not thread-safe and |
| | a possibility does exist that the file can be created by a concurrent process after the existence |
| | check yet before the output stream is created. In such a case, the default pyarrow behavior will |
| | truncate the contents of the existing file when opening the output stream. |
| | """ |
| | try: |
| | if not overwrite and self.exists() is True: |
| | raise FileExistsError(f"Cannot create file, already exists: {self.location}") |
| | output_file = self._filesystem.open_output_stream(self._path, buffer_size=self._buffer_size) |
| | except PermissionError: |
| | raise |
| | except OSError as e: |
| | if e.errno == 13 or "AWS Error [code 15]" in str(e): |
| | raise PermissionError(f"Cannot create file, access denied: {self.location}") from e |
| | raise |
| | return output_file |
| |
|
| | def to_input_file(self) -> PyArrowFile: |
| | """Return a new PyArrowFile for the location of an existing PyArrowFile instance. |
| | |
| | This method is included to abide by the OutputFile abstract base class. Since this implementation uses a single |
| | PyArrowFile class (as opposed to separate InputFile and OutputFile implementations), this method effectively returns |
| | a copy of the same instance. |
| | """ |
| | return self |
| |
|
| |
|
| | class PyArrowFileIO(FileIO): |
| | fs_by_scheme: Callable[[str, Optional[str]], FileSystem] |
| |
|
| | def __init__(self, properties: Properties = EMPTY_DICT): |
| | self.fs_by_scheme: Callable[[str, Optional[str]], FileSystem] = lru_cache(self._initialize_fs) |
| | super().__init__(properties=properties) |
| |
|
| | @staticmethod |
| | def parse_location(location: str) -> Tuple[str, str, str]: |
| | """Return the path without the scheme.""" |
| | uri = urlparse(location) |
| | if not uri.scheme: |
| | return "file", uri.netloc, os.path.abspath(location) |
| | elif uri.scheme in ("hdfs", "viewfs"): |
| | return uri.scheme, uri.netloc, uri.path |
| | else: |
| | return uri.scheme, uri.netloc, f"{uri.netloc}{uri.path}" |
| |
|
| | def _initialize_fs(self, scheme: str, netloc: Optional[str] = None) -> FileSystem: |
| | if scheme in {"s3", "s3a", "s3n"}: |
| | from pyarrow.fs import S3FileSystem |
| |
|
| | client_kwargs: Dict[str, Any] = { |
| | "endpoint_override": self.properties.get(S3_ENDPOINT), |
| | "access_key": self.properties.get(S3_ACCESS_KEY_ID), |
| | "secret_key": self.properties.get(S3_SECRET_ACCESS_KEY), |
| | "session_token": self.properties.get(S3_SESSION_TOKEN), |
| | "region": self.properties.get(S3_REGION), |
| | } |
| |
|
| | if proxy_uri := self.properties.get(S3_PROXY_URI): |
| | client_kwargs["proxy_options"] = proxy_uri |
| |
|
| | if connect_timeout := self.properties.get(S3_CONNECT_TIMEOUT): |
| | client_kwargs["connect_timeout"] = float(connect_timeout) |
| |
|
| | return S3FileSystem(**client_kwargs) |
| | elif scheme in ("hdfs", "viewfs"): |
| | from pyarrow.fs import HadoopFileSystem |
| |
|
| | hdfs_kwargs: Dict[str, Any] = {} |
| | if netloc: |
| | return HadoopFileSystem.from_uri(f"{scheme}://{netloc}") |
| | if host := self.properties.get(HDFS_HOST): |
| | hdfs_kwargs["host"] = host |
| | if port := self.properties.get(HDFS_PORT): |
| | |
| | hdfs_kwargs["port"] = int(port) |
| | if user := self.properties.get(HDFS_USER): |
| | hdfs_kwargs["user"] = user |
| | if kerb_ticket := self.properties.get(HDFS_KERB_TICKET): |
| | hdfs_kwargs["kerb_ticket"] = kerb_ticket |
| |
|
| | return HadoopFileSystem(**hdfs_kwargs) |
| | elif scheme in {"gs", "gcs"}: |
| | from pyarrow.fs import GcsFileSystem |
| |
|
| | gcs_kwargs: Dict[str, Any] = {} |
| | if access_token := self.properties.get(GCS_TOKEN): |
| | gcs_kwargs["access_token"] = access_token |
| | if expiration := self.properties.get(GCS_TOKEN_EXPIRES_AT_MS): |
| | gcs_kwargs["credential_token_expiration"] = millis_to_datetime(int(expiration)) |
| | if bucket_location := self.properties.get(GCS_DEFAULT_LOCATION): |
| | gcs_kwargs["default_bucket_location"] = bucket_location |
| | if endpoint := self.properties.get(GCS_ENDPOINT): |
| | url_parts = urlparse(endpoint) |
| | gcs_kwargs["scheme"] = url_parts.scheme |
| | gcs_kwargs["endpoint_override"] = url_parts.netloc |
| |
|
| | return GcsFileSystem(**gcs_kwargs) |
| | elif scheme == "file": |
| | return PyArrowLocalFileSystem() |
| | else: |
| | raise ValueError(f"Unrecognized filesystem type in URI: {scheme}") |
| |
|
| | def new_input(self, location: str) -> PyArrowFile: |
| | """Get a PyArrowFile instance to read bytes from the file at the given location. |
| | |
| | Args: |
| | location (str): A URI or a path to a local file. |
| | |
| | Returns: |
| | PyArrowFile: A PyArrowFile instance for the given location. |
| | """ |
| | scheme, netloc, path = self.parse_location(location) |
| | return PyArrowFile( |
| | fs=self.fs_by_scheme(scheme, netloc), |
| | location=location, |
| | path=path, |
| | buffer_size=int(self.properties.get(BUFFER_SIZE, ONE_MEGABYTE)), |
| | ) |
| |
|
| | def new_output(self, location: str) -> PyArrowFile: |
| | """Get a PyArrowFile instance to write bytes to the file at the given location. |
| | |
| | Args: |
| | location (str): A URI or a path to a local file. |
| | |
| | Returns: |
| | PyArrowFile: A PyArrowFile instance for the given location. |
| | """ |
| | scheme, netloc, path = self.parse_location(location) |
| | return PyArrowFile( |
| | fs=self.fs_by_scheme(scheme, netloc), |
| | location=location, |
| | path=path, |
| | buffer_size=int(self.properties.get(BUFFER_SIZE, ONE_MEGABYTE)), |
| | ) |
| |
|
| | def delete(self, location: Union[str, InputFile, OutputFile]) -> None: |
| | """Delete the file at the given location. |
| | |
| | Args: |
| | location (Union[str, InputFile, OutputFile]): The URI to the file--if an InputFile instance or an OutputFile instance is provided, |
| | the location attribute for that instance is used as the location to delete. |
| | |
| | Raises: |
| | FileNotFoundError: When the file at the provided location does not exist. |
| | PermissionError: If the file at the provided location cannot be accessed due to a permission error such as |
| | an AWS error code 15. |
| | """ |
| | str_location = location.location if isinstance(location, (InputFile, OutputFile)) else location |
| | scheme, netloc, path = self.parse_location(str_location) |
| | fs = self.fs_by_scheme(scheme, netloc) |
| |
|
| | try: |
| | fs.delete_file(path) |
| | except FileNotFoundError: |
| | raise |
| | except PermissionError: |
| | raise |
| | except OSError as e: |
| | if e.errno == 2 or "Path does not exist" in str(e): |
| | raise FileNotFoundError(f"Cannot delete file, does not exist: {location}") from e |
| | elif e.errno == 13 or "AWS Error [code 15]" in str(e): |
| | raise PermissionError(f"Cannot delete file, access denied: {location}") from e |
| | raise |
| |
|
| | def __getstate__(self) -> Dict[str, Any]: |
| | """Create a dictionary of the PyArrowFileIO fields used when pickling.""" |
| | fileio_copy = copy(self.__dict__) |
| | fileio_copy["fs_by_scheme"] = None |
| | return fileio_copy |
| |
|
| | def __setstate__(self, state: Dict[str, Any]) -> None: |
| | """Deserialize the state into a PyArrowFileIO instance.""" |
| | self.__dict__ = state |
| | self.fs_by_scheme = lru_cache(self._initialize_fs) |
| |
|
| |
|
| | def schema_to_pyarrow( |
| | schema: Union[Schema, IcebergType], metadata: Dict[bytes, bytes] = EMPTY_DICT, include_field_ids: bool = True |
| | ) -> pa.schema: |
| | return visit(schema, _ConvertToArrowSchema(metadata, include_field_ids)) |
| |
|
| |
|
| | class _ConvertToArrowSchema(SchemaVisitorPerPrimitiveType[pa.DataType]): |
| | _metadata: Dict[bytes, bytes] |
| |
|
| | def __init__(self, metadata: Dict[bytes, bytes] = EMPTY_DICT, include_field_ids: bool = True) -> None: |
| | self._metadata = metadata |
| | self._include_field_ids = include_field_ids |
| |
|
| | def schema(self, _: Schema, struct_result: pa.StructType) -> pa.schema: |
| | return pa.schema(list(struct_result), metadata=self._metadata) |
| |
|
| | def struct(self, _: StructType, field_results: List[pa.DataType]) -> pa.DataType: |
| | return pa.struct(field_results) |
| |
|
| | def field(self, field: NestedField, field_result: pa.DataType) -> pa.Field: |
| | metadata = {} |
| | if field.doc: |
| | metadata[PYARROW_FIELD_DOC_KEY] = field.doc |
| | if self._include_field_ids: |
| | metadata[PYARROW_PARQUET_FIELD_ID_KEY] = str(field.field_id) |
| |
|
| | return pa.field( |
| | name=field.name, |
| | type=field_result, |
| | nullable=field.optional, |
| | metadata=metadata, |
| | ) |
| |
|
| | def list(self, list_type: ListType, element_result: pa.DataType) -> pa.DataType: |
| | element_field = self.field(list_type.element_field, element_result) |
| | return pa.list_(value_type=element_field) |
| |
|
| | def map(self, map_type: MapType, key_result: pa.DataType, value_result: pa.DataType) -> pa.DataType: |
| | key_field = self.field(map_type.key_field, key_result) |
| | value_field = self.field(map_type.value_field, value_result) |
| | return pa.map_(key_type=key_field, item_type=value_field) |
| |
|
| | def visit_fixed(self, fixed_type: FixedType) -> pa.DataType: |
| | return pa.binary(len(fixed_type)) |
| |
|
| | def visit_decimal(self, decimal_type: DecimalType) -> pa.DataType: |
| | return pa.decimal128(decimal_type.precision, decimal_type.scale) |
| |
|
| | def visit_boolean(self, _: BooleanType) -> pa.DataType: |
| | return pa.bool_() |
| |
|
| | def visit_integer(self, _: IntegerType) -> pa.DataType: |
| | return pa.int32() |
| |
|
| | def visit_long(self, _: LongType) -> pa.DataType: |
| | return pa.int64() |
| |
|
| | def visit_float(self, _: FloatType) -> pa.DataType: |
| | |
| | return pa.float32() |
| |
|
| | def visit_double(self, _: DoubleType) -> pa.DataType: |
| | |
| | return pa.float64() |
| |
|
| | def visit_date(self, _: DateType) -> pa.DataType: |
| | |
| | return pa.date32() |
| |
|
| | def visit_time(self, _: TimeType) -> pa.DataType: |
| | return pa.time64("us") |
| |
|
| | def visit_timestamp(self, _: TimestampType) -> pa.DataType: |
| | return pa.timestamp(unit="us") |
| |
|
| | def visit_timestamptz(self, _: TimestamptzType) -> pa.DataType: |
| | return pa.timestamp(unit="us", tz="UTC") |
| |
|
| | def visit_string(self, _: StringType) -> pa.DataType: |
| | return pa.string() |
| |
|
| | def visit_uuid(self, _: UUIDType) -> pa.DataType: |
| | return pa.binary(16) |
| |
|
| | def visit_binary(self, _: BinaryType) -> pa.DataType: |
| | return pa.large_binary() |
| |
|
| |
|
| | def _convert_scalar(value: Any, iceberg_type: IcebergType) -> pa.scalar: |
| | if not isinstance(iceberg_type, PrimitiveType): |
| | raise ValueError(f"Expected primitive type, got: {iceberg_type}") |
| | return pa.scalar(value=value, type=schema_to_pyarrow(iceberg_type)) |
| |
|
| |
|
| | class _ConvertToArrowExpression(BoundBooleanExpressionVisitor[pc.Expression]): |
| | def visit_in(self, term: BoundTerm[pc.Expression], literals: Set[Any]) -> pc.Expression: |
| | pyarrow_literals = pa.array(literals, type=schema_to_pyarrow(term.ref().field.field_type)) |
| | return pc.field(term.ref().field.name).isin(pyarrow_literals) |
| |
|
| | def visit_not_in(self, term: BoundTerm[pc.Expression], literals: Set[Any]) -> pc.Expression: |
| | pyarrow_literals = pa.array(literals, type=schema_to_pyarrow(term.ref().field.field_type)) |
| | return ~pc.field(term.ref().field.name).isin(pyarrow_literals) |
| |
|
| | def visit_is_nan(self, term: BoundTerm[Any]) -> pc.Expression: |
| | ref = pc.field(term.ref().field.name) |
| | return pc.is_nan(ref) |
| |
|
| | def visit_not_nan(self, term: BoundTerm[Any]) -> pc.Expression: |
| | ref = pc.field(term.ref().field.name) |
| | return ~pc.is_nan(ref) |
| |
|
| | def visit_is_null(self, term: BoundTerm[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name).is_null(nan_is_null=False) |
| |
|
| | def visit_not_null(self, term: BoundTerm[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name).is_valid() |
| |
|
| | def visit_equal(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) == _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_not_equal(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) != _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_greater_than_or_equal(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) >= _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_greater_than(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) > _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_less_than(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) < _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_less_than_or_equal(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.field(term.ref().field.name) <= _convert_scalar(literal.value, term.ref().field.field_type) |
| |
|
| | def visit_starts_with(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return pc.starts_with(pc.field(term.ref().field.name), literal.value) |
| |
|
| | def visit_not_starts_with(self, term: BoundTerm[Any], literal: Literal[Any]) -> pc.Expression: |
| | return ~pc.starts_with(pc.field(term.ref().field.name), literal.value) |
| |
|
| | def visit_true(self) -> pc.Expression: |
| | return pc.scalar(True) |
| |
|
| | def visit_false(self) -> pc.Expression: |
| | return pc.scalar(False) |
| |
|
| | def visit_not(self, child_result: pc.Expression) -> pc.Expression: |
| | return ~child_result |
| |
|
| | def visit_and(self, left_result: pc.Expression, right_result: pc.Expression) -> pc.Expression: |
| | return left_result & right_result |
| |
|
| | def visit_or(self, left_result: pc.Expression, right_result: pc.Expression) -> pc.Expression: |
| | return left_result | right_result |
| |
|
| |
|
| | def expression_to_pyarrow(expr: BooleanExpression) -> pc.Expression: |
| | return boolean_expression_visit(expr, _ConvertToArrowExpression()) |
| |
|
| |
|
| | @lru_cache |
| | def _get_file_format(file_format: FileFormat, **kwargs: Dict[str, Any]) -> ds.FileFormat: |
| | if file_format == FileFormat.PARQUET: |
| | return ds.ParquetFileFormat(**kwargs) |
| | else: |
| | raise ValueError(f"Unsupported file format: {file_format}") |
| |
|
| |
|
| | def _construct_fragment(fs: FileSystem, data_file: DataFile, file_format_kwargs: Dict[str, Any] = EMPTY_DICT) -> ds.Fragment: |
| | _, _, path = PyArrowFileIO.parse_location(data_file.file_path) |
| | return _get_file_format(data_file.file_format, **file_format_kwargs).make_fragment(path, fs) |
| |
|
| |
|
| | def _read_deletes(fs: FileSystem, data_file: DataFile) -> Dict[str, pa.ChunkedArray]: |
| | delete_fragment = _construct_fragment( |
| | fs, data_file, file_format_kwargs={"dictionary_columns": ("file_path",), "pre_buffer": True, "buffer_size": ONE_MEGABYTE} |
| | ) |
| | table = ds.Scanner.from_fragment(fragment=delete_fragment).to_table() |
| | table = table.unify_dictionaries() |
| | return { |
| | file.as_py(): table.filter(pc.field("file_path") == file).column("pos") |
| | for file in table.column("file_path").chunks[0].dictionary |
| | } |
| |
|
| |
|
| | def _combine_positional_deletes(positional_deletes: List[pa.ChunkedArray], rows: int) -> pa.Array: |
| | if len(positional_deletes) == 1: |
| | all_chunks = positional_deletes[0] |
| | else: |
| | all_chunks = pa.chunked_array(itertools.chain(*[arr.chunks for arr in positional_deletes])) |
| | return np.setdiff1d(np.arange(rows), all_chunks, assume_unique=False) |
| |
|
| |
|
| | def pyarrow_to_schema(schema: pa.Schema, name_mapping: Optional[NameMapping] = None) -> Schema: |
| | has_ids = visit_pyarrow(schema, _HasIds()) |
| | if has_ids: |
| | visitor = _ConvertToIceberg() |
| | elif name_mapping is not None: |
| | visitor = _ConvertToIceberg(name_mapping=name_mapping) |
| | else: |
| | raise ValueError( |
| | "Parquet file does not have field-ids and the Iceberg table does not have 'schema.name-mapping.default' defined" |
| | ) |
| | return visit_pyarrow(schema, visitor) |
| |
|
| |
|
| | def _pyarrow_to_schema_without_ids(schema: pa.Schema) -> Schema: |
| | return visit_pyarrow(schema, _ConvertToIcebergWithoutIDs()) |
| |
|
| |
|
| | @singledispatch |
| | def visit_pyarrow(obj: Union[pa.DataType, pa.Schema], visitor: PyArrowSchemaVisitor[T]) -> T: |
| | """Apply a pyarrow schema visitor to any point within a schema. |
| | |
| | The function traverses the schema in post-order fashion. |
| | |
| | Args: |
| | obj (Union[pa.DataType, pa.Schema]): An instance of a Schema or an IcebergType. |
| | visitor (PyArrowSchemaVisitor[T]): An instance of an implementation of the generic PyarrowSchemaVisitor base class. |
| | |
| | Raises: |
| | NotImplementedError: If attempting to visit an unrecognized object type. |
| | """ |
| | raise NotImplementedError(f"Cannot visit non-type: {obj}") |
| |
|
| |
|
| | @visit_pyarrow.register(pa.Schema) |
| | def _(obj: pa.Schema, visitor: PyArrowSchemaVisitor[T]) -> T: |
| | return visitor.schema(obj, visit_pyarrow(pa.struct(obj), visitor)) |
| |
|
| |
|
| | @visit_pyarrow.register(pa.StructType) |
| | def _(obj: pa.StructType, visitor: PyArrowSchemaVisitor[T]) -> T: |
| | results = [] |
| |
|
| | for field in obj: |
| | visitor.before_field(field) |
| | result = visit_pyarrow(field.type, visitor) |
| | results.append(visitor.field(field, result)) |
| | visitor.after_field(field) |
| |
|
| | return visitor.struct(obj, results) |
| |
|
| |
|
| | @visit_pyarrow.register(pa.ListType) |
| | @visit_pyarrow.register(pa.FixedSizeListType) |
| | @visit_pyarrow.register(pa.LargeListType) |
| | def _(obj: Union[pa.ListType, pa.LargeListType, pa.FixedSizeListType], visitor: PyArrowSchemaVisitor[T]) -> T: |
| | visitor.before_list_element(obj.value_field) |
| | result = visit_pyarrow(obj.value_type, visitor) |
| | visitor.after_list_element(obj.value_field) |
| |
|
| | return visitor.list(obj, result) |
| |
|
| |
|
| | @visit_pyarrow.register(pa.MapType) |
| | def _(obj: pa.MapType, visitor: PyArrowSchemaVisitor[T]) -> T: |
| | visitor.before_map_key(obj.key_field) |
| | key_result = visit_pyarrow(obj.key_type, visitor) |
| | visitor.after_map_key(obj.key_field) |
| |
|
| | visitor.before_map_value(obj.item_field) |
| | value_result = visit_pyarrow(obj.item_type, visitor) |
| | visitor.after_map_value(obj.item_field) |
| |
|
| | return visitor.map(obj, key_result, value_result) |
| |
|
| |
|
| | @visit_pyarrow.register(pa.DictionaryType) |
| | def _(obj: pa.DictionaryType, visitor: PyArrowSchemaVisitor[T]) -> T: |
| | |
| | |
| | |
| | |
| | logger.warning(f"Iceberg does not have a dictionary type. {type(obj)} will be inferred as {obj.value_type} on read.") |
| | return visit_pyarrow(obj.value_type, visitor) |
| |
|
| |
|
| | @visit_pyarrow.register(pa.DataType) |
| | def _(obj: pa.DataType, visitor: PyArrowSchemaVisitor[T]) -> T: |
| | if pa.types.is_nested(obj): |
| | raise TypeError(f"Expected primitive type, got: {type(obj)}") |
| | return visitor.primitive(obj) |
| |
|
| |
|
| | class PyArrowSchemaVisitor(Generic[T], ABC): |
| | def before_field(self, field: pa.Field) -> None: |
| | """Override this method to perform an action immediately before visiting a field.""" |
| |
|
| | def after_field(self, field: pa.Field) -> None: |
| | """Override this method to perform an action immediately after visiting a field.""" |
| |
|
| | def before_list_element(self, element: pa.Field) -> None: |
| | """Override this method to perform an action immediately before visiting an element within a ListType.""" |
| |
|
| | def after_list_element(self, element: pa.Field) -> None: |
| | """Override this method to perform an action immediately after visiting an element within a ListType.""" |
| |
|
| | def before_map_key(self, key: pa.Field) -> None: |
| | """Override this method to perform an action immediately before visiting a key within a MapType.""" |
| |
|
| | def after_map_key(self, key: pa.Field) -> None: |
| | """Override this method to perform an action immediately after visiting a key within a MapType.""" |
| |
|
| | def before_map_value(self, value: pa.Field) -> None: |
| | """Override this method to perform an action immediately before visiting a value within a MapType.""" |
| |
|
| | def after_map_value(self, value: pa.Field) -> None: |
| | """Override this method to perform an action immediately after visiting a value within a MapType.""" |
| |
|
| | @abstractmethod |
| | def schema(self, schema: pa.Schema, struct_result: T) -> T: |
| | """Visit a schema.""" |
| |
|
| | @abstractmethod |
| | def struct(self, struct: pa.StructType, field_results: List[T]) -> T: |
| | """Visit a struct.""" |
| |
|
| | @abstractmethod |
| | def field(self, field: pa.Field, field_result: T) -> T: |
| | """Visit a field.""" |
| |
|
| | @abstractmethod |
| | def list(self, list_type: pa.ListType, element_result: T) -> T: |
| | """Visit a list.""" |
| |
|
| | @abstractmethod |
| | def map(self, map_type: pa.MapType, key_result: T, value_result: T) -> T: |
| | """Visit a map.""" |
| |
|
| | @abstractmethod |
| | def primitive(self, primitive: pa.DataType) -> T: |
| | """Visit a primitive type.""" |
| |
|
| |
|
| | def _get_field_id(field: pa.Field) -> Optional[int]: |
| | return ( |
| | int(field_id_str.decode()) |
| | if (field.metadata and (field_id_str := field.metadata.get(PYARROW_PARQUET_FIELD_ID_KEY))) |
| | else None |
| | ) |
| |
|
| |
|
| | class _HasIds(PyArrowSchemaVisitor[bool]): |
| | def schema(self, schema: pa.Schema, struct_result: bool) -> bool: |
| | return struct_result |
| |
|
| | def struct(self, struct: pa.StructType, field_results: List[bool]) -> bool: |
| | return all(field_results) |
| |
|
| | def field(self, field: pa.Field, field_result: bool) -> bool: |
| | return all([_get_field_id(field) is not None, field_result]) |
| |
|
| | def list(self, list_type: pa.ListType, element_result: bool) -> bool: |
| | element_field = list_type.value_field |
| | element_id = _get_field_id(element_field) |
| | return element_result and element_id is not None |
| |
|
| | def map(self, map_type: pa.MapType, key_result: bool, value_result: bool) -> bool: |
| | key_field = map_type.key_field |
| | key_id = _get_field_id(key_field) |
| | value_field = map_type.item_field |
| | value_id = _get_field_id(value_field) |
| | return all([key_id is not None, value_id is not None, key_result, value_result]) |
| |
|
| | def primitive(self, primitive: pa.DataType) -> bool: |
| | return True |
| |
|
| |
|
| | class _ConvertToIceberg(PyArrowSchemaVisitor[Union[IcebergType, Schema]]): |
| | """Converts PyArrowSchema to Iceberg Schema. Applies the IDs from name_mapping if provided.""" |
| |
|
| | _field_names: List[str] |
| | _name_mapping: Optional[NameMapping] |
| |
|
| | def __init__(self, name_mapping: Optional[NameMapping] = None) -> None: |
| | self._field_names = [] |
| | self._name_mapping = name_mapping |
| |
|
| | def _field_id(self, field: pa.Field) -> int: |
| | if self._name_mapping: |
| | return self._name_mapping.find(*self._field_names).field_id |
| | elif (field_id := _get_field_id(field)) is not None: |
| | return field_id |
| | else: |
| | raise ValueError(f"Cannot convert {field} to Iceberg Field as field_id is empty.") |
| |
|
| | def schema(self, schema: pa.Schema, struct_result: StructType) -> Schema: |
| | return Schema(*struct_result.fields) |
| |
|
| | def struct(self, struct: pa.StructType, field_results: List[NestedField]) -> StructType: |
| | return StructType(*field_results) |
| |
|
| | def field(self, field: pa.Field, field_result: IcebergType) -> NestedField: |
| | field_id = self._field_id(field) |
| | field_doc = doc_str.decode() if (field.metadata and (doc_str := field.metadata.get(PYARROW_FIELD_DOC_KEY))) else None |
| | field_type = field_result |
| | return NestedField(field_id, field.name, field_type, required=not field.nullable, doc=field_doc) |
| |
|
| | def list(self, list_type: pa.ListType, element_result: IcebergType) -> ListType: |
| | element_field = list_type.value_field |
| | self._field_names.append(LIST_ELEMENT_NAME) |
| | element_id = self._field_id(element_field) |
| | self._field_names.pop() |
| | return ListType(element_id, element_result, element_required=not element_field.nullable) |
| |
|
| | def map(self, map_type: pa.MapType, key_result: IcebergType, value_result: IcebergType) -> MapType: |
| | key_field = map_type.key_field |
| | self._field_names.append(MAP_KEY_NAME) |
| | key_id = self._field_id(key_field) |
| | self._field_names.pop() |
| | value_field = map_type.item_field |
| | self._field_names.append(MAP_VALUE_NAME) |
| | value_id = self._field_id(value_field) |
| | self._field_names.pop() |
| | return MapType(key_id, key_result, value_id, value_result, value_required=not value_field.nullable) |
| |
|
| | def primitive(self, primitive: pa.DataType) -> PrimitiveType: |
| | if pa.types.is_boolean(primitive): |
| | return BooleanType() |
| | elif pa.types.is_integer(primitive): |
| | width = primitive.bit_width |
| | if width <= 32: |
| | return IntegerType() |
| | elif width <= 64: |
| | return LongType() |
| | else: |
| | |
| | raise TypeError(f"Unsupported integer type: {primitive}") |
| | elif pa.types.is_float32(primitive): |
| | return FloatType() |
| | elif pa.types.is_float64(primitive): |
| | return DoubleType() |
| | elif isinstance(primitive, pa.Decimal128Type): |
| | primitive = cast(pa.Decimal128Type, primitive) |
| | return DecimalType(primitive.precision, primitive.scale) |
| | elif pa.types.is_string(primitive) or pa.types.is_large_string(primitive): |
| | return StringType() |
| | elif pa.types.is_date32(primitive): |
| | return DateType() |
| | elif isinstance(primitive, pa.Time64Type) and primitive.unit == "us": |
| | return TimeType() |
| | elif pa.types.is_timestamp(primitive): |
| | primitive = cast(pa.TimestampType, primitive) |
| | if primitive.unit == "us": |
| | if primitive.tz == "UTC" or primitive.tz == "+00:00": |
| | return TimestamptzType() |
| | elif primitive.tz is None: |
| | return TimestampType() |
| | elif pa.types.is_binary(primitive) or pa.types.is_large_binary(primitive): |
| | return BinaryType() |
| | elif pa.types.is_fixed_size_binary(primitive): |
| | primitive = cast(pa.FixedSizeBinaryType, primitive) |
| | return FixedType(primitive.byte_width) |
| |
|
| | raise TypeError(f"Unsupported type: {primitive}") |
| |
|
| | def before_field(self, field: pa.Field) -> None: |
| | self._field_names.append(field.name) |
| |
|
| | def after_field(self, field: pa.Field) -> None: |
| | self._field_names.pop() |
| |
|
| | def before_list_element(self, element: pa.Field) -> None: |
| | self._field_names.append(LIST_ELEMENT_NAME) |
| |
|
| | def after_list_element(self, element: pa.Field) -> None: |
| | self._field_names.pop() |
| |
|
| | def before_map_key(self, key: pa.Field) -> None: |
| | self._field_names.append(MAP_KEY_NAME) |
| |
|
| | def after_map_key(self, element: pa.Field) -> None: |
| | self._field_names.pop() |
| |
|
| | def before_map_value(self, value: pa.Field) -> None: |
| | self._field_names.append(MAP_VALUE_NAME) |
| |
|
| | def after_map_value(self, element: pa.Field) -> None: |
| | self._field_names.pop() |
| |
|
| |
|
| | class _ConvertToIcebergWithoutIDs(_ConvertToIceberg): |
| | """ |
| | Converts PyArrowSchema to Iceberg Schema with all -1 ids. |
| | |
| | The schema generated through this visitor should always be |
| | used in conjunction with `new_table_metadata` function to |
| | assign new field ids in order. This is currently used only |
| | when creating an Iceberg Schema from a PyArrow schema when |
| | creating a new Iceberg table. |
| | """ |
| |
|
| | def _field_id(self, field: pa.Field) -> int: |
| | return -1 |
| |
|
| |
|
| | def _task_to_table( |
| | fs: FileSystem, |
| | task: FileScanTask, |
| | bound_row_filter: BooleanExpression, |
| | projected_schema: Schema, |
| | projected_field_ids: Set[int], |
| | positional_deletes: Optional[List[ChunkedArray]], |
| | case_sensitive: bool, |
| | limit: Optional[int] = None, |
| | name_mapping: Optional[NameMapping] = None, |
| | ) -> Optional[pa.Table]: |
| | _, _, path = PyArrowFileIO.parse_location(task.file.file_path) |
| | arrow_format = ds.ParquetFileFormat(pre_buffer=True, buffer_size=(ONE_MEGABYTE * 8)) |
| | with fs.open_input_file(path) as fin: |
| | fragment = arrow_format.make_fragment(fin) |
| | physical_schema = fragment.physical_schema |
| | file_schema = pyarrow_to_schema(physical_schema, name_mapping) |
| |
|
| | pyarrow_filter = None |
| | if bound_row_filter is not AlwaysTrue(): |
| | translated_row_filter = translate_column_names(bound_row_filter, file_schema, case_sensitive=case_sensitive) |
| | bound_file_filter = bind(file_schema, translated_row_filter, case_sensitive=case_sensitive) |
| | pyarrow_filter = expression_to_pyarrow(bound_file_filter) |
| |
|
| | file_project_schema = prune_columns(file_schema, projected_field_ids, select_full_types=False) |
| |
|
| | if file_schema is None: |
| | raise ValueError(f"Missing Iceberg schema in Metadata for file: {path}") |
| |
|
| | fragment_scanner = ds.Scanner.from_fragment( |
| | fragment=fragment, |
| | schema=physical_schema, |
| | |
| | |
| | filter=pyarrow_filter if not positional_deletes else None, |
| | columns=[col.name for col in file_project_schema.columns], |
| | ) |
| |
|
| | if positional_deletes: |
| | |
| | indices = _combine_positional_deletes(positional_deletes, fragment.count_rows()) |
| |
|
| | if limit: |
| | if pyarrow_filter is not None: |
| | |
| | |
| | |
| | arrow_table = fragment_scanner.take(indices) |
| | arrow_table = arrow_table.filter(pyarrow_filter) |
| | arrow_table = arrow_table.slice(0, limit) |
| | else: |
| | arrow_table = fragment_scanner.take(indices[0:limit]) |
| | else: |
| | arrow_table = fragment_scanner.take(indices) |
| | |
| | if pyarrow_filter is not None: |
| | arrow_table = arrow_table.filter(pyarrow_filter) |
| | else: |
| | |
| | |
| | if limit: |
| | arrow_table = fragment_scanner.head(limit) |
| | else: |
| | arrow_table = fragment_scanner.to_table() |
| |
|
| | if len(arrow_table) < 1: |
| | return None |
| | return to_requested_schema(projected_schema, file_project_schema, arrow_table) |
| |
|
| |
|
| | def _read_all_delete_files(fs: FileSystem, tasks: Iterable[FileScanTask]) -> Dict[str, List[ChunkedArray]]: |
| | deletes_per_file: Dict[str, List[ChunkedArray]] = {} |
| | unique_deletes = set(itertools.chain.from_iterable([task.delete_files for task in tasks])) |
| | if len(unique_deletes) > 0: |
| | executor = ExecutorFactory.get_or_create() |
| | deletes_per_files: Iterator[Dict[str, ChunkedArray]] = executor.map( |
| | lambda args: _read_deletes(*args), [(fs, delete) for delete in unique_deletes] |
| | ) |
| | for delete in deletes_per_files: |
| | for file, arr in delete.items(): |
| | if file in deletes_per_file: |
| | deletes_per_file[file].append(arr) |
| | else: |
| | deletes_per_file[file] = [arr] |
| |
|
| | return deletes_per_file |
| |
|
| |
|
| | def project_table( |
| | tasks: Iterable[FileScanTask], |
| | table_metadata: TableMetadata, |
| | io: FileIO, |
| | row_filter: BooleanExpression, |
| | projected_schema: Schema, |
| | case_sensitive: bool = True, |
| | limit: Optional[int] = None, |
| | ) -> pa.Table: |
| | """Resolve the right columns based on the identifier. |
| | |
| | Args: |
| | tasks (Iterable[FileScanTask]): A URI or a path to a local file. |
| | table_metadata (TableMetadata): The table metadata of the table that's being queried |
| | io (FileIO): A FileIO to open streams to the object store |
| | row_filter (BooleanExpression): The expression for filtering rows. |
| | projected_schema (Schema): The output schema. |
| | case_sensitive (bool): Case sensitivity when looking up column names. |
| | limit (Optional[int]): Limit the number of records. |
| | |
| | Raises: |
| | ResolveError: When an incompatible query is done. |
| | """ |
| | scheme, netloc, _ = PyArrowFileIO.parse_location(table_metadata.location) |
| | if isinstance(io, PyArrowFileIO): |
| | fs = io.fs_by_scheme(scheme, netloc) |
| | else: |
| | try: |
| | from pyiceberg.io.fsspec import FsspecFileIO |
| |
|
| | if isinstance(io, FsspecFileIO): |
| | from pyarrow.fs import PyFileSystem |
| |
|
| | fs = PyFileSystem(FSSpecHandler(io.get_fs(scheme))) |
| | else: |
| | raise ValueError(f"Expected PyArrowFileIO or FsspecFileIO, got: {io}") |
| | except ModuleNotFoundError as e: |
| | |
| | raise ValueError(f"Expected PyArrowFileIO or FsspecFileIO, got: {io}") from e |
| |
|
| | bound_row_filter = bind(table_metadata.schema(), row_filter, case_sensitive=case_sensitive) |
| |
|
| | projected_field_ids = { |
| | id for id in projected_schema.field_ids if not isinstance(projected_schema.find_type(id), (MapType, ListType)) |
| | }.union(extract_field_ids(bound_row_filter)) |
| |
|
| | deletes_per_file = _read_all_delete_files(fs, tasks) |
| | executor = ExecutorFactory.get_or_create() |
| | futures = [ |
| | executor.submit( |
| | _task_to_table, |
| | fs, |
| | task, |
| | bound_row_filter, |
| | projected_schema, |
| | projected_field_ids, |
| | deletes_per_file.get(task.file.file_path), |
| | case_sensitive, |
| | limit, |
| | table_metadata.name_mapping(), |
| | ) |
| | for task in tasks |
| | ] |
| | total_row_count = 0 |
| | |
| | futures_index = {f: i for i, f in enumerate(futures)} |
| | completed_futures: SortedList[Future[pa.Table]] = SortedList(iterable=[], key=lambda f: futures_index[f]) |
| | for future in concurrent.futures.as_completed(futures): |
| | completed_futures.add(future) |
| | if table_result := future.result(): |
| | total_row_count += len(table_result) |
| | |
| | if limit is not None and total_row_count >= limit: |
| | break |
| |
|
| | |
| | if limit is not None: |
| | _ = [f.cancel() for f in futures if not f.done()] |
| |
|
| | tables = [f.result() for f in completed_futures if f.result()] |
| |
|
| | if len(tables) < 1: |
| | return pa.Table.from_batches([], schema=schema_to_pyarrow(projected_schema, include_field_ids=False)) |
| |
|
| | result = pa.concat_tables(tables) |
| |
|
| | if limit is not None: |
| | return result.slice(0, limit) |
| |
|
| | return result |
| |
|
| |
|
| | def to_requested_schema(requested_schema: Schema, file_schema: Schema, table: pa.Table) -> pa.Table: |
| | struct_array = visit_with_partner(requested_schema, table, ArrowProjectionVisitor(file_schema), ArrowAccessor(file_schema)) |
| |
|
| | arrays = [] |
| | fields = [] |
| | for pos, field in enumerate(requested_schema.fields): |
| | array = struct_array.field(pos) |
| | arrays.append(array) |
| | fields.append(pa.field(field.name, array.type, field.optional)) |
| | return pa.Table.from_arrays(arrays, schema=pa.schema(fields)) |
| |
|
| |
|
| | class ArrowProjectionVisitor(SchemaWithPartnerVisitor[pa.Array, Optional[pa.Array]]): |
| | file_schema: Schema |
| |
|
| | def __init__(self, file_schema: Schema): |
| | self.file_schema = file_schema |
| |
|
| | def _cast_if_needed(self, field: NestedField, values: pa.Array) -> pa.Array: |
| | file_field = self.file_schema.find_field(field.field_id) |
| | if field.field_type.is_primitive and field.field_type != file_field.field_type: |
| | return values.cast(schema_to_pyarrow(promote(file_field.field_type, field.field_type), include_field_ids=False)) |
| | return values |
| |
|
| | def _construct_field(self, field: NestedField, arrow_type: pa.DataType) -> pa.Field: |
| | return pa.field( |
| | name=field.name, |
| | type=arrow_type, |
| | nullable=field.optional, |
| | metadata={DOC: field.doc} if field.doc is not None else None, |
| | ) |
| |
|
| | def schema(self, schema: Schema, schema_partner: Optional[pa.Array], struct_result: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return struct_result |
| |
|
| | def struct( |
| | self, struct: StructType, struct_array: Optional[pa.Array], field_results: List[Optional[pa.Array]] |
| | ) -> Optional[pa.Array]: |
| | if struct_array is None: |
| | return None |
| | field_arrays: List[pa.Array] = [] |
| | fields: List[pa.Field] = [] |
| | for field, field_array in zip(struct.fields, field_results): |
| | if field_array is not None: |
| | array = self._cast_if_needed(field, field_array) |
| | field_arrays.append(array) |
| | fields.append(self._construct_field(field, array.type)) |
| | elif field.optional: |
| | arrow_type = schema_to_pyarrow(field.field_type, include_field_ids=False) |
| | field_arrays.append(pa.nulls(len(struct_array), type=arrow_type)) |
| | fields.append(self._construct_field(field, arrow_type)) |
| | else: |
| | raise ResolveError(f"Field is required, and could not be found in the file: {field}") |
| |
|
| | return pa.StructArray.from_arrays(arrays=field_arrays, fields=pa.struct(fields)) |
| |
|
| | def field(self, field: NestedField, _: Optional[pa.Array], field_array: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return field_array |
| |
|
| | def list(self, list_type: ListType, list_array: Optional[pa.Array], value_array: Optional[pa.Array]) -> Optional[pa.Array]: |
| | if isinstance(list_array, pa.ListArray) and value_array is not None: |
| | if isinstance(value_array, pa.StructArray): |
| | |
| | |
| | list_array = pa.ListArray.from_arrays(list_array.offsets, value_array) |
| |
|
| | arrow_field = pa.list_(self._construct_field(list_type.element_field, value_array.type)) |
| | return list_array.cast(arrow_field) |
| | else: |
| | return None |
| |
|
| | def map( |
| | self, map_type: MapType, map_array: Optional[pa.Array], key_result: Optional[pa.Array], value_result: Optional[pa.Array] |
| | ) -> Optional[pa.Array]: |
| | if isinstance(map_array, pa.MapArray) and key_result is not None and value_result is not None: |
| | arrow_field = pa.map_( |
| | self._construct_field(map_type.key_field, key_result.type), |
| | self._construct_field(map_type.value_field, value_result.type), |
| | ) |
| | if isinstance(value_result, pa.StructArray): |
| | |
| | return pa.MapArray.from_arrays(map_array.offsets, key_result, value_result, arrow_field) |
| | else: |
| | return map_array.cast(arrow_field) |
| | else: |
| | return None |
| |
|
| | def primitive(self, _: PrimitiveType, array: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return array |
| |
|
| |
|
| | class ArrowAccessor(PartnerAccessor[pa.Array]): |
| | file_schema: Schema |
| |
|
| | def __init__(self, file_schema: Schema): |
| | self.file_schema = file_schema |
| |
|
| | def schema_partner(self, partner: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return partner |
| |
|
| | def field_partner(self, partner_struct: Optional[pa.Array], field_id: int, _: str) -> Optional[pa.Array]: |
| | if partner_struct: |
| | |
| | try: |
| | name = self.file_schema.find_field(field_id).name |
| | except ValueError: |
| | return None |
| |
|
| | if isinstance(partner_struct, pa.StructArray): |
| | return partner_struct.field(name) |
| | elif isinstance(partner_struct, pa.Table): |
| | return partner_struct.column(name).combine_chunks() |
| |
|
| | return None |
| |
|
| | def list_element_partner(self, partner_list: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return partner_list.values if isinstance(partner_list, pa.ListArray) else None |
| |
|
| | def map_key_partner(self, partner_map: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return partner_map.keys if isinstance(partner_map, pa.MapArray) else None |
| |
|
| | def map_value_partner(self, partner_map: Optional[pa.Array]) -> Optional[pa.Array]: |
| | return partner_map.items if isinstance(partner_map, pa.MapArray) else None |
| |
|
| |
|
| | def _primitive_to_physical(iceberg_type: PrimitiveType) -> str: |
| | return visit(iceberg_type, _PRIMITIVE_TO_PHYSICAL_TYPE_VISITOR) |
| |
|
| |
|
| | class PrimitiveToPhysicalType(SchemaVisitorPerPrimitiveType[str]): |
| | def schema(self, schema: Schema, struct_result: str) -> str: |
| | raise ValueError(f"Expected primitive-type, got: {schema}") |
| |
|
| | def struct(self, struct: StructType, field_results: List[str]) -> str: |
| | raise ValueError(f"Expected primitive-type, got: {struct}") |
| |
|
| | def field(self, field: NestedField, field_result: str) -> str: |
| | raise ValueError(f"Expected primitive-type, got: {field}") |
| |
|
| | def list(self, list_type: ListType, element_result: str) -> str: |
| | raise ValueError(f"Expected primitive-type, got: {list_type}") |
| |
|
| | def map(self, map_type: MapType, key_result: str, value_result: str) -> str: |
| | raise ValueError(f"Expected primitive-type, got: {map_type}") |
| |
|
| | def visit_fixed(self, fixed_type: FixedType) -> str: |
| | return "FIXED_LEN_BYTE_ARRAY" |
| |
|
| | def visit_decimal(self, decimal_type: DecimalType) -> str: |
| | return "FIXED_LEN_BYTE_ARRAY" |
| |
|
| | def visit_boolean(self, boolean_type: BooleanType) -> str: |
| | return "BOOLEAN" |
| |
|
| | def visit_integer(self, integer_type: IntegerType) -> str: |
| | return "INT32" |
| |
|
| | def visit_long(self, long_type: LongType) -> str: |
| | return "INT64" |
| |
|
| | def visit_float(self, float_type: FloatType) -> str: |
| | return "FLOAT" |
| |
|
| | def visit_double(self, double_type: DoubleType) -> str: |
| | return "DOUBLE" |
| |
|
| | def visit_date(self, date_type: DateType) -> str: |
| | return "INT32" |
| |
|
| | def visit_time(self, time_type: TimeType) -> str: |
| | return "INT64" |
| |
|
| | def visit_timestamp(self, timestamp_type: TimestampType) -> str: |
| | return "INT64" |
| |
|
| | def visit_timestamptz(self, timestamptz_type: TimestamptzType) -> str: |
| | return "INT64" |
| |
|
| | def visit_string(self, string_type: StringType) -> str: |
| | return "BYTE_ARRAY" |
| |
|
| | def visit_uuid(self, uuid_type: UUIDType) -> str: |
| | return "FIXED_LEN_BYTE_ARRAY" |
| |
|
| | def visit_binary(self, binary_type: BinaryType) -> str: |
| | return "BYTE_ARRAY" |
| |
|
| |
|
| | _PRIMITIVE_TO_PHYSICAL_TYPE_VISITOR = PrimitiveToPhysicalType() |
| |
|
| |
|
| | class StatsAggregator: |
| | current_min: Any |
| | current_max: Any |
| | trunc_length: Optional[int] |
| |
|
| | def __init__(self, iceberg_type: PrimitiveType, physical_type_string: str, trunc_length: Optional[int] = None) -> None: |
| | self.current_min = None |
| | self.current_max = None |
| | self.trunc_length = trunc_length |
| |
|
| | expected_physical_type = _primitive_to_physical(iceberg_type) |
| | if expected_physical_type != physical_type_string: |
| | raise ValueError( |
| | f"Unexpected physical type {physical_type_string} for {iceberg_type}, expected {expected_physical_type}" |
| | ) |
| |
|
| | self.primitive_type = iceberg_type |
| |
|
| | def serialize(self, value: Any) -> bytes: |
| | return to_bytes(self.primitive_type, value) |
| |
|
| | def update_min(self, val: Optional[Any]) -> None: |
| | if self.current_min is None: |
| | self.current_min = val |
| | elif val is not None: |
| | self.current_min = min(val, self.current_min) |
| |
|
| | def update_max(self, val: Optional[Any]) -> None: |
| | if self.current_max is None: |
| | self.current_max = val |
| | elif val is not None: |
| | self.current_max = max(val, self.current_max) |
| |
|
| | def min_as_bytes(self) -> Optional[bytes]: |
| | if self.current_min is None: |
| | return None |
| |
|
| | return self.serialize( |
| | self.current_min |
| | if self.trunc_length is None |
| | else TruncateTransform(width=self.trunc_length).transform(self.primitive_type)(self.current_min) |
| | ) |
| |
|
| | def max_as_bytes(self) -> Optional[bytes]: |
| | if self.current_max is None: |
| | return None |
| |
|
| | if self.primitive_type == StringType(): |
| | if not isinstance(self.current_max, str): |
| | raise ValueError("Expected the current_max to be a string") |
| | s_result = truncate_upper_bound_text_string(self.current_max, self.trunc_length) |
| | return self.serialize(s_result) if s_result is not None else None |
| | elif self.primitive_type == BinaryType(): |
| | if not isinstance(self.current_max, bytes): |
| | raise ValueError("Expected the current_max to be bytes") |
| | b_result = truncate_upper_bound_binary_string(self.current_max, self.trunc_length) |
| | return self.serialize(b_result) if b_result is not None else None |
| | else: |
| | if self.trunc_length is not None: |
| | raise ValueError(f"{self.primitive_type} cannot be truncated") |
| | return self.serialize(self.current_max) |
| |
|
| |
|
| | DEFAULT_TRUNCATION_LENGTH = 16 |
| | TRUNCATION_EXPR = r"^truncate\((\d+)\)$" |
| |
|
| |
|
| | class MetricModeTypes(Enum): |
| | TRUNCATE = "truncate" |
| | NONE = "none" |
| | COUNTS = "counts" |
| | FULL = "full" |
| |
|
| |
|
| | @dataclass(frozen=True) |
| | class MetricsMode(Singleton): |
| | type: MetricModeTypes |
| | length: Optional[int] = None |
| |
|
| |
|
| | def match_metrics_mode(mode: str) -> MetricsMode: |
| | sanitized_mode = mode.strip().lower() |
| | if sanitized_mode.startswith("truncate"): |
| | m = re.match(TRUNCATION_EXPR, sanitized_mode) |
| | if m: |
| | length = int(m[1]) |
| | if length < 1: |
| | raise ValueError("Truncation length must be larger than 0") |
| | return MetricsMode(MetricModeTypes.TRUNCATE, int(m[1])) |
| | else: |
| | raise ValueError(f"Malformed truncate: {mode}") |
| | elif sanitized_mode == "none": |
| | return MetricsMode(MetricModeTypes.NONE) |
| | elif sanitized_mode == "counts": |
| | return MetricsMode(MetricModeTypes.COUNTS) |
| | elif sanitized_mode == "full": |
| | return MetricsMode(MetricModeTypes.FULL) |
| | else: |
| | raise ValueError(f"Unsupported metrics mode: {mode}") |
| |
|
| |
|
| | @dataclass(frozen=True) |
| | class StatisticsCollector: |
| | field_id: int |
| | iceberg_type: PrimitiveType |
| | mode: MetricsMode |
| | column_name: str |
| |
|
| |
|
| | class PyArrowStatisticsCollector(PreOrderSchemaVisitor[List[StatisticsCollector]]): |
| | _field_id: int = 0 |
| | _schema: Schema |
| | _properties: Dict[str, str] |
| | _default_mode: str |
| |
|
| | def __init__(self, schema: Schema, properties: Dict[str, str]): |
| | self._schema = schema |
| | self._properties = properties |
| | self._default_mode = self._properties.get( |
| | TableProperties.DEFAULT_WRITE_METRICS_MODE, TableProperties.DEFAULT_WRITE_METRICS_MODE_DEFAULT |
| | ) |
| |
|
| | def schema(self, schema: Schema, struct_result: Callable[[], List[StatisticsCollector]]) -> List[StatisticsCollector]: |
| | return struct_result() |
| |
|
| | def struct( |
| | self, struct: StructType, field_results: List[Callable[[], List[StatisticsCollector]]] |
| | ) -> List[StatisticsCollector]: |
| | return list(itertools.chain(*[result() for result in field_results])) |
| |
|
| | def field(self, field: NestedField, field_result: Callable[[], List[StatisticsCollector]]) -> List[StatisticsCollector]: |
| | self._field_id = field.field_id |
| | return field_result() |
| |
|
| | def list(self, list_type: ListType, element_result: Callable[[], List[StatisticsCollector]]) -> List[StatisticsCollector]: |
| | self._field_id = list_type.element_id |
| | return element_result() |
| |
|
| | def map( |
| | self, |
| | map_type: MapType, |
| | key_result: Callable[[], List[StatisticsCollector]], |
| | value_result: Callable[[], List[StatisticsCollector]], |
| | ) -> List[StatisticsCollector]: |
| | self._field_id = map_type.key_id |
| | k = key_result() |
| | self._field_id = map_type.value_id |
| | v = value_result() |
| | return k + v |
| |
|
| | def primitive(self, primitive: PrimitiveType) -> List[StatisticsCollector]: |
| | column_name = self._schema.find_column_name(self._field_id) |
| | if column_name is None: |
| | return [] |
| |
|
| | metrics_mode = match_metrics_mode(self._default_mode) |
| |
|
| | col_mode = self._properties.get(f"{TableProperties.METRICS_MODE_COLUMN_CONF_PREFIX}.{column_name}") |
| | if col_mode: |
| | metrics_mode = match_metrics_mode(col_mode) |
| |
|
| | if ( |
| | not (isinstance(primitive, StringType) or isinstance(primitive, BinaryType)) |
| | and metrics_mode.type == MetricModeTypes.TRUNCATE |
| | ): |
| | metrics_mode = MetricsMode(MetricModeTypes.FULL) |
| |
|
| | is_nested = column_name.find(".") >= 0 |
| |
|
| | if is_nested and metrics_mode.type in [MetricModeTypes.TRUNCATE, MetricModeTypes.FULL]: |
| | metrics_mode = MetricsMode(MetricModeTypes.COUNTS) |
| |
|
| | return [StatisticsCollector(field_id=self._field_id, iceberg_type=primitive, mode=metrics_mode, column_name=column_name)] |
| |
|
| |
|
| | def compute_statistics_plan( |
| | schema: Schema, |
| | table_properties: Dict[str, str], |
| | ) -> Dict[int, StatisticsCollector]: |
| | """ |
| | Compute the statistics plan for all columns. |
| | |
| | The resulting list is assumed to have the same length and same order as the columns in the pyarrow table. |
| | This allows the list to map from the column index to the Iceberg column ID. |
| | For each element, the desired metrics collection that was provided by the user in the configuration |
| | is computed and then adjusted according to the data type of the column. For nested columns the minimum |
| | and maximum values are not computed. And truncation is only applied to text of binary strings. |
| | |
| | Args: |
| | table_properties (from pyiceberg.table.metadata.TableMetadata): The Iceberg table metadata properties. |
| | They are required to compute the mapping of column position to iceberg schema type id. It's also |
| | used to set the mode for column metrics collection |
| | """ |
| | stats_cols = pre_order_visit(schema, PyArrowStatisticsCollector(schema, table_properties)) |
| | result: Dict[int, StatisticsCollector] = {} |
| | for stats_col in stats_cols: |
| | result[stats_col.field_id] = stats_col |
| | return result |
| |
|
| |
|
| | @dataclass(frozen=True) |
| | class ID2ParquetPath: |
| | field_id: int |
| | parquet_path: str |
| |
|
| |
|
| | class ID2ParquetPathVisitor(PreOrderSchemaVisitor[List[ID2ParquetPath]]): |
| | _field_id: int = 0 |
| | _path: List[str] |
| |
|
| | def __init__(self) -> None: |
| | self._path = [] |
| |
|
| | def schema(self, schema: Schema, struct_result: Callable[[], List[ID2ParquetPath]]) -> List[ID2ParquetPath]: |
| | return struct_result() |
| |
|
| | def struct(self, struct: StructType, field_results: List[Callable[[], List[ID2ParquetPath]]]) -> List[ID2ParquetPath]: |
| | return list(itertools.chain(*[result() for result in field_results])) |
| |
|
| | def field(self, field: NestedField, field_result: Callable[[], List[ID2ParquetPath]]) -> List[ID2ParquetPath]: |
| | self._field_id = field.field_id |
| | self._path.append(field.name) |
| | result = field_result() |
| | self._path.pop() |
| | return result |
| |
|
| | def list(self, list_type: ListType, element_result: Callable[[], List[ID2ParquetPath]]) -> List[ID2ParquetPath]: |
| | self._field_id = list_type.element_id |
| | self._path.append("list.element") |
| | result = element_result() |
| | self._path.pop() |
| | return result |
| |
|
| | def map( |
| | self, |
| | map_type: MapType, |
| | key_result: Callable[[], List[ID2ParquetPath]], |
| | value_result: Callable[[], List[ID2ParquetPath]], |
| | ) -> List[ID2ParquetPath]: |
| | self._field_id = map_type.key_id |
| | self._path.append("key_value.key") |
| | k = key_result() |
| | self._path.pop() |
| | self._field_id = map_type.value_id |
| | self._path.append("key_value.value") |
| | v = value_result() |
| | self._path.pop() |
| | return k + v |
| |
|
| | def primitive(self, primitive: PrimitiveType) -> List[ID2ParquetPath]: |
| | return [ID2ParquetPath(field_id=self._field_id, parquet_path=".".join(self._path))] |
| |
|
| |
|
| | def parquet_path_to_id_mapping( |
| | schema: Schema, |
| | ) -> Dict[str, int]: |
| | """ |
| | Compute the mapping of parquet column path to Iceberg ID. |
| | |
| | For each column, the parquet file metadata has a path_in_schema attribute that follows |
| | a specific naming scheme for nested columnds. This function computes a mapping of |
| | the full paths to the corresponding Iceberg IDs. |
| | |
| | Args: |
| | schema (pyiceberg.schema.Schema): The current table schema. |
| | """ |
| | result: Dict[str, int] = {} |
| | for pair in pre_order_visit(schema, ID2ParquetPathVisitor()): |
| | result[pair.parquet_path] = pair.field_id |
| | return result |
| |
|
| |
|
| | @dataclass(frozen=True) |
| | class DataFileStatistics: |
| | record_count: int |
| | column_sizes: Dict[int, int] |
| | value_counts: Dict[int, int] |
| | null_value_counts: Dict[int, int] |
| | nan_value_counts: Dict[int, int] |
| | column_aggregates: Dict[int, StatsAggregator] |
| | split_offsets: List[int] |
| |
|
| | def _partition_value(self, partition_field: PartitionField, schema: Schema) -> Any: |
| | if partition_field.source_id not in self.column_aggregates: |
| | return None |
| |
|
| | if not partition_field.transform.preserves_order: |
| | raise ValueError( |
| | f"Cannot infer partition value from parquet metadata for a non-linear Partition Field: {partition_field.name} with transform {partition_field.transform}" |
| | ) |
| |
|
| | lower_value = partition_record_value( |
| | partition_field=partition_field, |
| | value=self.column_aggregates[partition_field.source_id].current_min, |
| | schema=schema, |
| | ) |
| | upper_value = partition_record_value( |
| | partition_field=partition_field, |
| | value=self.column_aggregates[partition_field.source_id].current_max, |
| | schema=schema, |
| | ) |
| | if lower_value != upper_value: |
| | raise ValueError( |
| | f"Cannot infer partition value from parquet metadata as there are more than one partition values for Partition Field: {partition_field.name}. {lower_value=}, {upper_value=}" |
| | ) |
| | return lower_value |
| |
|
| | def partition(self, partition_spec: PartitionSpec, schema: Schema) -> Record: |
| | return Record(**{field.name: self._partition_value(field, schema) for field in partition_spec.fields}) |
| |
|
| | def to_serialized_dict(self) -> Dict[str, Any]: |
| | lower_bounds = {} |
| | upper_bounds = {} |
| |
|
| | for k, agg in self.column_aggregates.items(): |
| | _min = agg.min_as_bytes() |
| | if _min is not None: |
| | lower_bounds[k] = _min |
| | _max = agg.max_as_bytes() |
| | if _max is not None: |
| | upper_bounds[k] = _max |
| | return { |
| | "record_count": self.record_count, |
| | "column_sizes": self.column_sizes, |
| | "value_counts": self.value_counts, |
| | "null_value_counts": self.null_value_counts, |
| | "nan_value_counts": self.nan_value_counts, |
| | "lower_bounds": lower_bounds, |
| | "upper_bounds": upper_bounds, |
| | "split_offsets": self.split_offsets, |
| | } |
| |
|
| |
|
| | def data_file_statistics_from_parquet_metadata( |
| | parquet_metadata: pq.FileMetaData, |
| | stats_columns: Dict[int, StatisticsCollector], |
| | parquet_column_mapping: Dict[str, int], |
| | ) -> DataFileStatistics: |
| | """ |
| | Compute and return DataFileStatistics that includes the following. |
| | |
| | - record_count |
| | - column_sizes |
| | - value_counts |
| | - null_value_counts |
| | - nan_value_counts |
| | - column_aggregates |
| | - split_offsets |
| | |
| | Args: |
| | parquet_metadata (pyarrow.parquet.FileMetaData): A pyarrow metadata object. |
| | stats_columns (Dict[int, StatisticsCollector]): The statistics gathering plan. It is required to |
| | set the mode for column metrics collection |
| | parquet_column_mapping (Dict[str, int]): The mapping of the parquet file name to the field ID |
| | """ |
| | if parquet_metadata.num_columns != len(stats_columns): |
| | raise ValueError( |
| | f"Number of columns in statistics configuration ({len(stats_columns)}) is different from the number of columns in pyarrow table ({parquet_metadata.num_columns})" |
| | ) |
| |
|
| | if parquet_metadata.num_columns != len(parquet_column_mapping): |
| | raise ValueError( |
| | f"Number of columns in column mapping ({len(parquet_column_mapping)}) is different from the number of columns in pyarrow table ({parquet_metadata.num_columns})" |
| | ) |
| |
|
| | column_sizes: Dict[int, int] = {} |
| | value_counts: Dict[int, int] = {} |
| | split_offsets: List[int] = [] |
| |
|
| | null_value_counts: Dict[int, int] = {} |
| | nan_value_counts: Dict[int, int] = {} |
| |
|
| | col_aggs = {} |
| |
|
| | for r in range(parquet_metadata.num_row_groups): |
| | |
| | |
| | |
| |
|
| | row_group = parquet_metadata.row_group(r) |
| |
|
| | data_offset = row_group.column(0).data_page_offset |
| | dictionary_offset = row_group.column(0).dictionary_page_offset |
| |
|
| | if row_group.column(0).has_dictionary_page and dictionary_offset < data_offset: |
| | split_offsets.append(dictionary_offset) |
| | else: |
| | split_offsets.append(data_offset) |
| |
|
| | invalidate_col: Set[int] = set() |
| |
|
| | for pos in range(parquet_metadata.num_columns): |
| | column = row_group.column(pos) |
| | field_id = parquet_column_mapping[column.path_in_schema] |
| |
|
| | stats_col = stats_columns[field_id] |
| |
|
| | column_sizes.setdefault(field_id, 0) |
| | column_sizes[field_id] += column.total_compressed_size |
| |
|
| | if stats_col.mode == MetricsMode(MetricModeTypes.NONE): |
| | continue |
| |
|
| | value_counts[field_id] = value_counts.get(field_id, 0) + column.num_values |
| |
|
| | if column.is_stats_set: |
| | try: |
| | statistics = column.statistics |
| |
|
| | if statistics.has_null_count: |
| | null_value_counts[field_id] = null_value_counts.get(field_id, 0) + statistics.null_count |
| |
|
| | if stats_col.mode == MetricsMode(MetricModeTypes.COUNTS): |
| | continue |
| |
|
| | if field_id not in col_aggs: |
| | col_aggs[field_id] = StatsAggregator( |
| | stats_col.iceberg_type, statistics.physical_type, stats_col.mode.length |
| | ) |
| |
|
| | col_aggs[field_id].update_min(statistics.min) |
| | col_aggs[field_id].update_max(statistics.max) |
| |
|
| | except pyarrow.lib.ArrowNotImplementedError as e: |
| | invalidate_col.add(field_id) |
| | logger.warning(e) |
| | else: |
| | invalidate_col.add(field_id) |
| | logger.warning("PyArrow statistics missing for column %d when writing file", pos) |
| |
|
| | split_offsets.sort() |
| |
|
| | for field_id in invalidate_col: |
| | del col_aggs[field_id] |
| | del null_value_counts[field_id] |
| |
|
| | return DataFileStatistics( |
| | record_count=parquet_metadata.num_rows, |
| | column_sizes=column_sizes, |
| | value_counts=value_counts, |
| | null_value_counts=null_value_counts, |
| | nan_value_counts=nan_value_counts, |
| | column_aggregates=col_aggs, |
| | split_offsets=split_offsets, |
| | ) |
| |
|
| |
|
| | def write_file(io: FileIO, table_metadata: TableMetadata, tasks: Iterator[WriteTask]) -> Iterator[DataFile]: |
| | parquet_writer_kwargs = _get_parquet_writer_kwargs(table_metadata.properties) |
| | row_group_size = PropertyUtil.property_as_int( |
| | properties=table_metadata.properties, |
| | property_name=TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES, |
| | default=TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES_DEFAULT, |
| | ) |
| |
|
| | def write_parquet(task: WriteTask) -> DataFile: |
| | table_schema = task.schema |
| | arrow_table = pa.Table.from_batches(task.record_batches) |
| | |
| | |
| | if (sanitized_schema := sanitize_column_names(table_schema)) != table_schema: |
| | file_schema = sanitized_schema |
| | arrow_table = to_requested_schema(requested_schema=file_schema, file_schema=table_schema, table=arrow_table) |
| | else: |
| | file_schema = table_schema |
| |
|
| | file_path = f'{table_metadata.location}/data/{task.generate_data_file_path("parquet")}' |
| | fo = io.new_output(file_path) |
| | with fo.create(overwrite=True) as fos: |
| | with pq.ParquetWriter(fos, schema=file_schema.as_arrow(), **parquet_writer_kwargs) as writer: |
| | writer.write(arrow_table, row_group_size=row_group_size) |
| | statistics = data_file_statistics_from_parquet_metadata( |
| | parquet_metadata=writer.writer.metadata, |
| | stats_columns=compute_statistics_plan(file_schema, table_metadata.properties), |
| | parquet_column_mapping=parquet_path_to_id_mapping(file_schema), |
| | ) |
| | data_file = DataFile( |
| | content=DataFileContent.DATA, |
| | file_path=file_path, |
| | file_format=FileFormat.PARQUET, |
| | partition=task.partition_key.partition if task.partition_key else Record(), |
| | file_size_in_bytes=len(fo), |
| | |
| | |
| | |
| | sort_order_id=None, |
| | |
| | spec_id=table_metadata.default_spec_id, |
| | equality_ids=None, |
| | key_metadata=None, |
| | **statistics.to_serialized_dict(), |
| | ) |
| |
|
| | return data_file |
| |
|
| | executor = ExecutorFactory.get_or_create() |
| | data_files = executor.map(write_parquet, tasks) |
| |
|
| | return iter(data_files) |
| |
|
| |
|
| | def bin_pack_arrow_table(tbl: pa.Table, target_file_size: int) -> Iterator[List[pa.RecordBatch]]: |
| | from pyiceberg.utils.bin_packing import PackingIterator |
| |
|
| | avg_row_size_bytes = tbl.nbytes / tbl.num_rows |
| | target_rows_per_file = target_file_size // avg_row_size_bytes |
| | batches = tbl.to_batches(max_chunksize=target_rows_per_file) |
| | bin_packed_record_batches = PackingIterator( |
| | items=batches, |
| | target_weight=target_file_size, |
| | lookback=len(batches), |
| | weight_func=lambda x: x.nbytes, |
| | largest_bin_first=False, |
| | ) |
| | return bin_packed_record_batches |
| |
|
| |
|
| | def parquet_files_to_data_files(io: FileIO, table_metadata: TableMetadata, file_paths: Iterator[str]) -> Iterator[DataFile]: |
| | for file_path in file_paths: |
| | input_file = io.new_input(file_path) |
| | with input_file.open() as input_stream: |
| | parquet_metadata = pq.read_metadata(input_stream) |
| |
|
| | if visit_pyarrow(parquet_metadata.schema.to_arrow_schema(), _HasIds()): |
| | raise NotImplementedError( |
| | f"Cannot add file {file_path} because it has field IDs. `add_files` only supports addition of files without field_ids" |
| | ) |
| | schema = table_metadata.schema() |
| | statistics = data_file_statistics_from_parquet_metadata( |
| | parquet_metadata=parquet_metadata, |
| | stats_columns=compute_statistics_plan(schema, table_metadata.properties), |
| | parquet_column_mapping=parquet_path_to_id_mapping(schema), |
| | ) |
| | data_file = DataFile( |
| | content=DataFileContent.DATA, |
| | file_path=file_path, |
| | file_format=FileFormat.PARQUET, |
| | partition=statistics.partition(table_metadata.spec(), table_metadata.schema()), |
| | file_size_in_bytes=len(input_file), |
| | sort_order_id=None, |
| | spec_id=table_metadata.default_spec_id, |
| | equality_ids=None, |
| | key_metadata=None, |
| | **statistics.to_serialized_dict(), |
| | ) |
| |
|
| | yield data_file |
| |
|
| |
|
| | ICEBERG_UNCOMPRESSED_CODEC = "uncompressed" |
| | PYARROW_UNCOMPRESSED_CODEC = "none" |
| |
|
| |
|
| | def _get_parquet_writer_kwargs(table_properties: Properties) -> Dict[str, Any]: |
| | for key_pattern in [ |
| | TableProperties.PARQUET_ROW_GROUP_SIZE_BYTES, |
| | TableProperties.PARQUET_PAGE_ROW_LIMIT, |
| | TableProperties.PARQUET_BLOOM_FILTER_MAX_BYTES, |
| | f"{TableProperties.PARQUET_BLOOM_FILTER_COLUMN_ENABLED_PREFIX}.*", |
| | ]: |
| | if unsupported_keys := fnmatch.filter(table_properties, key_pattern): |
| | raise NotImplementedError(f"Parquet writer option(s) {unsupported_keys} not implemented") |
| |
|
| | compression_codec = table_properties.get(TableProperties.PARQUET_COMPRESSION, TableProperties.PARQUET_COMPRESSION_DEFAULT) |
| | compression_level = PropertyUtil.property_as_int( |
| | properties=table_properties, |
| | property_name=TableProperties.PARQUET_COMPRESSION_LEVEL, |
| | default=TableProperties.PARQUET_COMPRESSION_LEVEL_DEFAULT, |
| | ) |
| | if compression_codec == ICEBERG_UNCOMPRESSED_CODEC: |
| | compression_codec = PYARROW_UNCOMPRESSED_CODEC |
| |
|
| | return { |
| | "compression": compression_codec, |
| | "compression_level": compression_level, |
| | "data_page_size": PropertyUtil.property_as_int( |
| | properties=table_properties, |
| | property_name=TableProperties.PARQUET_PAGE_SIZE_BYTES, |
| | default=TableProperties.PARQUET_PAGE_SIZE_BYTES_DEFAULT, |
| | ), |
| | "dictionary_pagesize_limit": PropertyUtil.property_as_int( |
| | properties=table_properties, |
| | property_name=TableProperties.PARQUET_DICT_SIZE_BYTES, |
| | default=TableProperties.PARQUET_DICT_SIZE_BYTES_DEFAULT, |
| | ), |
| | "write_batch_size": PropertyUtil.property_as_int( |
| | properties=table_properties, |
| | property_name=TableProperties.PARQUET_PAGE_ROW_LIMIT, |
| | default=TableProperties.PARQUET_PAGE_ROW_LIMIT_DEFAULT, |
| | ), |
| | } |
| |
|
