~ubuntu-branches/debian/jessie/sqlalchemy/jessie

Above, the :func:`declarative_base` callable returns a new base class from which

all mapped classes should inherit.  When the class definition is completed, a

new :class:`~sqlalchemy.schema.Table` and

:class:`~sqlalchemy.orm.mapper` will have been generated, accessible

via the ``__table__`` and ``__mapper__`` attributes on the ``SomeClass`` class.

        engineer_id = Column('id', Integer, ForeignKey('people.id'), primary_key=True)

Like :func:`~sqlalchemy.orm.relationship`, all :class:`~sqlalchemy.orm.interfaces.MapperProperty`

subclasses such as :func:`~sqlalchemy.orm.deferred`, 

:func:`~sqlalchemy.orm.column_property`, etc. ultimately involve references

to columns, and therefore have the :func:`~sqlalchemy.util.classproperty` requirement so that no reliance on copying is needed::

        __tablename__ = None

        primary_language = Column(String(50))

            if (decl.has_inherited_table(cls) and

                TableNameMixin not in cls.__bases__):

        # This is single table inheritance

        __tablename__ = None

        primary_language = Column(String(50))

        # This is joinded table inheritance

        __tablename__ = None

        __mapper_args__ = {'polymorphic_identity': 'engineer'}

from sqlalchemy.orm import synonym as _orm_synonym, mapper, comparable_property, class_mapper

__all__ = 'declarative_base', 'synonym_for', 'comparable_using', 'instrument_declarative'

    """Given a class, return True if any of the classes it inherits from has a mapped

    table, otherwise return False.

                                "Tuple form of __table_args__ is "

                                "(arg1, arg2, arg3, ..., {'kw1':val1, 'kw2':val2, ...})"

                            )

                                          *(tuple(cols) + tuple(args)), **table_kw)

                        "Can't add additional column %r when specifying __table__" % key

                        )

                mapper_args['inherits'] = cls._decl_class_registry.get(c.__name__, None)

            "specified and does not inherit from an existing table-mapped class." % cls

        inherited_mapper = class_mapper(mapper_args['inherits'], compile=False)

                    "Can't place __table_args__ on an inherited class with no table."

                        "Can't place primary key columns on an inherited class with no table."

                                "Column '%s' on class %s conflicts with existing column '%s'" % 

                                (c, cls, inherited_table.c[c.name])

                            )

        inherited_mapper = class_mapper(mapper_args['inherits'], compile=False)

    cls.__mapper__ = mapper_cls(cls, table, properties=our_stuff, **mapper_args)

                cls.__mapper__.add_property(key, _deferred_relationship(cls, value))

                                        "Class %r does not have a mapped column named %r"

                                        % (self.cls, key))

                                        "Property %r is not an instance of"

                                        " ColumnProperty (i.e. does not correspond"

                                        " directly to a Column)." % key)

                    "When compiling mapper %s, expression %r failed to locate a name (%r). "

                    "If this is a class name, consider adding this relationship() to the %r "

                    "class after both dependent classes have been defined." % (

                    prop.parent, arg, n.args[0], cls))

    A decorator version of :func:`~sqlalchemy.orm.synonym`.  The function being

    decorated is the 'descriptor', otherwise passes its arguments through

    to synonym()::

        if not hasattr(type(self), k):

                (k, type(self).__name__))

      

      An optional callable, defaults to :func:`~sqlalchemy.orm.mapper`.  Will be

      used to map subclasses to their Tables.

      Defaults to :class:`object`.  A type to use as the base for the generated

      declarative base class.  May be a class or tuple of classes.