.. autoclass:: sqlalchemy.orm.state.AttributeState
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.instrumentation.ClassManager
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.properties.ColumnProperty
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.descriptor_props.CompositeProperty
:members:
-
+
.. autoclass:: sqlalchemy.orm.attributes.Event
:members:
-
+
.. autoclass:: sqlalchemy.orm.interfaces._InspectionAttr
:members:
-
+
.. autoclass:: sqlalchemy.orm.state.InstanceState
:members:
-
+
.. autoclass:: sqlalchemy.orm.attributes.InstrumentedAttribute
:members: __get__, __set__, __delete__
-
+
:undoc-members:
+.. autodata:: sqlalchemy.orm.interfaces.MANYTOONE
+
+.. autodata:: sqlalchemy.orm.interfaces.MANYTOMANY
+
.. autoclass:: sqlalchemy.orm.interfaces.MapperProperty
:members:
-
.. autodata:: sqlalchemy.orm.interfaces.NOT_EXTENSION
+
+.. autodata:: sqlalchemy.orm.interfaces.ONETOMANY
+
.. autoclass:: sqlalchemy.orm.interfaces.PropComparator
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.properties.RelationshipProperty
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.descriptor_props.SynonymProperty
:members:
-
+
:inherited-members:
.. autoclass:: sqlalchemy.orm.query.QueryContext
:members:
-
+
.. autoclass:: sqlalchemy.orm.attributes.QueryableAttribute
:members:
EXT_CONTINUE = util.symbol('EXT_CONTINUE')
EXT_STOP = util.symbol('EXT_STOP')
-ONETOMANY = util.symbol('ONETOMANY')
-MANYTOONE = util.symbol('MANYTOONE')
-MANYTOMANY = util.symbol('MANYTOMANY')
+ONETOMANY = util.symbol('ONETOMANY',
+"""Indicates the one-to-many direction for a :func:`.relationship`.
-NOT_EXTENSION = util.symbol('NOT_EXTENSION')
+This symbol is typically used by the internals but may be exposed within
+certain API features.
+
+""")
+
+MANYTOONE = util.symbol('MANYTOONE',
+"""Indicates the many-to-one direction for a :func:`.relationship`.
+
+This symbol is typically used by the internals but may be exposed within
+certain API features.
+
+""")
+
+MANYTOMANY = util.symbol('MANYTOMANY',
+"""Indicates the many-to-many direction for a :func:`.relationship`.
+
+This symbol is typically used by the internals but may be exposed within
+certain API features.
+
+""")
+
+NOT_EXTENSION = util.symbol('NOT_EXTENSION',
"""Symbol indicating an :class:`_InspectionAttr` that's
not part of sqlalchemy.ext.
Is assigned to the :attr:`._InspectionAttr.extension_type`
attibute.
-"""
+""")
_none_set = frozenset([None])
@property
def key(self):
+ """Return the 'key' for this :class:`.Table`.
+
+ This value is used as the dictionary key within the
+ :attr:`.MetaData.tables` collection. It is typically the same
+ as that of :attr:`.Table.name` for a table with no :attr:`.Table.schema`
+ set; otherwise it is typically of the form ``schemaname.tablename``.
+
+ """
return _get_table_key(self.name, self.schema)
def __repr__(self):
execution.
The :class:`.Table` objects themselves are stored in the
- ``metadata.tables`` dictionary.
-
- The ``bind`` property may be assigned to dynamically. A common pattern is
- to start unbound and then bind later when an engine is available::
+ :attr:`.MetaData.tables` dictionary.
- metadata = MetaData()
- # define tables
- Table('mytable', metadata, ...)
- # connect to an engine later, perhaps after loading a URL from a
- # configuration file
- metadata.bind = an_engine
-
- MetaData is a thread-safe object after tables have been explicitly defined
- or loaded via reflection.
+ :class:`.MetaData` is a thread-safe object for read operations. Construction
+ of new tables within a single :class:`.MetaData` object, either explicitly
+ or via reflection, may not be completely thread-safe.
.. seealso::
"with reflect=True")
self.reflect()
+ tables = None
+ """A dictionary of :class:`.Table` objects keyed to their name or "table key".
+
+ The exact key is that determined by the :attr:`.Table.key` attribute;
+ for a table with no :attr:`.Table.schema` attribute, this is the same
+ as :attr:`.Table.name`. For a table with a schema, it is typically of the
+ form ``schemaname.tablename``.
+
+ .. seealso::
+
+ :attr:`.MetaData.sorted_tables`
+
+ """
+
def __repr__(self):
return 'MetaData(bind=%r)' % self.bind
.. seealso::
- :meth:`.Inspector.sorted_tables`
+ :attr:`.MetaData.tables`
+
+ :meth:`.Inspector.get_table_names`
"""
return ddl.sort_tables(self.tables.values())
__visit_name__ = 'fromclause'
named_with_column = False
_hide_froms = []
+
schema = None
+ """Define the 'schema' attribute for this :class:`.FromClause`.
+
+ This is typically ``None`` for most objects except that of :class:`.Table`,
+ where it is taken as the value of the :paramref:`.Table.schema` argument.
+
+ """
+
_memoized_property = util.group_expirable_memoized_property(["_columns"])
@util.dependencies("sqlalchemy.sql.functions")