Class SimpleResultMetaData

lib/sqlalchemy/engine/result.py:246–424

result metadata for in-memory collections.

class SimpleResultMetaData(ResultMetaData):
    """result metadata for in-memory collections."""

    __slots__ = (
        "_keys",
        "_keymap",
        "_processors",
        "_tuplefilter",
        "_translated_indexes",
        "_create_unique_filters",
        "_key_to_index",
        "_ambiguous_keys",
    )

    _keys: Sequence[str]

    def __init__(
        self,
        keys: Sequence[str],
        extra: Optional[Sequence[Any]] = None,
        _processors: Optional[_ProcessorsType] = None,
        _tuplefilter: Optional[_TupleGetterType] = None,
        _translated_indexes: Optional[Sequence[int]] = None,
        _create_unique_filters: Optional[
            Callable[
                [Any],
                Sequence[Optional[Callable[[Any], Any]]],
            ]
        ] = None,
        _ambiguous_keys: Optional[frozenset[str]] = None,
    ):
        self._keys = list(keys)
        self._tuplefilter = _tuplefilter
        self._translated_indexes = _translated_indexes
        self._create_unique_filters = _create_unique_filters
        if extra:
            assert len(self._keys) == len(extra)
            recs_names = [
                (
                    (name,) + (extras if extras else ()),
                    (index, name, extras),
                )
                for index, (name, extras) in enumerate(zip(self._keys, extra))
            ]
        else:
            recs_names = [
                ((name,), (index, name, ()))
                for index, name in enumerate(self._keys)
            ]

        self._keymap = {key: rec for keys, rec in recs_names for key in keys}

        if _ambiguous_keys:
            for name in _ambiguous_keys.intersection(self._keymap):
                rec = self._keymap[name]
                self._keymap[name] = (None,) + rec[1:]

        self._processors = _processors