python - 如何将任意元数据分配给pyarrow.Table/Parquet列

用例

我将Apache Parquet文件用作快速的IO格式，用于在GeoPandas中使用Python处理的大型空间数据。我将要素几何存储为WKB，并希望将坐标引用系统(CRS)记录为与WKB数据关联的元数据。

代码问题

我正在尝试将任意元数据分配给pyarrow.Field对象。

我尝试过的内容

假设table是从pyarrow.Table实例化的df，即pandas.DataFrame:

df = pd.DataFrame({
        'foo' : [1, 3, 2],
        'bar' : [6, 4, 5]
        })

table = pa.Table.from_pandas(df)

根据pyarrow文档，列元数据包含在属于field(source)的schema中，并且可以将可选元数据添加到field(source)。

如果我尝试为metadata属性分配一个值，则会引发错误:

>>> table.schema.field_by_name('foo').metadata = {'crs' : '4283'}
AttributeError: attribute 'metadata' of 'pyarrow.lib.Field' objects is not writable

>>> table.column(0).field.metadata = {'crs' : '4283'}
AttributeError: attribute 'metadata' of 'pyarrow.lib.Field' objects is not writable

如果我尝试将一个字段(具有通过add_metadata方法关联的元数据)分配给一个字段，它将返回错误:

>>> table.schema.field_by_name('foo') = (
           table.schema.field_by_name('foo').add_metadata({'crs' : '4283'})
           )
SyntaxError: can't assign to function call

>>> table.column(0).field = table.column(0).field.add_metadata({'crs' : '4283'})
AttributeError: attribute 'field' of 'pyarrow.lib.Column' objects is not writable

我什至尝试将元数据分配给pandas.Series对象，例如

df['foo']._metadata.append({'crs' : '4283'})

但是在pandas_metadata对象的schema属性上调用table(docs)方法时，该数据不会在元数据中返回。

研究

在stackoverflow上，this问题仍未得到解答，并且this相关问题涉及Scala，而不是Python和pyarrow。 Elsewhere我已经看到了与pyarrow.Field对象相关联的元数据，但是仅通过从头开始实例化pyarrow.Field和pyarrow.Table对象即可。

PS

这是我第一次发布到stackoverflow，因此在此先感谢您为任何错误表示歉意。

最佳答案

“箭头”中的“所有内容”都是不可变的，因此，正如您所经历的那样，您不能简单地修改任何字段或架构的元数据。唯一的方法是使用添加的元数据创建"new"表。我将新引号放在引号之间，因为无需实际复制表即可完成此操作，因为在幕后这只是在移动指针。这是一些代码，显示了如何在Arrow元数据中存储任意字典(只要它们是json可序列化的)以及如何检索它们:

def set_metadata(tbl, col_meta={}, tbl_meta={}):
    """Store table- and column-level metadata as json-encoded byte strings.

    Table-level metadata is stored in the table's schema.
    Column-level metadata is stored in the table columns' fields.

    To update the metadata, first new fields are created for all columns.
    Next a schema is created using the new fields and updated table metadata.
    Finally a new table is created by replacing the old one's schema, but
    without copying any data.

    Args:
        tbl (pyarrow.Table): The table to store metadata in
        col_meta: A json-serializable dictionary with column metadata in the form
            {
                'column_1': {'some': 'data', 'value': 1},
                'column_2': {'more': 'stuff', 'values': [1,2,3]}
            }
        tbl_meta: A json-serializable dictionary with table-level metadata.
    """
    # Create updated column fields with new metadata
    if col_meta or tbl_meta:
        fields = []
        for col in tbl.itercolumns():
            if col.name in col_meta:
                # Get updated column metadata
                metadata = col.field.metadata or {}
                for k, v in col_meta[col.name].items():
                    metadata[k] = json.dumps(v).encode('utf-8')
                # Update field with updated metadata
                fields.append(col.field.add_metadata(metadata))
            else:
                fields.append(col.field)

        # Get updated table metadata
        tbl_metadata = tbl.schema.metadata
        for k, v in tbl_meta.items():
            tbl_metadata[k] = json.dumps(v).encode('utf-8')

        # Create new schema with updated field metadata and updated table metadata
        schema = pa.schema(fields, metadata=tbl_metadata)

        # With updated schema build new table (shouldn't copy data)
        # tbl = pa.Table.from_batches(tbl.to_batches(), schema)
        tbl = pa.Table.from_arrays(list(tbl.itercolumns()), schema=schema)

    return tbl


def decode_metadata(metadata):
    """Arrow stores metadata keys and values as bytes.
    We store "arbitrary" data as json-encoded strings (utf-8),
    which are here decoded into normal dict.
    """
    if not metadata:
        # None or {} are not decoded
        return metadata

    decoded = {}
    for k, v in metadata.items():
        key = k.decode('utf-8')
        val = json.loads(v.decode('utf-8'))
        decoded[key] = val
    return decoded


def table_metadata(tbl):
    """Get table metadata as dict."""
    return decode_metadata(tbl.schema.metadata)


def column_metadata(tbl):
    """Get column metadata as dict."""
    return {col.name: decode_metadata(col.field.metadata) for col in tbl.itercolumns()}


def get_metadata(tbl):
    """Get column and table metadata as dicts."""
    return column_metadata(tbl), table_metadata(tbl)

简而言之，您可以使用添加的元数据创建新字段，将字段聚合到新架构中，然后根据现有表和新架构创建新表。一切都太漫长了。理想情况下，pyarrow将具有方便的功能，可使用较少的代码行来执行此操作，但是最后我检查了这是执行此操作的唯一方法。

唯一的复杂之处在于元数据以字节形式存储在Arrow中，因此在上面的代码中，我将元数据存储为json可序列化字典，并在utf-8中进行了编码。

关于python - 如何将任意元数据分配给pyarrow.Table/Parquet列，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/55546027/