Edit: row.py
# engine/row.py # Copyright (C) 2005-2025 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: https://www.opensource.org/licenses/mit-license.php """Define row constructs including :class:`.Row`.""" from __future__ import annotations from abc import ABC import collections.abc as collections_abc import operator import typing from typing import Any from typing import Callable from typing import Dict from typing import Generic from typing import Iterator from typing import List from typing import Mapping from typing import NoReturn from typing import Optional from typing import overload from typing import Sequence from typing import Tuple from typing import TYPE_CHECKING from typing import TypeVar from typing import Union from ..sql import util as sql_util from ..util import deprecated from ..util._has_cy import HAS_CYEXTENSION if TYPE_CHECKING or not HAS_CYEXTENSION: from ._py_row import BaseRow as BaseRow else: from sqlalchemy.cyextension.resultproxy import BaseRow as BaseRow if TYPE_CHECKING: from .result import _KeyType from .result import _ProcessorsType from .result import RMKeyView _T = TypeVar("_T", bound=Any) _TP = TypeVar("_TP", bound=Tuple[Any, ...]) class Row(BaseRow, Sequence[Any], Generic[_TP]): """Represent a single result row. The :class:`.Row` object represents a row of a database result. It is typically associated in the 1.x series of SQLAlchemy with the :class:`_engine.CursorResult` object, however is also used by the ORM for tuple-like results as of SQLAlchemy 1.4. The :class:`.Row` object seeks to act as much like a Python named tuple as possible. For mapping (i.e. dictionary) behavior on a row, such as testing for containment of keys, refer to the :attr:`.Row._mapping` attribute. .. seealso:: :ref:`tutorial_selecting_data` - includes examples of selecting rows from SELECT statements. .. versionchanged:: 1.4 Renamed ``RowProxy`` to :class:`.Row`. :class:`.Row` is no longer a "proxy" object in that it contains the final form of data within it, and now acts mostly like a named tuple. Mapping-like functionality is moved to the :attr:`.Row._mapping` attribute. See :ref:`change_4710_core` for background on this change. """ __slots__ = () def __setattr__(self, name: str, value: Any) -> NoReturn: raise AttributeError("can't set attribute") def __delattr__(self, name: str) -> NoReturn: raise AttributeError("can't delete attribute") def _tuple(self) -> _TP: """Return a 'tuple' form of this :class:`.Row`. At runtime, this method returns "self"; the :class:`.Row` object is already a named tuple. However, at the typing level, if this :class:`.Row` is typed, the "tuple" return type will be a :pep:`484` ``Tuple`` datatype that contains typing information about individual elements, supporting typed unpacking and attribute access. .. versionadded:: 2.0.19 - The :meth:`.Row._tuple` method supersedes the previous :meth:`.Row.tuple` method, which is now underscored to avoid name conflicts with column names in the same way as other named-tuple methods on :class:`.Row`. .. seealso:: :attr:`.Row._t` - shorthand attribute notation :meth:`.Result.tuples` """ return self # type: ignore @deprecated( "2.0.19", "The :meth:`.Row.tuple` method is deprecated in favor of " ":meth:`.Row._tuple`; all :class:`.Row` " "methods and library-level attributes are intended to be underscored " "to avoid name conflicts. Please use :meth:`Row._tuple`.", ) def tuple(self) -> _TP: """Return a 'tuple' form of this :class:`.Row`. .. versionadded:: 2.0 """ return self._tuple() @property def _t(self) -> _TP: """A synonym for :meth:`.Row._tuple`. .. versionadded:: 2.0.19 - The :attr:`.Row._t` attribute supersedes the previous :attr:`.Row.t` attribute, which is now underscored to avoid name conflicts with column names in the same way as other named-tuple methods on :class:`.Row`. .. seealso:: :attr:`.Result.t` """ return self # type: ignore @property @deprecated( "2.0.19", "The :attr:`.Row.t` attribute is deprecated in favor of " ":attr:`.Row._t`; all :class:`.Row` " "methods and library-level attributes are intended to be underscored " "to avoid name conflicts. Please use :attr:`Row._t`.", ) def t(self) -> _TP: """A synonym for :meth:`.Row._tuple`. .. versionadded:: 2.0 """ return self._t @property def _mapping(self) -> RowMapping: """Return a :class:`.RowMapping` for this :class:`.Row`. This object provides a consistent Python mapping (i.e. dictionary) interface for the data contained within the row. The :class:`.Row` by itself behaves like a named tuple. .. seealso:: :attr:`.Row._fields` .. versionadded:: 1.4 """ return RowMapping(self._parent, None, self._key_to_index, self._data) def _filter_on_values( self, processor: Optional[_ProcessorsType] ) -> Row[Any]: return Row(self._parent, processor, self._key_to_index, self._data) if not TYPE_CHECKING: def _special_name_accessor(name: str) -> Any: """Handle ambiguous names such as "count" and "index" """ @property def go(self: Row) -> Any: if self._parent._has_key(name): return self.__getattr__(name) else: def meth(*arg: Any, **kw: Any) -> Any: return getattr(collections_abc.Sequence, name)( self, *arg, **kw ) return meth return go count = _special_name_accessor("count") index = _special_name_accessor("index") def __contains__(self, key: Any) -> bool: return key in self._data def _op(self, other: Any, op: Callable[[Any, Any], bool]) -> bool: return ( op(self._to_tuple_instance(), other._to_tuple_instance()) if isinstance(other, Row) else op(self._to_tuple_instance(), other) ) __hash__ = BaseRow.__hash__ if TYPE_CHECKING: @overload def __getitem__(self, index: int) -> Any: ... @overload def __getitem__(self, index: slice) -> Sequence[Any]: ... def __getitem__(self, index: Union[int, slice]) -> Any: ... def __lt__(self, other: Any) -> bool: return self._op(other, operator.lt) def __le__(self, other: Any) -> bool: return self._op(other, operator.le) def __ge__(self, other: Any) -> bool: return self._op(other, operator.ge) def __gt__(self, other: Any) -> bool: return self._op(other, operator.gt) def __eq__(self, other: Any) -> bool: return self._op(other, operator.eq) def __ne__(self, other: Any) -> bool: return self._op(other, operator.ne) def __repr__(self) -> str: return repr(sql_util._repr_row(self)) @property def _fields(self) -> Tuple[str, ...]: """Return a tuple of string keys as represented by this :class:`.Row`. The keys can represent the labels of the columns returned by a core statement or the names of the orm classes returned by an orm execution. This attribute is analogous to the Python named tuple ``._fields`` attribute. .. versionadded:: 1.4 .. seealso:: :attr:`.Row._mapping` """ return tuple([k for k in self._parent.keys if k is not None]) def _asdict(self) -> Dict[str, Any]: """Return a new dict which maps field names to their corresponding values. This method is analogous to the Python named tuple ``._asdict()`` method, and works by applying the ``dict()`` constructor to the :attr:`.Row._mapping` attribute. .. versionadded:: 1.4 .. seealso:: :attr:`.Row._mapping` """ return dict(self._mapping) BaseRowProxy = BaseRow RowProxy = Row class ROMappingView(ABC): __slots__ = () _items: Sequence[Any] _mapping: Mapping["_KeyType", Any] def __init__( self, mapping: Mapping["_KeyType", Any], items: Sequence[Any] ): self._mapping = mapping # type: ignore[misc] self._items = items # type: ignore[misc] def __len__(self) -> int: return len(self._items) def __repr__(self) -> str: return "{0.__class__.__name__}({0._mapping!r})".format(self) def __iter__(self) -> Iterator[Any]: return iter(self._items) def __contains__(self, item: Any) -> bool: return item in self._items def __eq__(self, other: Any) -> bool: return list(other) == list(self) def __ne__(self, other: Any) -> bool: return list(other) != list(self) class ROMappingKeysValuesView( ROMappingView, typing.KeysView["_KeyType"], typing.ValuesView[Any] ): __slots__ = ("_items",) # mapping slot is provided by KeysView class ROMappingItemsView(ROMappingView, typing.ItemsView["_KeyType", Any]): __slots__ = ("_items",) # mapping slot is provided by ItemsView class RowMapping(BaseRow, typing.Mapping["_KeyType", Any]): """A ``Mapping`` that maps column names and objects to :class:`.Row` values. The :class:`.RowMapping` is available from a :class:`.Row` via the :attr:`.Row._mapping` attribute, as well as from the iterable interface provided by the :class:`.MappingResult` object returned by the :meth:`_engine.Result.mappings` method. :class:`.RowMapping` supplies Python mapping (i.e. dictionary) access to the contents of the row. This includes support for testing of containment of specific keys (string column names or objects), as well as iteration of keys, values, and items:: for row in result: if "a" in row._mapping: print("Column 'a': %s" % row._mapping["a"]) print("Column b: %s" % row._mapping[table.c.b]) .. versionadded:: 1.4 The :class:`.RowMapping` object replaces the mapping-like access previously provided by a database result row, which now seeks to behave mostly like a named tuple. """ __slots__ = () if TYPE_CHECKING: def __getitem__(self, key: _KeyType) -> Any: ... else: __getitem__ = BaseRow._get_by_key_impl_mapping def _values_impl(self) -> List[Any]: return list(self._data) def __iter__(self) -> Iterator[str]: return (k for k in self._parent.keys if k is not None) def __len__(self) -> int: return len(self._data) def __contains__(self, key: object) -> bool: return self._parent._has_key(key) def __repr__(self) -> str: return repr(dict(self)) def items(self) -> ROMappingItemsView: """Return a view of key/value tuples for the elements in the underlying :class:`.Row`. """ return ROMappingItemsView( self, [(key, self[key]) for key in self.keys()] ) def keys(self) -> RMKeyView: """Return a view of 'keys' for string column names represented by the underlying :class:`.Row`. """ return self._parent.keys def values(self) -> ROMappingKeysValuesView: """Return a view of values for the values represented in the underlying :class:`.Row`. """ return ROMappingKeysValuesView(self, self._values_impl())
Cancel