Association Proxy

associationproxy is used to create a read/write view of a target attribute across a relationship. It essentially conceals the usage of a “middle” attribute between two endpoints, and can be used to cherry-pick fields from a collection of related objects or to reduce the verbosity of using the association object pattern. Applied creatively, the association proxy allows the construction of sophisticated collections and dictionary views of virtually any geometry, persisted to the database using standard, transparently configured relational patterns.

Simplifying Scalar Collections

Consider a many-to-many mapping between two classes, User and Keyword. Each User can have any number of Keyword objects, and vice-versa (the many-to-many pattern is described at Many To Many). The example below illustrates this pattern in the same way, with the exception of an extra attribute added to the User class called User.keywords:

  1. from __future__ import annotations
  3. from typing import Final
  5. from sqlalchemy import Column
  6. from sqlalchemy import ForeignKey
  7. from sqlalchemy import Integer
  8. from sqlalchemy import String
  9. from sqlalchemy import Table
  10. from sqlalchemy.orm import DeclarativeBase
  11. from sqlalchemy.orm import Mapped
  12. from sqlalchemy.orm import mapped_column
  13. from sqlalchemy.orm import relationship
  14. from sqlalchemy.ext.associationproxy import association_proxy
  15. from sqlalchemy.ext.associationproxy import AssociationProxy
  18. class Base(DeclarativeBase):
  19.     pass
  22. class User(Base):
  23.     __tablename__ = "user"
  24.     id: Mapped[int] = mapped_column(primary_key=True)
  25.     name: Mapped[str] = mapped_column(String(64))
  26.     kw: Mapped[list[Keyword]] = relationship(secondary=lambda: user_keyword_table)
  28.     def __init__(self, name: str):
  29.         self.name = name
  31.     # proxy the 'keyword' attribute from the 'kw' relationship
  32.     keywords: AssociationProxy[list[str]] = association_proxy("kw", "keyword")
  35. class Keyword(Base):
  36.     __tablename__ = "keyword"
  37.     id: Mapped[int] = mapped_column(primary_key=True)
  38.     keyword: Mapped[str] = mapped_column(String(64))
  40.     def __init__(self, keyword: str):
  41.         self.keyword = keyword
  44. user_keyword_table: Final[Table] = Table(
  45.     "user_keyword",
  46.     Base.metadata,
  47.     Column("user_id", Integer, ForeignKey("user.id"), primary_key=True),
  48.     Column("keyword_id", Integer, ForeignKey("keyword.id"), primary_key=True),
  49. )

In the above example, association_proxy() is applied to the User class to produce a “view” of the kw relationship, which exposes the string value of .keyword associated with each Keyword object. It also creates new Keyword objects transparently when strings are added to the collection:

  1. >>> user = User("jek")
  2. >>> user.keywords.append("cheese-inspector")
  3. >>> user.keywords.append("snack-ninja")
  4. >>> print(user.keywords)
  5. ['cheese-inspector', 'snack-ninja']

To understand the mechanics of this, first review the behavior of User and Keyword without using the .keywords association proxy. Normally, reading and manipulating the collection of “keyword” strings associated with User requires traversal from each collection element to the .keyword attribute, which can be awkward. The example below illustrates the identical series of operations applied without using the association proxy:

  1. >>> # identical operations without using the association proxy
  2. >>> user = User("jek")
  3. >>> user.kw.append(Keyword("cheese-inspector"))
  4. >>> user.kw.append(Keyword("snack-ninja"))
  5. >>> print([keyword.keyword for keyword in user.kw])
  6. ['cheese-inspector', 'snack-ninja']

The AssociationProxy object produced by the association_proxy() function is an instance of a Python descriptor, and is not considered to be “mapped” by the Mapper in any way. Therefore, it’s always indicated inline within the class definition of the mapped class, regardless of whether Declarative or Imperative mappings are used.

The proxy functions by operating upon the underlying mapped attribute or collection in response to operations, and changes made via the proxy are immediately apparent in the mapped attribute, as well as vice versa. The underlying attribute remains fully accessible.

When first accessed, the association proxy performs introspection operations on the target collection so that its behavior corresponds correctly. Details such as if the locally proxied attribute is a collection (as is typical) or a scalar reference, as well as if the collection acts like a set, list, or dictionary is taken into account, so that the proxy should act just like the underlying collection or attribute does.

Creation of New Values

When a list append() event (or set add(), dictionary __setitem__(), or scalar assignment event) is intercepted by the association proxy, it instantiates a new instance of the “intermediary” object using its constructor, passing as a single argument the given value. In our example above, an operation like:

  1. user.keywords.append("cheese-inspector")

Is translated by the association proxy into the operation:

  1. user.kw.append(Keyword("cheese-inspector"))

The example works here because we have designed the constructor for Keyword to accept a single positional argument, keyword. For those cases where a single-argument constructor isn’t feasible, the association proxy’s creational behavior can be customized using the association_proxy.creator argument, which references a callable (i.e. Python function) that will produce a new object instance given the singular argument. Below we illustrate this using a lambda as is typical:

  1. class User(Base):
  2.     ...
  4.     # use Keyword(keyword=kw) on append() events
  5.     keywords: AssociationProxy[list[str]] = association_proxy(
  6.         "kw", "keyword", creator=lambda kw: Keyword(keyword=kw)
  7.     )

The creator function accepts a single argument in the case of a list- or set- based collection, or a scalar attribute. In the case of a dictionary-based collection, it accepts two arguments, “key” and “value”. An example of this is below in Proxying to Dictionary Based Collections.

Simplifying Association Objects

The “association object” pattern is an extended form of a many-to-many relationship, and is described at Association Object. Association proxies are useful for keeping “association objects” out of the way during regular use.

Suppose our user_keyword table above had additional columns which we’d like to map explicitly, but in most cases we don’t require direct access to these attributes. Below, we illustrate a new mapping which introduces the UserKeywordAssociation class, which is mapped to the user_keyword table illustrated earlier. This class adds an additional column special_key, a value which we occasionally want to access, but not in the usual case. We create an association proxy on the User class called keywords, which will bridge the gap from the user_keyword_associations collection of User to the .keyword attribute present on each UserKeywordAssociation:

  1. from __future__ import annotations
  3. from typing import Optional
  5. from sqlalchemy import ForeignKey
  6. from sqlalchemy import String
  7. from sqlalchemy.ext.associationproxy import association_proxy
  8. from sqlalchemy.ext.associationproxy import AssociationProxy
  9. from sqlalchemy.orm import DeclarativeBase
  10. from sqlalchemy.orm import Mapped
  11. from sqlalchemy.orm import mapped_column
  12. from sqlalchemy.orm import relationship
  15. class Base(DeclarativeBase):
  16.     pass
  19. class User(Base):
  20.     __tablename__ = "user"
  22.     id: Mapped[int] = mapped_column(primary_key=True)
  23.     name: Mapped[str] = mapped_column(String(64))
  25.     user_keyword_associations: Mapped[list[UserKeywordAssociation]] = relationship(
  26.         back_populates="user",
  27.         cascade="all, delete-orphan",
  28.     )
  30.     # association proxy of "user_keyword_associations" collection
  31.     # to "keyword" attribute
  32.     keywords: AssociationProxy[list[Keyword]] = association_proxy(
  33.         "user_keyword_associations",
  34.         "keyword",
  35.         creator=lambda keyword: UserKeywordAssociation(keyword=Keyword(keyword)),
  36.     )
  38.     def __init__(self, name: str):
  39.         self.name = name
  42. class UserKeywordAssociation(Base):
  43.     __tablename__ = "user_keyword"
  44.     user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
  45.     keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
  46.     special_key: Mapped[Optional[str]] = mapped_column(String(50))
  48.     user: Mapped[User] = relationship(back_populates="user_keyword_associations")
  50.     keyword: Mapped[Keyword] = relationship()
  53. class Keyword(Base):
  54.     __tablename__ = "keyword"
  55.     id: Mapped[int] = mapped_column(primary_key=True)
  56.     keyword: Mapped[str] = mapped_column("keyword", String(64))
  58.     def __init__(self, keyword: str):
  59.         self.keyword = keyword
  61.     def __repr__(self) -> str:
  62.         return f"Keyword({self.keyword!r})"

With the above configuration, we can operate upon the .keywords collection of each User object, each of which exposes a collection of Keyword objects that are obtained from the underlying UserKeywordAssociation elements:

  1. >>> user = User("log")
  2. >>> for kw in (Keyword("new_from_blammo"), Keyword("its_big")):
  3. ...     user.keywords.append(kw)
  4. >>> print(user.keywords)
  5. [Keyword('new_from_blammo'), Keyword('its_big')]

This example is in contrast to the example illustrated previously at Simplifying Scalar Collections, where the association proxy exposed a collection of strings, rather than a collection of composed objects. In this case, each .keywords.append() operation is equivalent to:

  1. >>> user.user_keyword_associations.append(
  2. ...     UserKeywordAssociation(keyword=Keyword("its_heavy"))
  3. ... )

The UserKeywordAssociation object has two attributes that are both populated within the scope of the append() operation of the association proxy; .keyword, which refers to the Keyword object, and .user, which refers to the User object. The .keyword attribute is populated first, as the association proxy generates a new UserKeywordAssociation object in response to the .append() operation, assigning the given Keyword instance to the .keyword attribute. Then, as the UserKeywordAssociation object is appended to the User.user_keyword_associations collection, the UserKeywordAssociation.user attribute, configured as back_populates for User.user_keyword_associations, is initialized upon the given UserKeywordAssociation instance to refer to the parent User receiving the append operation. The special_key argument above is left at its default value of None.

For those cases where we do want special_key to have a value, we create the UserKeywordAssociation object explicitly. Below we assign all three attributes, wherein the assignment of .user during construction, has the effect of appending the new UserKeywordAssociation to the User.user_keyword_associations collection (via the relationship):

  1. >>> UserKeywordAssociation(
  2. ...     keyword=Keyword("its_wood"), user=user, special_key="my special key"
  3. ... )

The association proxy returns to us a collection of Keyword objects represented by all these operations:

  1. >>> print(user.keywords)
  2. [Keyword('new_from_blammo'), Keyword('its_big'), Keyword('its_heavy'), Keyword('its_wood')]

Proxying to Dictionary Based Collections

The association proxy can proxy to dictionary based collections as well. SQLAlchemy mappings usually use the attribute_keyed_dict() collection type to create dictionary collections, as well as the extended techniques described in Custom Dictionary-Based Collections.

The association proxy adjusts its behavior when it detects the usage of a dictionary-based collection. When new values are added to the dictionary, the association proxy instantiates the intermediary object by passing two arguments to the creation function instead of one, the key and the value. As always, this creation function defaults to the constructor of the intermediary class, and can be customized using the creator argument.

Below, we modify our UserKeywordAssociation example such that the User.user_keyword_associations collection will now be mapped using a dictionary, where the UserKeywordAssociation.special_key argument will be used as the key for the dictionary. We also apply a creator argument to the User.keywords proxy so that these values are assigned appropriately when new elements are added to the dictionary:

  1. from __future__ import annotations
  3. from sqlalchemy import ForeignKey
  4. from sqlalchemy import String
  5. from sqlalchemy.ext.associationproxy import association_proxy
  6. from sqlalchemy.ext.associationproxy import AssociationProxy
  7. from sqlalchemy.orm import DeclarativeBase
  8. from sqlalchemy.orm import Mapped
  9. from sqlalchemy.orm import mapped_column
  10. from sqlalchemy.orm import relationship
  11. from sqlalchemy.orm.collections import attribute_keyed_dict
  14. class Base(DeclarativeBase):
  15.     pass
  18. class User(Base):
  19.     __tablename__ = "user"
  20.     id: Mapped[int] = mapped_column(primary_key=True)
  21.     name: Mapped[str] = mapped_column(String(64))
  23.     # user/user_keyword_associations relationship, mapping
  24.     # user_keyword_associations with a dictionary against "special_key" as key.
  25.     user_keyword_associations: Mapped[dict[str, UserKeywordAssociation]] = relationship(
  26.         back_populates="user",
  27.         collection_class=attribute_keyed_dict("special_key"),
  28.         cascade="all, delete-orphan",
  29.     )
  30.     # proxy to 'user_keyword_associations', instantiating
  31.     # UserKeywordAssociation assigning the new key to 'special_key',
  32.     # values to 'keyword'.
  33.     keywords: AssociationProxy[dict[str, Keyword]] = association_proxy(
  34.         "user_keyword_associations",
  35.         "keyword",
  36.         creator=lambda k, v: UserKeywordAssociation(special_key=k, keyword=v),
  37.     )
  39.     def __init__(self, name: str):
  40.         self.name = name
  43. class UserKeywordAssociation(Base):
  44.     __tablename__ = "user_keyword"
  45.     user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
  46.     keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
  47.     special_key: Mapped[str]
  49.     user: Mapped[User] = relationship(
  50.         back_populates="user_keyword_associations",
  51.     )
  52.     keyword: Mapped[Keyword] = relationship()
  55. class Keyword(Base):
  56.     __tablename__ = "keyword"
  57.     id: Mapped[int] = mapped_column(primary_key=True)
  58.     keyword: Mapped[str] = mapped_column(String(64))
  60.     def __init__(self, keyword: str):
  61.         self.keyword = keyword
  63.     def __repr__(self) -> str:
  64.         return f"Keyword({self.keyword!r})"

We illustrate the .keywords collection as a dictionary, mapping the UserKeywordAssociation.special_key value to Keyword objects:

  1. >>> user = User("log")
  3. >>> user.keywords["sk1"] = Keyword("kw1")
  4. >>> user.keywords["sk2"] = Keyword("kw2")
  6. >>> print(user.keywords)
  7. {'sk1': Keyword('kw1'), 'sk2': Keyword('kw2')}

Composite Association Proxies

Given our previous examples of proxying from relationship to scalar attribute, proxying across an association object, and proxying dictionaries, we can combine all three techniques together to give User a keywords dictionary that deals strictly with the string value of special_key mapped to the string keyword. Both the UserKeywordAssociation and Keyword classes are entirely concealed. This is achieved by building an association proxy on User that refers to an association proxy present on UserKeywordAssociation:

  1. from __future__ import annotations
  3. from sqlalchemy import ForeignKey
  4. from sqlalchemy import String
  5. from sqlalchemy.ext.associationproxy import association_proxy
  6. from sqlalchemy.ext.associationproxy import AssociationProxy
  7. from sqlalchemy.orm import DeclarativeBase
  8. from sqlalchemy.orm import Mapped
  9. from sqlalchemy.orm import mapped_column
  10. from sqlalchemy.orm import relationship
  11. from sqlalchemy.orm.collections import attribute_keyed_dict
  14. class Base(DeclarativeBase):
  15.     pass
  18. class User(Base):
  19.     __tablename__ = "user"
  20.     id: Mapped[int] = mapped_column(primary_key=True)
  21.     name: Mapped[str] = mapped_column(String(64))
  23.     user_keyword_associations: Mapped[dict[str, UserKeywordAssociation]] = relationship(
  24.         back_populates="user",
  25.         collection_class=attribute_keyed_dict("special_key"),
  26.         cascade="all, delete-orphan",
  27.     )
  28.     # the same 'user_keyword_associations'->'keyword' proxy as in
  29.     # the basic dictionary example.
  30.     keywords: AssociationProxy[dict[str, str]] = association_proxy(
  31.         "user_keyword_associations",
  32.         "keyword",
  33.         creator=lambda k, v: UserKeywordAssociation(special_key=k, keyword=v),
  34.     )
  36.     def __init__(self, name: str):
  37.         self.name = name
  40. class UserKeywordAssociation(Base):
  41.     __tablename__ = "user_keyword"
  42.     user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
  43.     keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
  44.     special_key: Mapped[str] = mapped_column(String(64))
  45.     user: Mapped[User] = relationship(
  46.         back_populates="user_keyword_associations",
  47.     )
  49.     # the relationship to Keyword is now called
  50.     # 'kw'
  51.     kw: Mapped[Keyword] = relationship()
  53.     # 'keyword' is changed to be a proxy to the
  54.     # 'keyword' attribute of 'Keyword'
  55.     keyword: AssociationProxy[dict[str, str]] = association_proxy("kw", "keyword")
  58. class Keyword(Base):
  59.     __tablename__ = "keyword"
  60.     id: Mapped[int] = mapped_column(primary_key=True)
  61.     keyword: Mapped[str] = mapped_column(String(64))
  63.     def __init__(self, keyword: str):
  64.         self.keyword = keyword

User.keywords is now a dictionary of string to string, where UserKeywordAssociation and Keyword objects are created and removed for us transparently using the association proxy. In the example below, we illustrate usage of the assignment operator, also appropriately handled by the association proxy, to apply a dictionary value to the collection at once:

  1. >>> user = User("log")
  2. >>> user.keywords = {"sk1": "kw1", "sk2": "kw2"}
  3. >>> print(user.keywords)
  4. {'sk1': 'kw1', 'sk2': 'kw2'}
  6. >>> user.keywords["sk3"] = "kw3"
  7. >>> del user.keywords["sk2"]
  8. >>> print(user.keywords)
  9. {'sk1': 'kw1', 'sk3': 'kw3'}
  11. >>> # illustrate un-proxied usage
  12. ... print(user.user_keyword_associations["sk3"].kw)
  13. <__main__.Keyword object at 0x12ceb90>

One caveat with our example above is that because Keyword objects are created for each dictionary set operation, the example fails to maintain uniqueness for the Keyword objects on their string name, which is a typical requirement for a tagging scenario such as this one. For this use case the recipe UniqueObject, or a comparable creational strategy, is recommended, which will apply a “lookup first, then create” strategy to the constructor of the Keyword class, so that an already existing Keyword is returned if the given name is already present.

Querying with Association Proxies

The AssociationProxy features simple SQL construction capabilities which work at the class level in a similar way as other ORM-mapped attributes, and provide rudimentary filtering support primarily based on the SQL EXISTS keyword.

Note

The primary purpose of the association proxy extension is to allow for improved persistence and object-access patterns with mapped object instances that are already loaded. The class-bound querying feature is of limited use and will not replace the need to refer to the underlying attributes when constructing SQL queries with JOINs, eager loading options, etc.

For this section, assume a class with both an association proxy that refers to a column, as well as an association proxy that refers to a related object, as in the example mapping below:

  1. from __future__ import annotations
  2. from sqlalchemy import Column, ForeignKey, Integer, String
  3. from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
  4. from sqlalchemy.orm import DeclarativeBase, relationship
  5. from sqlalchemy.orm.collections import attribute_keyed_dict
  6. from sqlalchemy.orm.collections import Mapped
  9. class Base(DeclarativeBase):
  10.     pass
  13. class User(Base):
  14.     __tablename__ = "user"
  15.     id: Mapped[int] = mapped_column(primary_key=True)
  16.     name: Mapped[str] = mapped_column(String(64))
  18.     user_keyword_associations: Mapped[UserKeywordAssociation] = relationship(
  19.         cascade="all, delete-orphan",
  20.     )
  22.     # object-targeted association proxy
  23.     keywords: AssociationProxy[List[Keyword]] = association_proxy(
  24.         "user_keyword_associations",
  25.         "keyword",
  26.     )
  28.     # column-targeted association proxy
  29.     special_keys: AssociationProxy[list[str]] = association_proxy(
  30.         "user_keyword_associations", "special_key"
  31.     )
  34. class UserKeywordAssociation(Base):
  35.     __tablename__ = "user_keyword"
  36.     user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
  37.     keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
  38.     special_key: Mapped[str] = mapped_column(String(64))
  39.     keyword: Mapped[Keyword] = relationship()
  42. class Keyword(Base):
  43.     __tablename__ = "keyword"
  44.     id: Mapped[int] = mapped_column(primary_key=True)
  45.     keyword: Mapped[str] = mapped_column(String(64))

The SQL generated takes the form of a correlated subquery against the EXISTS SQL operator so that it can be used in a WHERE clause without the need for additional modifications to the enclosing query. If the immediate target of an association proxy is a mapped column expression, standard column operators can be used which will be embedded in the subquery. For example a straight equality operator:

  1. >>> print(session.scalars(select(User).where(User.special_keys == "jek")))
  2. SELECT "user".id AS user_id, "user".name AS user_name
  3. FROM "user"
  4. WHERE EXISTS (SELECT 1
  5. FROM user_keyword
  6. WHERE "user".id = user_keyword.user_id AND user_keyword.special_key = :special_key_1)

a LIKE operator:

  1. >>> print(session.scalars(select(User).where(User.special_keys.like("%jek"))))
  2. SELECT "user".id AS user_id, "user".name AS user_name
  3. FROM "user"
  4. WHERE EXISTS (SELECT 1
  5. FROM user_keyword
  6. WHERE "user".id = user_keyword.user_id AND user_keyword.special_key LIKE :special_key_1)

For association proxies where the immediate target is a related object or collection, or another association proxy or attribute on the related object, relationship-oriented operators can be used instead, such as PropComparator.has() and PropComparator.any(). The User.keywords attribute is in fact two association proxies linked together, so when using this proxy for generating SQL phrases, we get two levels of EXISTS subqueries:

  1. >>> print(session.scalars(select(User).where(User.keywords.any(Keyword.keyword == "jek"))))
  2. SELECT "user".id AS user_id, "user".name AS user_name
  3. FROM "user"
  4. WHERE EXISTS (SELECT 1
  5. FROM user_keyword
  6. WHERE "user".id = user_keyword.user_id AND (EXISTS (SELECT 1
  7. FROM keyword
  8. WHERE keyword.id = user_keyword.keyword_id AND keyword.keyword = :keyword_1)))

This is not the most efficient form of SQL, so while association proxies can be convenient for generating WHERE criteria quickly, SQL results should be inspected and “unrolled” into explicit JOIN criteria for best use, especially when chaining association proxies together.

Changed in version 1.3: Association proxy features distinct querying modes based on the type of target. See AssociationProxy now provides standard column operators for a column-oriented target.

Cascading Scalar Deletes

New in version 1.3.

Given a mapping as:

  1. from __future__ import annotations
  2. from sqlalchemy import Column, ForeignKey, Integer, String
  3. from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
  4. from sqlalchemy.orm import DeclarativeBase, relationship
  5. from sqlalchemy.orm.collections import attribute_keyed_dict
  6. from sqlalchemy.orm.collections import Mapped
  9. class Base(DeclarativeBase):
  10.     pass
  13. class A(Base):
  14.     __tablename__ = "test_a"
  15.     id: Mapped[int] = mapped_column(primary_key=True)
  16.     ab: Mapped[AB] = relationship(uselist=False)
  17.     b: AssociationProxy[B] = association_proxy(
  18.         "ab", "b", creator=lambda b: AB(b=b), cascade_scalar_deletes=True
  19.     )
  22. class B(Base):
  23.     __tablename__ = "test_b"
  24.     id: Mapped[int] = mapped_column(primary_key=True)
  27. class AB(Base):
  28.     __tablename__ = "test_ab"
  29.     a_id: Mapped[int] = mapped_column(ForeignKey(A.id), primary_key=True)
  30.     b_id: Mapped[int] = mapped_column(ForeignKey(B.id), primary_key=True)
  32.     b: Mapped[B] = relationship()

An assignment to A.b will generate an AB object:

  1. a.b = B()

The A.b association is scalar, and includes use of the parameter AssociationProxy.cascade_scalar_deletes. When this parameter is enabled, setting A.b to None will remove A.ab as well:

  1. a.b = None
  2. assert a.ab is None

When AssociationProxy.cascade_scalar_deletes is not set, the association object a.ab above would remain in place.

Note that this is not the behavior for collection-based association proxies; in that case, the intermediary association object is always removed when members of the proxied collection are removed. Whether or not the row is deleted depends on the relationship cascade setting.

See also

Cascades

API Documentation

Object NameDescription

association_proxy(target_collection, attr, *, [creator, getset_factory, proxy_factory, proxy_bulk_set, info, cascade_scalar_deletes, init, repr, default, default_factory, compare, kw_only])

Return a Python property implementing a view of a target attribute which references an attribute on members of the target.

AssociationProxy

A descriptor that presents a read/write view of an object attribute.

AssociationProxyExtensionType

An enumeration.

AssociationProxyInstance

A per-class object that serves class- and object-specific results.

ColumnAssociationProxyInstance

an AssociationProxyInstance that has a database column as a target.

ObjectAssociationProxyInstance

an AssociationProxyInstance that has an object as a target.

function sqlalchemy.ext.associationproxy.association_proxy(target_collection: str, attr: str, *, creator: Optional[_CreatorProtocol] = None, getset_factory: Optional[_GetSetFactoryProtocol] = None, proxy_factory: Optional[_ProxyFactoryProtocol] = None, proxy_bulk_set: Optional[_ProxyBulkSetProtocol] = None, info: Optional[_InfoType] = None, cascade_scalar_deletes: bool = False, init: Union[_NoArg, bool] = _NoArg.NO_ARG, repr: Union[_NoArg, bool] = _NoArg.NO_ARG, default: Optional[Any] = _NoArg.NO_ARG, default_factory: Union[_NoArg, Callable[[], _T]] = _NoArg.NO_ARG, compare: Union[_NoArg, bool] = _NoArg.NO_ARG, kw_only: Union[_NoArg, bool] = _NoArg.NO_ARG) → AssociationProxy[Any]

Return a Python property implementing a view of a target attribute which references an attribute on members of the target.

The returned value is an instance of AssociationProxy.

Implements a Python property representing a relationship as a collection of simpler values, or a scalar value. The proxied property will mimic the collection type of the target (list, dict or set), or, in the case of a one to one relationship, a simple scalar value.

  • Parameters:

    • target_collection – Name of the attribute that is the immediate target. This attribute is typically mapped by relationship() to link to a target collection, but can also be a many-to-one or non-scalar relationship.

    • attr – Attribute on the associated instance or instances that are available on instances of the target object.

    • creator –

      optional.

      Defines custom behavior when new items are added to the proxied collection.

      By default, adding new items to the collection will trigger a construction of an instance of the target object, passing the given item as a positional argument to the target constructor. For cases where this isn’t sufficient, association_proxy.creator can supply a callable that will construct the object in the appropriate way, given the item that was passed.

      For list- and set- oriented collections, a single argument is passed to the callable. For dictionary oriented collections, two arguments are passed, corresponding to the key and value.

      The association_proxy.creator callable is also invoked for scalar (i.e. many-to-one, one-to-one) relationships. If the current value of the target relationship attribute is None, the callable is used to construct a new object. If an object value already exists, the given attribute value is populated onto that object.

      See also

      Creation of New Values

    • cascade_scalar_deletes –

      when True, indicates that setting the proxied value to None, or deleting it via del, should also remove the source object. Only applies to scalar attributes. Normally, removing the proxied target will not remove the proxy source, as this object may have other state that is still to be kept.

      New in version 1.3.

      See also

      Cascading Scalar Deletes - complete usage example

    • init –

      Specific to Declarative Dataclass Mapping, specifies if the mapped attribute should be part of the __init__() method as generated by the dataclass process.

      New in version 2.0.0b4.

    • repr –

      Specific to Declarative Dataclass Mapping, specifies if the attribute established by this AssociationProxy should be part of the __repr__() method as generated by the dataclass process.

      New in version 2.0.0b4.

    • default_factory –

      Specific to Declarative Dataclass Mapping, specifies a default-value generation function that will take place as part of the __init__() method as generated by the dataclass process.

      New in version 2.0.0b4.

    • compare –

      Specific to Declarative Dataclass Mapping, indicates if this field should be included in comparison operations when generating the __eq__() and __ne__() methods for the mapped class.

      New in version 2.0.0b4.

    • kw_only –

      Specific to Declarative Dataclass Mapping, indicates if this field should be marked as keyword-only when generating the __init__() method as generated by the dataclass process.

      New in version 2.0.0b4.

    • info – optional, will be assigned to AssociationProxy.info if present.

The following additional parameters involve injection of custom behaviors within the AssociationProxy object and are for advanced use only:

  • Parameters:

    • getset_factory –

      Optional. Proxied attribute access is automatically handled by routines that get and set values based on the attr argument for this proxy.

      If you would like to customize this behavior, you may supply a getset_factory callable that produces a tuple of getter and setter functions. The factory is called with two arguments, the abstract type of the underlying collection and this proxy instance.

    • proxy_factory – Optional. The type of collection to emulate is determined by sniffing the target collection. If your collection type can’t be determined by duck typing or you’d like to use a different collection implementation, you may supply a factory function to produce those collections. Only applicable to non-scalar relationships.

    • proxy_bulk_set – Optional, use with proxy_factory.

class sqlalchemy.ext.associationproxy.AssociationProxy

A descriptor that presents a read/write view of an object attribute.

Members

__init__(), creator, extension_type, for_class(), getset_factory, info, is_aliased_class, is_attribute, is_bundle, is_clause_element, is_instance, is_mapper, is_property, is_selectable, key, proxy_bulk_set, proxy_factory, target_collection, value_attr

Class signature

class sqlalchemy.ext.associationproxy.AssociationProxy (sqlalchemy.orm.base.InspectionAttrInfo, sqlalchemy.orm.base.ORMDescriptor, sqlalchemy.orm._DCAttributeOptions, sqlalchemy.ext.associationproxy._AssociationProxyProtocol)

  1. New in version 1.3: - [AssociationProxy](#sqlalchemy.ext.associationproxy.AssociationProxy "sqlalchemy.ext.associationproxy.AssociationProxy") no longer stores any state specific to a particular parent class; the state is now stored in per-class [AssociationProxyInstance](#sqlalchemy.ext.associationproxy.AssociationProxyInstance "sqlalchemy.ext.associationproxy.AssociationProxyInstance") objects.

class sqlalchemy.ext.associationproxy.AssociationProxyInstance

A per-class object that serves class- and object-specific results.

This is used by AssociationProxy when it is invoked in terms of a specific class or instance of a class, i.e. when it is used as a regular Python descriptor.

When referring to the AssociationProxy as a normal Python descriptor, the AssociationProxyInstance is the object that actually serves the information. Under normal circumstances, its presence is transparent:

  1. >>> User.keywords.scalar
  2. False

In the special case that the AssociationProxy object is being accessed directly, in order to get an explicit handle to the AssociationProxyInstance, use the AssociationProxy.for_class() method:

  1. proxy_state = inspect(User).all_orm_descriptors["keywords"].for_class(User)
  3. # view if proxy object is scalar or not
  4. >>> proxy_state.scalar
  5. False

New in version 1.3.

Members

__eq__(), __le__(), __lt__(), __ne__(), all_(), any(), any_(), asc(), attr, between(), bool_op(), collate(), collection_class, concat(), contains(), delete(), desc(), distinct(), endswith(), for_proxy(), get(), has(), icontains(), iendswith(), ilike(), in_(), info, is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), parent, regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, set(), startswith(), target_class, timetuple

Class signature

class sqlalchemy.ext.associationproxy.AssociationProxyInstance (sqlalchemy.orm.base.SQLORMOperations)

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  5. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.delete(obj: Any) → None

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.desc() → ColumnOperators

    inherited from the ColumnOperators.desc() method of ColumnOperators

    Produce a desc() clause against the parent object.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.distinct() → ColumnOperators

    inherited from the ColumnOperators.distinct() method of ColumnOperators

    Produce a distinct() clause against the parent object.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.endswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.endswith() method of ColumnOperators

    Implement the ‘endswith’ operator.

    Produces a LIKE expression that tests against a match for the end of a string value:

    1. column LIKE '%' || <other>

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.endswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.endswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.endswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.endswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.endswith("foo%bar", autoescape=True)

        Will render as:

        1. somecolumn LIKE '%' || :param ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.endswith("foo/%bar", escape="^")

        Will render as:

        1. somecolumn LIKE '%' || :param ESCAPE '^'

        The parameter may also be combined with ColumnOperators.endswith.autoescape:

        1. somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • classmethod sqlalchemy.ext.associationproxy.AssociationProxyInstance.for_proxy(parent: AssociationProxy[_T], owning_class: Type[Any], parent_instance: Any) → AssociationProxyInstance[_T]

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.get(obj: Any) → Union[_T, None, AssociationProxyInstance[_T]]

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.has(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]

    Produce a proxied ‘has’ expression using EXISTS.

    This expression will be a composed product using the Comparator.any() and/or Comparator.has() operators of the underlying proxied attributes.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

    inherited from the ColumnOperators.icontains() method of ColumnOperators

    Implement the icontains operator, e.g. case insensitive version of ColumnOperators.contains().

    Produces a LIKE expression that tests against an insensitive match for the middle of a string value:

    1. lower(column) LIKE '%' || lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.icontains("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.icontains.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.icontains.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.icontains.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.icontains("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.icontains("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.contains.autoescape:

        1. somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.iendswith() method of ColumnOperators

    Implement the iendswith operator, e.g. case insensitive version of ColumnOperators.endswith().

    Produces a LIKE expression that tests against an insensitive match for the end of a string value:

    1. lower(column) LIKE '%' || lower(<other>)

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.iendswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.iendswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.iendswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.iendswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.iendswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.iendswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'

        The parameter may also be combined with ColumnOperators.iendswith.autoescape:

        1. somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.ilike() method of ColumnOperators

    Implement the ilike operator, e.g. case insensitive LIKE.

    In a column context, produces an expression either of the form:

    1. lower(a) LIKE lower(other)

    Or on backends that support the ILIKE operator:

    1. a ILIKE other

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.ilike("%foobar%"))

    • Parameters:

      • other – expression to be compared

      • escape –

        optional escape character, renders the ESCAPE keyword, e.g.:

        1. somecolumn.ilike("foo/%bar", escape="/")
  1. See also
  3. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.in_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.in_() method of ColumnOperators

    Implement the in operator.

    In a column context, produces the clause column IN <other>.

    The given parameter other may be:

    • A list of literal values, e.g.:

      1. stmt.where(column.in_([1, 2, 3]))

      In this calling form, the list of items is converted to a set of bound parameters the same length as the list given:

      1. WHERE COL IN (?, ?, ?)

    • A list of tuples may be provided if the comparison is against a tuple_() containing multiple expressions:

      1. from sqlalchemy import tuple_
      2. stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

    • An empty list, e.g.:

      1. stmt.where(column.in_([]))

      In this calling form, the expression renders an “empty set” expression. These expressions are tailored to individual backends and are generally trying to get an empty SELECT statement as a subquery. Such as on SQLite, the expression is:

      1. WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      Changed in version 1.4: empty IN expressions now use an execution-time generated SELECT subquery in all cases.

    • A bound parameter, e.g. bindparam(), may be used if it includes the bindparam.expanding flag:

      1. stmt.where(column.in_(bindparam('value', expanding=True)))

      In this calling form, the expression renders a special non-SQL placeholder expression that looks like:

      1. WHERE COL IN ([EXPANDING_value])

      This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:

      1. connection.execute(stmt, {"value": [1, 2, 3]})

      The database would be passed a bound parameter for each value:

      1. WHERE COL IN (?, ?, ?)

      New in version 1.2: added “expanding” bound parameters

      If an empty list is passed, a special “empty list” expression, which is specific to the database in use, is rendered. On SQLite this would be:

      1. WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      New in version 1.3: “expanding” bound parameters now support empty lists

    • a select() construct, which is usually a correlated scalar select:

      1. stmt.where(
      2.     column.in_(
      3.         select(othertable.c.y).
      4.         where(table.c.x == othertable.c.x)
      5.     )
      6. )

      In this calling form, ColumnOperators.in_() renders as given:

      1. WHERE COL IN (SELECT othertable.y
      2. FROM othertable WHERE othertable.x = table.x)

    • Parameters:

      other – a list of literals, a select() construct, or a bindparam() construct that includes the bindparam.expanding flag set to True.

  • attribute sqlalchemy.ext.associationproxy.AssociationProxyInstance.info

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_() method of ColumnOperators

    Implement the IS operator.

    Normally, IS is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS may be desirable if comparing to boolean values on certain platforms.

    See also

    ColumnOperators.is_not()

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

    Implement the IS DISTINCT FROM operator.

    Renders “a IS DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS NOT b”.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_not(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.isnot(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.istartswith() method of ColumnOperators

    Implement the istartswith operator, e.g. case insensitive version of ColumnOperators.startswith().

    Produces a LIKE expression that tests against an insensitive match for the start of a string value:

    1. lower(column) LIKE lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.istartswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.istartswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.istartswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.istartswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.istartswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.istartswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.istartswith.autoescape:

        1. somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  1. See also
  3. [ColumnOperators.ilike()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.ilike "sqlalchemy.sql.expression.ColumnOperators.ilike")
  1. See also
  3. [Operators.bool\_op()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.Operators.bool_op "sqlalchemy.sql.expression.Operators.bool_op")
  5. [Redefining and Creating New Operators]($e8ad009010586d59.md#types-operators)
  7. [Using custom operators in join conditions]($b68ea79e4b407a37.md#relationship-custom-operator)

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators

    inherited from the Operators.operate() method of Operators

    Operate on an argument.

    This is the lowest level of operation, raises NotImplementedError by default.

    Overriding this on a subclass can allow common behavior to be applied to all operations. For example, overriding ColumnOperators to apply func.lower() to the left and right side:

    1. class MyComparator(ColumnOperators):
    2.     def operate(self, op, other, **kwargs):
    3.         return op(func.lower(self), func.lower(other), **kwargs)

    • Parameters:

      • op – Operator callable.

      • *other – the ‘other’ side of the operation. Will be a single scalar for most operations.

      • **kwargs – modifiers. These may be passed by special operators such as ColumnOperators.contains().

  • attribute sqlalchemy.ext.associationproxy.AssociationProxyInstance.parent: _AssociationProxyProtocol[_T]

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_match() method of ColumnOperators

    Implements a database-specific ‘regexp match’ operator.

    E.g.:

    1. stmt = select(table.c.some_column).where(
    2.     table.c.some_column.regexp_match('^(b|c)')
    3. )

    ColumnOperators.regexp_match() attempts to resolve to a REGEXP-like function or operator provided by the backend, however the specific regular expression syntax and flags available are not backend agnostic.

    Examples include:

    • PostgreSQL - renders x ~ y or x !~ y when negated.

    • Oracle - renders REGEXP_LIKE(x, y)

    • SQLite - uses SQLite’s REGEXP placeholder operator and calls into the Python re.match() builtin.

    • other backends may provide special implementations.

    • Backends without any special implementation will emit the operator as “REGEXP” or “NOT REGEXP”. This is compatible with SQLite and MySQL, for example.

    Regular expression support is currently implemented for Oracle, PostgreSQL, MySQL and MariaDB. Partial support is available for SQLite. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern. When using the ignore case flag ‘i’ in PostgreSQL, the ignore case regexp match operator ~* or !~* will be used.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_replace()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_replace "sqlalchemy.sql.expression.ColumnOperators.regexp_replace")

  • method sqlalchemy.ext.associationproxy.AssociationProxyInstance.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

    Implements a database-specific ‘regexp replace’ operator.

    E.g.:

    1. stmt = select(
    2.     table.c.some_column.regexp_replace(
    3.         'b(..)',
    4.         'XY',
    5.         flags='g'
    6.     )
    7. )

    ColumnOperators.regexp_replace() attempts to resolve to a REGEXP_REPLACE-like function provided by the backend, that usually emit the function REGEXP_REPLACE(). However, the specific regular expression syntax and flags available are not backend agnostic.

    Regular expression replacement support is currently implemented for Oracle, PostgreSQL, MySQL 8 or greater and MariaDB. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • pattern – The replacement string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_match()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_match "sqlalchemy.sql.expression.ColumnOperators.regexp_match")
  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

class sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance

an AssociationProxyInstance that has an object as a target.

Members

__le__(), __lt__(), all_(), any(), any_(), asc(), attr, between(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), has(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, startswith(), target_class, timetuple

Class signature

class sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance (sqlalchemy.ext.associationproxy.AssociationProxyInstance)

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.has(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]

    inherited from the AssociationProxyInstance.has() method of AssociationProxyInstance

    Produce a proxied ‘has’ expression using EXISTS.

    This expression will be a composed product using the Comparator.any() and/or Comparator.has() operators of the underlying proxied attributes.

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

    inherited from the ColumnOperators.icontains() method of ColumnOperators

    Implement the icontains operator, e.g. case insensitive version of ColumnOperators.contains().

    Produces a LIKE expression that tests against an insensitive match for the middle of a string value:

    1. lower(column) LIKE '%' || lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.icontains("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.icontains.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.icontains.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.icontains.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.icontains("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.icontains("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.contains.autoescape:

        1. somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.iendswith() method of ColumnOperators

    Implement the iendswith operator, e.g. case insensitive version of ColumnOperators.endswith().

    Produces a LIKE expression that tests against an insensitive match for the end of a string value:

    1. lower(column) LIKE '%' || lower(<other>)

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.iendswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.iendswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.iendswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.iendswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.iendswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.iendswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'

        The parameter may also be combined with ColumnOperators.iendswith.autoescape:

        1. somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.ilike() method of ColumnOperators

    Implement the ilike operator, e.g. case insensitive LIKE.

    In a column context, produces an expression either of the form:

    1. lower(a) LIKE lower(other)

    Or on backends that support the ILIKE operator:

    1. a ILIKE other

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.ilike("%foobar%"))

    • Parameters:

      • other – expression to be compared

      • escape –

        optional escape character, renders the ESCAPE keyword, e.g.:

        1. somecolumn.ilike("foo/%bar", escape="/")
  1. See also
  3. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.in_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.in_() method of ColumnOperators

    Implement the in operator.

    In a column context, produces the clause column IN <other>.

    The given parameter other may be:

    • A list of literal values, e.g.:

      1. stmt.where(column.in_([1, 2, 3]))

      In this calling form, the list of items is converted to a set of bound parameters the same length as the list given:

      1. WHERE COL IN (?, ?, ?)

    • A list of tuples may be provided if the comparison is against a tuple_() containing multiple expressions:

      1. from sqlalchemy import tuple_
      2. stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

    • An empty list, e.g.:

      1. stmt.where(column.in_([]))

      In this calling form, the expression renders an “empty set” expression. These expressions are tailored to individual backends and are generally trying to get an empty SELECT statement as a subquery. Such as on SQLite, the expression is:

      1. WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      Changed in version 1.4: empty IN expressions now use an execution-time generated SELECT subquery in all cases.

    • A bound parameter, e.g. bindparam(), may be used if it includes the bindparam.expanding flag:

      1. stmt.where(column.in_(bindparam('value', expanding=True)))

      In this calling form, the expression renders a special non-SQL placeholder expression that looks like:

      1. WHERE COL IN ([EXPANDING_value])

      This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:

      1. connection.execute(stmt, {"value": [1, 2, 3]})

      The database would be passed a bound parameter for each value:

      1. WHERE COL IN (?, ?, ?)

      New in version 1.2: added “expanding” bound parameters

      If an empty list is passed, a special “empty list” expression, which is specific to the database in use, is rendered. On SQLite this would be:

      1. WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      New in version 1.3: “expanding” bound parameters now support empty lists

    • a select() construct, which is usually a correlated scalar select:

      1. stmt.where(
      2.     column.in_(
      3.         select(othertable.c.y).
      4.         where(table.c.x == othertable.c.x)
      5.     )
      6. )

      In this calling form, ColumnOperators.in_() renders as given:

      1. WHERE COL IN (SELECT othertable.y
      2. FROM othertable WHERE othertable.x = table.x)

    • Parameters:

      other – a list of literals, a select() construct, or a bindparam() construct that includes the bindparam.expanding flag set to True.

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.is_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_() method of ColumnOperators

    Implement the IS operator.

    Normally, IS is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS may be desirable if comparing to boolean values on certain platforms.

    See also

    ColumnOperators.is_not()

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

    Implement the IS DISTINCT FROM operator.

    Renders “a IS DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS NOT b”.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.is_not(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.isnot(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.istartswith() method of ColumnOperators

    Implement the istartswith operator, e.g. case insensitive version of ColumnOperators.startswith().

    Produces a LIKE expression that tests against an insensitive match for the start of a string value:

    1. lower(column) LIKE lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.istartswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.istartswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.istartswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.istartswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.istartswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.istartswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.istartswith.autoescape:

        1. somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  1. See also
  3. [ColumnOperators.ilike()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.ilike "sqlalchemy.sql.expression.ColumnOperators.ilike")
  1. See also
  3. [Operators.bool\_op()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.Operators.bool_op "sqlalchemy.sql.expression.Operators.bool_op")
  5. [Redefining and Creating New Operators]($e8ad009010586d59.md#types-operators)
  7. [Using custom operators in join conditions]($b68ea79e4b407a37.md#relationship-custom-operator)

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators

    inherited from the Operators.operate() method of Operators

    Operate on an argument.

    This is the lowest level of operation, raises NotImplementedError by default.

    Overriding this on a subclass can allow common behavior to be applied to all operations. For example, overriding ColumnOperators to apply func.lower() to the left and right side:

    1. class MyComparator(ColumnOperators):
    2.     def operate(self, op, other, **kwargs):
    3.         return op(func.lower(self), func.lower(other), **kwargs)

    • Parameters:

      • op – Operator callable.

      • *other – the ‘other’ side of the operation. Will be a single scalar for most operations.

      • **kwargs – modifiers. These may be passed by special operators such as ColumnOperators.contains().

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_match() method of ColumnOperators

    Implements a database-specific ‘regexp match’ operator.

    E.g.:

    1. stmt = select(table.c.some_column).where(
    2.     table.c.some_column.regexp_match('^(b|c)')
    3. )

    ColumnOperators.regexp_match() attempts to resolve to a REGEXP-like function or operator provided by the backend, however the specific regular expression syntax and flags available are not backend agnostic.

    Examples include:

    • PostgreSQL - renders x ~ y or x !~ y when negated.

    • Oracle - renders REGEXP_LIKE(x, y)

    • SQLite - uses SQLite’s REGEXP placeholder operator and calls into the Python re.match() builtin.

    • other backends may provide special implementations.

    • Backends without any special implementation will emit the operator as “REGEXP” or “NOT REGEXP”. This is compatible with SQLite and MySQL, for example.

    Regular expression support is currently implemented for Oracle, PostgreSQL, MySQL and MariaDB. Partial support is available for SQLite. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern. When using the ignore case flag ‘i’ in PostgreSQL, the ignore case regexp match operator ~* or !~* will be used.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_replace()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_replace "sqlalchemy.sql.expression.ColumnOperators.regexp_replace")

  • method sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

    Implements a database-specific ‘regexp replace’ operator.

    E.g.:

    1. stmt = select(
    2.     table.c.some_column.regexp_replace(
    3.         'b(..)',
    4.         'XY',
    5.         flags='g'
    6.     )
    7. )

    ColumnOperators.regexp_replace() attempts to resolve to a REGEXP_REPLACE-like function provided by the backend, that usually emit the function REGEXP_REPLACE(). However, the specific regular expression syntax and flags available are not backend agnostic.

    Regular expression replacement support is currently implemented for Oracle, PostgreSQL, MySQL 8 or greater and MariaDB. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • pattern – The replacement string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_match()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_match "sqlalchemy.sql.expression.ColumnOperators.regexp_match")
  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

class sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance

an AssociationProxyInstance that has a database column as a target.

Members

__le__(), __lt__(), __ne__(), all_(), any(), any_(), asc(), attr, between(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), has(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, startswith(), target_class, timetuple

Class signature

class sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance (sqlalchemy.ext.associationproxy.AssociationProxyInstance)

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  5. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.desc() → ColumnOperators

    inherited from the ColumnOperators.desc() method of ColumnOperators

    Produce a desc() clause against the parent object.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.distinct() → ColumnOperators

    inherited from the ColumnOperators.distinct() method of ColumnOperators

    Produce a distinct() clause against the parent object.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.endswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.endswith() method of ColumnOperators

    Implement the ‘endswith’ operator.

    Produces a LIKE expression that tests against a match for the end of a string value:

    1. column LIKE '%' || <other>

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.endswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.endswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.endswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.endswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.endswith("foo%bar", autoescape=True)

        Will render as:

        1. somecolumn LIKE '%' || :param ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.endswith("foo/%bar", escape="^")

        Will render as:

        1. somecolumn LIKE '%' || :param ESCAPE '^'

        The parameter may also be combined with ColumnOperators.endswith.autoescape:

        1. somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.has(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]

    inherited from the AssociationProxyInstance.has() method of AssociationProxyInstance

    Produce a proxied ‘has’ expression using EXISTS.

    This expression will be a composed product using the Comparator.any() and/or Comparator.has() operators of the underlying proxied attributes.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

    inherited from the ColumnOperators.icontains() method of ColumnOperators

    Implement the icontains operator, e.g. case insensitive version of ColumnOperators.contains().

    Produces a LIKE expression that tests against an insensitive match for the middle of a string value:

    1. lower(column) LIKE '%' || lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.icontains("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.icontains.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.icontains.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.icontains.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.icontains("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.icontains("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.contains.autoescape:

        1. somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.iendswith() method of ColumnOperators

    Implement the iendswith operator, e.g. case insensitive version of ColumnOperators.endswith().

    Produces a LIKE expression that tests against an insensitive match for the end of a string value:

    1. lower(column) LIKE '%' || lower(<other>)

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.iendswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.iendswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.iendswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.iendswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.iendswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.iendswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'

        The parameter may also be combined with ColumnOperators.iendswith.autoescape:

        1. somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.ilike() method of ColumnOperators

    Implement the ilike operator, e.g. case insensitive LIKE.

    In a column context, produces an expression either of the form:

    1. lower(a) LIKE lower(other)

    Or on backends that support the ILIKE operator:

    1. a ILIKE other

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.ilike("%foobar%"))

    • Parameters:

      • other – expression to be compared

      • escape –

        optional escape character, renders the ESCAPE keyword, e.g.:

        1. somecolumn.ilike("foo/%bar", escape="/")
  1. See also
  3. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.in_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.in_() method of ColumnOperators

    Implement the in operator.

    In a column context, produces the clause column IN <other>.

    The given parameter other may be:

    • A list of literal values, e.g.:

      1. stmt.where(column.in_([1, 2, 3]))

      In this calling form, the list of items is converted to a set of bound parameters the same length as the list given:

      1. WHERE COL IN (?, ?, ?)

    • A list of tuples may be provided if the comparison is against a tuple_() containing multiple expressions:

      1. from sqlalchemy import tuple_
      2. stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))

    • An empty list, e.g.:

      1. stmt.where(column.in_([]))

      In this calling form, the expression renders an “empty set” expression. These expressions are tailored to individual backends and are generally trying to get an empty SELECT statement as a subquery. Such as on SQLite, the expression is:

      1. WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      Changed in version 1.4: empty IN expressions now use an execution-time generated SELECT subquery in all cases.

    • A bound parameter, e.g. bindparam(), may be used if it includes the bindparam.expanding flag:

      1. stmt.where(column.in_(bindparam('value', expanding=True)))

      In this calling form, the expression renders a special non-SQL placeholder expression that looks like:

      1. WHERE COL IN ([EXPANDING_value])

      This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:

      1. connection.execute(stmt, {"value": [1, 2, 3]})

      The database would be passed a bound parameter for each value:

      1. WHERE COL IN (?, ?, ?)

      New in version 1.2: added “expanding” bound parameters

      If an empty list is passed, a special “empty list” expression, which is specific to the database in use, is rendered. On SQLite this would be:

      1. WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

      New in version 1.3: “expanding” bound parameters now support empty lists

    • a select() construct, which is usually a correlated scalar select:

      1. stmt.where(
      2.     column.in_(
      3.         select(othertable.c.y).
      4.         where(table.c.x == othertable.c.x)
      5.     )
      6. )

      In this calling form, ColumnOperators.in_() renders as given:

      1. WHERE COL IN (SELECT othertable.y
      2. FROM othertable WHERE othertable.x = table.x)

    • Parameters:

      other – a list of literals, a select() construct, or a bindparam() construct that includes the bindparam.expanding flag set to True.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_() method of ColumnOperators

    Implement the IS operator.

    Normally, IS is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS may be desirable if comparing to boolean values on certain platforms.

    See also

    ColumnOperators.is_not()

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_distinct_from() method of ColumnOperators

    Implement the IS DISTINCT FROM operator.

    Renders “a IS DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS NOT b”.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_not(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.is_not_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.isnot(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot() method of ColumnOperators

    Implement the IS NOT operator.

    Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. However, explicit usage of IS NOT may be desirable if comparing to boolean values on certain platforms.

    Changed in version 1.4: The is_not() operator is renamed from isnot() in previous releases. The previous name remains available for backwards compatibility.

    See also

    ColumnOperators.is_()

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

    inherited from the ColumnOperators.isnot_distinct_from() method of ColumnOperators

    Implement the IS NOT DISTINCT FROM operator.

    Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.

    Changed in version 1.4: The is_not_distinct_from() operator is renamed from isnot_distinct_from() in previous releases. The previous name remains available for backwards compatibility.

    New in version 1.1.

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators

    inherited from the ColumnOperators.istartswith() method of ColumnOperators

    Implement the istartswith operator, e.g. case insensitive version of ColumnOperators.startswith().

    Produces a LIKE expression that tests against an insensitive match for the start of a string value:

    1. lower(column) LIKE lower(<other>) || '%'

    E.g.:

    1. stmt = select(sometable).\
    2.     where(sometable.c.column.istartswith("foobar"))

    Since the operator uses LIKE, wildcard characters "%" and "_" that are present inside the <other> expression will behave like wildcards as well. For literal string values, the ColumnOperators.istartswith.autoescape flag may be set to True to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the ColumnOperators.istartswith.escape parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.

    • Parameters:

      • other – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters % and _ are not escaped by default unless the ColumnOperators.istartswith.autoescape flag is set to True.

      • autoescape –

        boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of "%", "_" and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.

        An expression such as:

        1. somecolumn.istartswith("foo%bar", autoescape=True)

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'

        With the value of :param as "foo/%bar".

      • escape –

        a character which when given will render with the ESCAPE keyword to establish that character as the escape character. This character can then be placed preceding occurrences of % and _ to allow them to act as themselves and not wildcard characters.

        An expression such as:

        1. somecolumn.istartswith("foo/%bar", escape="^")

        Will render as:

        1. lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'

        The parameter may also be combined with ColumnOperators.istartswith.autoescape:

        1. somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)

        Where above, the given literal parameter will be converted to "foo^%bar^^bat" before being passed to the database.

  1. See also
  3. [ColumnOperators.startswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.startswith "sqlalchemy.sql.expression.ColumnOperators.startswith")
  1. See also
  3. [ColumnOperators.ilike()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.ilike "sqlalchemy.sql.expression.ColumnOperators.ilike")
  1. See also
  3. [Operators.bool\_op()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.Operators.bool_op "sqlalchemy.sql.expression.Operators.bool_op")
  5. [Redefining and Creating New Operators]($e8ad009010586d59.md#types-operators)
  7. [Using custom operators in join conditions]($b68ea79e4b407a37.md#relationship-custom-operator)

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]

    Operate on an argument.

    This is the lowest level of operation, raises NotImplementedError by default.

    Overriding this on a subclass can allow common behavior to be applied to all operations. For example, overriding ColumnOperators to apply func.lower() to the left and right side:

    1. class MyComparator(ColumnOperators):
    2.     def operate(self, op, other, **kwargs):
    3.         return op(func.lower(self), func.lower(other), **kwargs)

    • Parameters:

      • op – Operator callable.

      • *other – the ‘other’ side of the operation. Will be a single scalar for most operations.

      • **kwargs – modifiers. These may be passed by special operators such as ColumnOperators.contains().

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_match() method of ColumnOperators

    Implements a database-specific ‘regexp match’ operator.

    E.g.:

    1. stmt = select(table.c.some_column).where(
    2.     table.c.some_column.regexp_match('^(b|c)')
    3. )

    ColumnOperators.regexp_match() attempts to resolve to a REGEXP-like function or operator provided by the backend, however the specific regular expression syntax and flags available are not backend agnostic.

    Examples include:

    • PostgreSQL - renders x ~ y or x !~ y when negated.

    • Oracle - renders REGEXP_LIKE(x, y)

    • SQLite - uses SQLite’s REGEXP placeholder operator and calls into the Python re.match() builtin.

    • other backends may provide special implementations.

    • Backends without any special implementation will emit the operator as “REGEXP” or “NOT REGEXP”. This is compatible with SQLite and MySQL, for example.

    Regular expression support is currently implemented for Oracle, PostgreSQL, MySQL and MariaDB. Partial support is available for SQLite. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern. When using the ignore case flag ‘i’ in PostgreSQL, the ignore case regexp match operator ~* or !~* will be used.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_replace()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_replace "sqlalchemy.sql.expression.ColumnOperators.regexp_replace")

  • method sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators

    inherited from the ColumnOperators.regexp_replace() method of ColumnOperators

    Implements a database-specific ‘regexp replace’ operator.

    E.g.:

    1. stmt = select(
    2.     table.c.some_column.regexp_replace(
    3.         'b(..)',
    4.         'XY',
    5.         flags='g'
    6.     )
    7. )

    ColumnOperators.regexp_replace() attempts to resolve to a REGEXP_REPLACE-like function provided by the backend, that usually emit the function REGEXP_REPLACE(). However, the specific regular expression syntax and flags available are not backend agnostic.

    Regular expression replacement support is currently implemented for Oracle, PostgreSQL, MySQL 8 or greater and MariaDB. Support among third-party dialects may vary.

    • Parameters:

      • pattern – The regular expression pattern string or column clause.

      • pattern – The replacement string or column clause.

      • flags – Any regular expression string flags to apply. Flags tend to be backend specific. It can be a string or a column clause. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern.

  1. New in version 1.4.
  3. See also
  5. [ColumnOperators.regexp\_match()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.regexp_match "sqlalchemy.sql.expression.ColumnOperators.regexp_match")
  1. See also
  3. [ColumnOperators.endswith()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.endswith "sqlalchemy.sql.expression.ColumnOperators.endswith")
  5. [ColumnOperators.contains()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.contains "sqlalchemy.sql.expression.ColumnOperators.contains")
  7. [ColumnOperators.like()]($aafca12b71ff5dd3.md#sqlalchemy.sql.expression.ColumnOperators.like "sqlalchemy.sql.expression.ColumnOperators.like")

class sqlalchemy.ext.associationproxy.AssociationProxyExtensionType

An enumeration.

Members

ASSOCIATION_PROXY

Class signature

class sqlalchemy.ext.associationproxy.AssociationProxyExtensionType (sqlalchemy.orm.base.InspectionAttrExtensionType)