ALTER TABLE users DROP CONSTRAINT cst_user_name_length
DROP TABLE users{stop}
-The real usefulness of the above becomes clearer once we illustrate the :meth:`.DDLEvent.execute_if`
-method. This method returns a modified form of the DDL callable which will
-filter on criteria before responding to a received event. It accepts a
-parameter ``dialect``, which is the string name of a dialect or a tuple of such,
-which will limit the execution of the item to just those dialects. It also
-accepts a ``callable_`` parameter which may reference a Python callable which will
-be invoked upon event reception, returning ``True`` or ``False`` indicating if
-the event should proceed.
+The real usefulness of the above becomes clearer once we illustrate the
+:meth:`.DDLElement.execute_if` method. This method returns a modified form of
+the DDL callable which will filter on criteria before responding to a
+received event. It accepts a parameter ``dialect``, which is the string
+name of a dialect or a tuple of such, which will limit the execution of the
+item to just those dialects. It also accepts a ``callable_`` parameter which
+may reference a Python callable which will be invoked upon event reception,
+returning ``True`` or ``False`` indicating if the event should proceed.
If our :class:`~sqlalchemy.schema.CheckConstraint` was only supported by
Postgresql and not other databases, we could limit its usage to just that dialect::
class Engine(Connectable, log.Identified):
"""
Connects a :class:`~sqlalchemy.pool.Pool` and
- :class:`~sqlalchemy.engine.base.Dialect` together to provide a source
+ :class:`~sqlalchemy.engine.Dialect` together to provide a source
of database connectivity and behavior.
An :class:`.Engine` object is instantiated publicly using the
"""Performs database schema inspection.
The Inspector acts as a proxy to the reflection methods of the
- :class:`~sqlalchemy.engine.base.Dialect`, providing a
+ :class:`~sqlalchemy.engine.interfaces.Dialect`, providing a
consistent interface as well as caching support for previously
fetched metadata.
engine = create_engine('...')
insp = Inspector.from_engine(engine)
- Where above, the :class:`~sqlalchemy.engine.base.Dialect` may opt
+ Where above, the :class:`~sqlalchemy.engine.interfaces.Dialect` may opt
to return an :class:`.Inspector` subclass that provides additional
methods specific to the dialect's target database.
def __init__(self, bind):
"""Initialize a new :class:`.Inspector`.
- :param bind: a :class:`~sqlalchemy.engine.base.Connectable`,
+ :param bind: a :class:`~sqlalchemy.engine.Connectable`,
which is typically an instance of
:class:`~sqlalchemy.engine.Engine` or
:class:`~sqlalchemy.engine.Connection`.
For a dialect-specific instance of :class:`.Inspector`, see
- :meth:`Inspector.from_engine`
+ :meth:`.Inspector.from_engine`
"""
# this might not be a connection, it could be an engine.
"""Construct a new dialect-specific Inspector object from the given
engine or connection.
- :param bind: a :class:`~sqlalchemy.engine.base.Connectable`,
+ :param bind: a :class:`~sqlalchemy.engine.Connectable`,
which is typically an instance of
:class:`~sqlalchemy.engine.Engine` or
:class:`~sqlalchemy.engine.Connection`.
This method differs from direct a direct constructor call of
:class:`.Inspector` in that the
- :class:`~sqlalchemy.engine.base.Dialect` is given a chance to provide
- a dialect-specific :class:`.Inspector` instance, which may provide
- additional methods.
+ :class:`~sqlalchemy.engine.interfaces.Dialect` is given a chance to
+ provide a dialect-specific :class:`.Inspector` instance, which may
+ provide additional methods.
See the example at :class:`.Inspector`.
table. The metadata is used as a point of association of this table
with other tables which are referenced via foreign key. It also
may be used to associate this table with a particular
- :class:`~sqlalchemy.engine.base.Connectable`.
+ :class:`.Connectable`.
:param \*args: Additional positional arguments are used primarily
to add the list of :class:`.Column` objects contained within this
This alternate hook to :func:`.event.listen` allows the establishment
of a listener function specific to this :class:`.Table` before
the "autoload" process begins. Particularly useful for
- the :meth:`.events.column_reflect` event::
+ the :meth:`.DDLEvents.column_reflect` event::
def listen_for_reflect(table, column_info):
"handle the column reflection event"
])
:param mustexist: When ``True``, indicates that this Table must already
- be present in the given :class:`.MetaData`` collection, else
+ be present in the given :class:`.MetaData` collection, else
an exception is raised.
:param prefixes:
in this ``MetaData`` no longer exists in the database.
:param bind:
- A :class:`~sqlalchemy.engine.base.Connectable` used to access the
- database; if None, uses the existing bind on this ``MetaData``, if
- any.
+ A :class:`.Connectable` used to access the database; if None, uses
+ the existing bind on this ``MetaData``, if any.
:param schema:
Optional, query and reflect tables from an alterate schema.
present in the target database.
:param bind:
- A :class:`~sqlalchemy.engine.base.Connectable` used to access the
+ A :class:`.Connectable` used to access the
database; if None, uses the existing bind on this ``MetaData``, if
any.
the target database.
:param bind:
- A :class:`~sqlalchemy.engine.base.Connectable` used to access the
+ A :class:`.Connectable` used to access the
database; if None, uses the existing bind on this ``MetaData``, if
any.
"""Execute this DDL immediately.
Executes the DDL statement in isolation using the supplied
- :class:`~sqlalchemy.engine.base.Connectable` or
- :class:`~sqlalchemy.engine.base.Connectable` assigned to the ``.bind``
+ :class:`.Connectable` or
+ :class:`.Connectable` assigned to the ``.bind``
property, if not supplied. If the DDL has a conditional ``on``
criteria, it will be invoked with None as the event.
:param bind:
Optional, an ``Engine`` or ``Connection``. If not supplied, a valid
- :class:`~sqlalchemy.engine.base.Connectable` must be present in the
+ :class:`.Connectable` must be present in the
``.bind`` property.
:param target:
available for use in string substitutions on the DDL statement.
:param bind:
- Optional. A :class:`~sqlalchemy.engine.base.Connectable`, used by
+ Optional. A :class:`.Connectable`, used by
default when ``execute()`` is invoked without a bind argument.
def compile(self, bind=None, dialect=None, **kw):
"""Compile this SQL expression.
- The return value is a :class:`~sqlalchemy.engine.Compiled` object.
+ The return value is a :class:`~.Compiled` object.
Calling ``str()`` or ``unicode()`` on the returned value will yield a
string representation of the result. The
- :class:`~sqlalchemy.engine.Compiled` object also can return a
+ :class:`~.Compiled` object also can return a
dictionary of bind parameter names and values
using the ``params`` accessor.
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
