sqlalchemy.orm.decl_api.registry

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Class decorator which will invoke _orm.registry.generate_base for a given base class.

E.g.:

from sqlalchemy.orm import registry

mapper_registry = registry()

@mapper_registry.as_declarative_base()
class Base(object):
    @declared_attr
    def __tablename__(cls):
        return cls.__name__.lower()
    id = Column(Integer, primary_key=True)

class MyMappedClass(Base):
    # ...

All keyword arguments passed to _orm.registry.as_declarative_base are passed along to _orm.registry.generate_base.

Configure all as-yet unconfigured mappers in this _orm.registry.

The configure step is used to reconcile and initialize the _orm.relationship linkages between mapped classes, as well as to invoke configuration events such as the _orm.MapperEvents.before_configured and _orm.MapperEvents.after_configured, which may be used by ORM extensions or user-defined extension hooks.

If one or more mappers in this registry contain _orm.relationship constructs that refer to mapped classes in other registries, this registry is said to be dependent on those registries. In order to configure those dependent registries automatically, the :paramref:`_orm.registry.configure.cascade` flag should be set to True. Otherwise, if they are not configured, an exception will be raised. The rationale behind this behavior is to allow an application to programmatically invoke configuration of registries while controlling whether or not the process implicitly reaches other registries.

As an alternative to invoking _orm.registry.configure, the ORM function _orm.configure_mappers function may be used to ensure configuration is complete for all _orm.registry objects in memory. This is generally simpler to use and also predates the usage of _orm.registry objects overall. However, this function will impact all mappings throughout the running Python process and may be more memory/time consuming for an application that has many registries in use for different purposes that may not be needed immediately.

Dispose of all mappers in this _orm.registry.

After invocation, all the classes that were mapped within this registry will no longer have class instrumentation associated with them. This method is the per-_orm.registry analogue to the application-wide _orm.clear_mappers function.

If this registry contains mappers that are dependencies of other registries, typically via _orm.relationship links, then those registries must be disposed as well. When such registries exist in relation to this one, their _orm.registry.dispose method will also be called, if the :paramref:`_orm.registry.dispose.cascade` flag is set to True; otherwise, an error is raised if those registries were not already disposed.

Generate a declarative base class.

Classes that inherit from the returned class object will be automatically mapped using declarative mapping.

E.g.:

from sqlalchemy.orm import registry

mapper_registry = registry()

Base = mapper_registry.generate_base()

class MyClass(Base):
    __tablename__ = "my_table"
    id = Column(Integer, primary_key=True)

The above dynamically generated class is equivalent to the non-dynamic example below:

from sqlalchemy.orm import registry
from sqlalchemy.orm.decl_api import DeclarativeMeta

mapper_registry = registry()

class Base(metaclass=DeclarativeMeta):
    __abstract__ = True
    registry = mapper_registry
    metadata = mapper_registry.metadata

    __init__ = mapper_registry.constructor

The _orm.registry.generate_base method provides the implementation for the _orm.declarative_base function, which creates the _orm.registry and base class all at once.

See the section :ref:`orm_declarative_mapping` for background and examples.

Map a class declaratively.

In this form of mapping, the class is scanned for mapping information, including for columns to be associated with a table, and/or an actual table object.

Returns the _orm.Mapper object.

E.g.:

from sqlalchemy.orm import registry

mapper_registry = registry()

class Foo:
    __tablename__ = 'some_table'

    id = Column(Integer, primary_key=True)
    name = Column(String)

mapper = mapper_registry.map_declaratively(Foo)

This function is more conveniently invoked indirectly via either the _orm.registry.mapped class decorator or by subclassing a declarative metaclass generated from _orm.registry.generate_base.

See the section :ref:`orm_declarative_mapping` for complete details and examples.

Map a class imperatively.

In this form of mapping, the class is not scanned for any mapping information. Instead, all mapping constructs are passed as arguments.

This method is intended to be fully equivalent to the classic SQLAlchemy _orm.mapper function, except that it's in terms of a particular registry.

E.g.:

from sqlalchemy.orm import registry

mapper_registry = registry()

my_table = Table(
    "my_table",
    mapper_registry.metadata,
    Column('id', Integer, primary_key=True)
)

class MyClass:
    pass

mapper_registry.map_imperatively(MyClass, my_table)

See the section :ref:`orm_imperative_mapping` for complete background and usage examples.

Class decorator that will apply the Declarative mapping process to a given class.

E.g.:

from sqlalchemy.orm import registry

mapper_registry = registry()

@mapper_registry.mapped
class Foo:
    __tablename__ = 'some_table'

    id = Column(Integer, primary_key=True)
    name = Column(String)

See the section :ref:`orm_declarative_mapping` for complete details and examples.