While :class:`.Operations` is normally configured as
part of the :meth:`.EnvironmentContext.run_migrations`
- method called from an ``env.py`` script, a standalone
+ method called from an ``env.py`` script, a standalone
:class:`.Operations` instance can be
made for use cases external to regular Alembic
migrations by passing in a :class:`.MigrationContext`::
-
+
from alembic.migration import MigrationContext
from alembic.operations import Operations
-
+
conn = myengine.connect()
ctx = MigrationContext.configure(conn)
op = Operations(ctx)
-
+
op.alter_column("t", "c", nullable=True)
-
+
"""
def __init__(self, migration_context):
"""Construct a new :class:`.Operations`
- :param migration_context: a :class:`.MigrationContext`
+ :param migration_context: a :class:`.MigrationContext`
instance.
"""
yield op
alembic.op._remove_proxy()
- def _foreign_key_constraint(self, name, source, referent,
+ def _foreign_key_constraint(self, name, source, referent,
local_cols, remote_cols,
onupdate=None, ondelete=None):
m = schema.MetaData()
- t1 = schema.Table(source, m,
+ t1 = schema.Table(source, m,
*[schema.Column(n, NULLTYPE) for n in local_cols])
- t2 = schema.Table(referent, m,
+ t2 = schema.Table(referent, m,
*[schema.Column(n, NULLTYPE) for n in remote_cols])
- f = schema.ForeignKeyConstraint(local_cols,
- ["%s.%s" % (referent, n)
+ f = schema.ForeignKeyConstraint(local_cols,
+ ["%s.%s" % (referent, n)
for n in remote_cols],
name=name,
onupdate=onupdate,
return f
def _unique_constraint(self, name, source, local_cols, **kw):
- t = schema.Table(source, schema.MetaData(),
+ t = schema.Table(source, schema.MetaData(),
*[schema.Column(n, NULLTYPE) for n in local_cols])
kw['name'] = name
uq = schema.UniqueConstraint(*[t.c[n] for n in local_cols], **kw)
return uq
def _check_constraint(self, name, source, condition, **kw):
- t = schema.Table(source, schema.MetaData(),
+ t = schema.Table(source, schema.MetaData(),
schema.Column('x', Integer))
ck = schema.CheckConstraint(condition, name=name, **kw)
t.append_constraint(ck)
schema=schema
)
- def alter_column(self, table_name, column_name,
+ def alter_column(self, table_name, column_name,
nullable=None,
server_default=False,
name=None,
existing_server_default=False,
existing_nullable=None,
):
- """Issue an "alter column" instruction using the
+ """Issue an "alter column" instruction using the
current migration context.
Generally, only that aspect of the column which
and :class:`~sqlalchemy.types.Enum` may also
add or drop constraints which accompany those
types on backends that don't support them natively.
- The ``existing_server_default`` argument is
+ The ``existing_server_default`` argument is
used in this case as well to remove a previous
constraint.
:param table_name: string name of the target table.
- :param column_name: string name of the target column,
+ :param column_name: string name of the target column,
as it exists before the operation begins.
:param nullable: Optional; specify ``True`` or ``False``
to alter the column's nullability.
- :param server_default: Optional; specify a string
+ :param server_default: Optional; specify a string
SQL expression, :func:`~sqlalchemy.sql.expression.text`,
or :class:`~sqlalchemy.schema.DefaultClause` to indicate
an alteration to the column's default value.
indicate the new name within a column rename operation.
:param type_: Optional; a :class:`~sqlalchemy.types.TypeEngine`
type object to specify a change to the column's type.
- For SQLAlchemy types that also indicate a constraint (i.e.
- :class:`~sqlalchemy.types.Boolean`,
- :class:`~sqlalchemy.types.Enum`),
+ For SQLAlchemy types that also indicate a constraint (i.e.
+ :class:`~sqlalchemy.types.Boolean`,
+ :class:`~sqlalchemy.types.Enum`),
the constraint is also generated.
- :param existing_type: Optional; a
+ :param existing_type: Optional; a
:class:`~sqlalchemy.types.TypeEngine`
type object to specify the previous type. This
- is required for all MySQL column alter operations that
+ is required for all MySQL column alter operations that
don't otherwise specify a new type, as well as for
when nullability is being changed on a SQL Server
- column. It is also used if the type is a so-called
+ column. It is also used if the type is a so-called
SQLlchemy "schema" type which
- may define a constraint (i.e.
- :class:`~sqlalchemy.types.Boolean`,
- :class:`~sqlalchemy.types.Enum`),
+ may define a constraint (i.e.
+ :class:`~sqlalchemy.types.Boolean`,
+ :class:`~sqlalchemy.types.Enum`),
so that the constraint can be dropped.
:param existing_server_default: Optional; The existing
- default value of the column. Required on MySQL if
- an existing default is not being changed; else MySQL
+ default value of the column. Required on MySQL if
+ an existing default is not being changed; else MySQL
removes the default.
:param existing_nullable: Optional; the existing nullability
of the column. Required on MySQL if the existing nullability
"""
if existing_type:
- t = self._table(table_name,
+ t = self._table(table_name,
schema.Column(column_name, existing_type)
)
for constraint in t.constraints:
if not isinstance(constraint, schema.PrimaryKeyConstraint):
self.impl.drop_constraint(constraint)
- self.impl.alter_column(table_name, column_name,
+ self.impl.alter_column(table_name, column_name,
nullable=nullable,
server_default=server_default,
name=name,
self.impl.add_constraint(constraint)
def add_column(self, table_name, column):
- """Issue an "add column" instruction using the current
+ """Issue an "add column" instruction using the current
migration context.
e.g.::
from alembic import op
from sqlalchemy import Column, String
- op.add_column('organization',
+ op.add_column('organization',
Column('name', String())
)
from alembic import op
from sqlalchemy import Column, INTEGER, ForeignKey
- op.add_column('organization',
+ op.add_column('organization',
Column('account_id', INTEGER, ForeignKey('accounts.id'))
)
default values to be created on the database side are
specified using the ``server_default`` parameter, and not
``default`` which only specifies Python-side defaults::
-
+
from alembic import op
from sqlalchemy import Column, TIMESTAMP, func
self.impl.add_constraint(constraint)
def drop_column(self, table_name, column_name, **kw):
- """Issue a "drop column" instruction using the current
+ """Issue a "drop column" instruction using the current
migration context.
e.g.::
:param table_name: name of table
:param column_name: name of column
- :param mssql_drop_check: Optional boolean. When ``True``, on
- Microsoft SQL Server only, first
- drop the CHECK constraint on the column using a
+ :param mssql_drop_check: Optional boolean. When ``True``, on
+ Microsoft SQL Server only, first
+ drop the CHECK constraint on the column using a
SQL-script-compatible
block that selects into a @variable from sys.check_constraints,
then exec's a separate DROP CONSTRAINT for that constraint.
- :param mssql_drop_default: Optional boolean. When ``True``, on
- Microsoft SQL Server only, first
- drop the DEFAULT constraint on the column using a
+ :param mssql_drop_default: Optional boolean. When ``True``, on
+ Microsoft SQL Server only, first
+ drop the DEFAULT constraint on the column using a
SQL-script-compatible
block that selects into a @variable from sys.default_constraints,
then exec's a separate DROP CONSTRAINT for that default.
)
- def create_foreign_key(self, name, source, referent, local_cols,
+ def create_foreign_key(self, name, source, referent, local_cols,
remote_cols, onupdate=None, ondelete=None):
- """Issue a "create foreign key" instruction using the
+ """Issue a "create foreign key" instruction using the
current migration context.
e.g.::
from alembic import op
op.create_foreign_key(
- "fk_user_address", "address",
+ "fk_user_address", "address",
"user", ["user_id"], ["id"])
This internally generates a :class:`~sqlalchemy.schema.Table` object
- containing the necessary columns, then generates a new
+ containing the necessary columns, then generates a new
:class:`~sqlalchemy.schema.ForeignKeyConstraint`
object which it then associates with the :class:`~sqlalchemy.schema.Table`.
- Any event listeners associated with this action will be fired
+ Any event listeners associated with this action will be fired
off normally. The :class:`~sqlalchemy.schema.AddConstraint`
construct is ultimately used to generate the ALTER statement.
:param name: Name of the foreign key constraint. The name is necessary
so that an ALTER statement can be emitted. For setups that
use an automated naming scheme such as that described at
- `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
+ `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
``name`` here can be ``None``, as the event listener will
apply the name to the constraint object when it is associated
with the table.
there is no support for dotted schema names.
:param referent: String name of the destination table. Currently
there is no support for dotted schema names.
- :param local_cols: a list of string column names in the
+ :param local_cols: a list of string column names in the
source table.
:param remote_cols: a list of string column names in the
remote table.
"""
self.impl.add_constraint(
- self._foreign_key_constraint(name, source, referent,
+ self._foreign_key_constraint(name, source, referent,
local_cols, remote_cols,
onupdate=onupdate, ondelete=ondelete)
)
def create_unique_constraint(self, name, source, local_cols, **kw):
- """Issue a "create unique constraint" instruction using the
+ """Issue a "create unique constraint" instruction using the
current migration context.
e.g.::
op.create_unique_constraint("uq_user_name", "user", ["name"])
This internally generates a :class:`~sqlalchemy.schema.Table` object
- containing the necessary columns, then generates a new
+ containing the necessary columns, then generates a new
:class:`~sqlalchemy.schema.UniqueConstraint`
object which it then associates with the :class:`~sqlalchemy.schema.Table`.
- Any event listeners associated with this action will be fired
+ Any event listeners associated with this action will be fired
off normally. The :class:`~sqlalchemy.schema.AddConstraint`
construct is ultimately used to generate the ALTER statement.
:param name: Name of the unique constraint. The name is necessary
so that an ALTER statement can be emitted. For setups that
use an automated naming scheme such as that described at
- `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
+ `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
``name`` here can be ``None``, as the event listener will
apply the name to the constraint object when it is associated
with the table.
:param source: String name of the source table. Currently
there is no support for dotted schema names.
- :param local_cols: a list of string column names in the
+ :param local_cols: a list of string column names in the
source table.
:param deferrable: optional bool. If set, emit DEFERRABLE or NOT DEFERRABLE when
issuing DDL for this constraint.
"""
self.impl.add_constraint(
- self._unique_constraint(name, source, local_cols,
+ self._unique_constraint(name, source, local_cols,
**kw)
)
def create_check_constraint(self, name, source, condition, **kw):
- """Issue a "create check constraint" instruction using the
+ """Issue a "create check constraint" instruction using the
current migration context.
e.g.::
op.create_check_constraint(
"ck_user_name_len",
- "user",
+ "user",
func.len(column('name')) > 5
)
CHECK constraints are usually against a SQL expression, so ad-hoc
- table metadata is usually needed. The function will convert the given
- arguments into a :class:`sqlalchemy.schema.CheckConstraint` bound
+ table metadata is usually needed. The function will convert the given
+ arguments into a :class:`sqlalchemy.schema.CheckConstraint` bound
to an anonymous table in order to emit the CREATE statement.
:param name: Name of the check constraint. The name is necessary
so that an ALTER statement can be emitted. For setups that
use an automated naming scheme such as that described at
- `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
+ `NamingConventions <http://www.sqlalchemy.org/trac/wiki/UsageRecipes/NamingConventions>`_,
``name`` here can be ``None``, as the event listener will
apply the name to the constraint object when it is associated
with the table.
def create_table(self, name, *columns, **kw):
"""Issue a "create table" instruction using the current migration context.
- This directive receives an argument list similar to that of the
+ This directive receives an argument list similar to that of the
traditional :class:`sqlalchemy.schema.Table` construct, but without the
metadata::
default values to be created on the database side are
specified using the ``server_default`` parameter, and not
``default`` which only specifies Python-side defaults::
-
+
from alembic import op
from sqlalchemy import Column, TIMESTAMP, func
)
:param name: Name of the table
- :param \*columns: collection of :class:`~sqlalchemy.schema.Column`
+ :param \*columns: collection of :class:`~sqlalchemy.schema.Column`
objects within
- the table, as well as optional :class:`~sqlalchemy.schema.Constraint`
+ the table, as well as optional :class:`~sqlalchemy.schema.Constraint`
objects
and :class:`~.sqlalchemy.schema.Index` objects.
- :param emit_events: if ``True``, emit ``before_create`` and
- ``after_create`` events when the table is being created. In
- particular, the Postgresql ENUM type will emit a CREATE TYPE within
+ :param emit_events: if ``True``, emit ``before_create`` and
+ ``after_create`` events when the table is being created. In
+ particular, the Postgresql ENUM type will emit a CREATE TYPE within
these events.
:param \**kw: Other keyword arguments are passed to the underlying
:class:`.Table` object created for the command.
)
def drop_table(self, name):
- """Issue a "drop table" instruction using the current
+ """Issue a "drop table" instruction using the current
migration context.
)
def create_index(self, name, tablename, *columns, **kw):
- """Issue a "create index" instruction using the current
+ """Issue a "create index" instruction using the current
migration context.
e.g.::
)
def drop_index(self, name, tablename=None):
- """Issue a "drop index" instruction using the current
+ """Issue a "drop index" instruction using the current
migration context.
e.g.::
drop_index("accounts")
-
+
:param tablename: name of the owning table. Some
backends such as Microsoft SQL Server require this.
def drop_constraint(self, name, tablename, type=None):
"""Drop a constraint of the given name, typically via DROP CONSTRAINT.
-
+
:param name: name of the constraint.
:param tablename: tablename.
- :param type: optional, required on MySQL. can be
- 'foreignkey', 'primary', 'unique', or 'check'
+ :param type: optional, required on MySQL. can be
+ 'foreignkey', 'primary', 'unique', or 'check'.
+
+ .. versionadded:: 0.3.6 'primary' qualfier to enable
+ dropping of MySQL primary key constraints.
"""
t = self._table(tablename)
types = {
'foreignkey':lambda name:schema.ForeignKeyConstraint(
[], [], name=name),
- 'primary':schema.PrimaryKeyConstraint,
+ 'primary':schema.PrimaryKeyConstraint,
'unique':schema.UniqueConstraint,
'check':lambda name:schema.CheckConstraint("", name=name),
None:schema.Constraint
try:
const = types[type]
except KeyError:
- raise TypeError("'type' can be one of %s" %
- ", ".join(sorted(repr(x) for x in types)))
+ raise TypeError("'type' can be one of %s" %
+ ", ".join(sorted(repr(x) for x in types)))
const = const(name=name)
t.append_constraint(const)
self.impl.drop_constraint(const)
def bulk_insert(self, table, rows):
- """Issue a "bulk insert" operation using the current
+ """Issue a "bulk insert" operation using the current
migration context.
This provides a means of representing an INSERT of multiple rows
- which works equally well in the context of executing on a live
- connection as well as that of generating a SQL script. In the
- case of a SQL script, the values are rendered inline into the
+ which works equally well in the context of executing on a live
+ connection as well as that of generating a SQL script. In the
+ case of a SQL script, the values are rendered inline into the
statement.
e.g.::
bulk_insert(accounts_table,
[
- {'id':1, 'name':'John Smith',
+ {'id':1, 'name':'John Smith',
'create_date':date(2010, 10, 5)},
- {'id':2, 'name':'Ed Williams',
+ {'id':2, 'name':'Ed Williams',
'create_date':date(2007, 5, 27)},
- {'id':3, 'name':'Wendy Jones',
+ {'id':3, 'name':'Wendy Jones',
'create_date':date(2008, 8, 15)},
]
)
self.impl.bulk_insert(table, rows)
def inline_literal(self, value, type_=None):
- """Produce an 'inline literal' expression, suitable for
+ """Produce an 'inline literal' expression, suitable for
using in an INSERT, UPDATE, or DELETE statement.
When using Alembic in "offline" mode, CRUD operations
script needs to have these rendered inline. While it should
always be noted that inline literal values are an **enormous**
security hole in an application that handles untrusted input,
- a schema migration is not run in this context, so
+ a schema migration is not run in this context, so
literals are safe to render inline, with the caveat that
advanced types like dates may not be supported directly
by SQLAlchemy.
:param value: The value to render. Strings, integers, and simple
numerics should be supported. Other types like boolean,
- dates, etc. may or may not be supported yet by various
+ dates, etc. may or may not be supported yet by various
backends.
- :param type_: optional - a :class:`sqlalchemy.types.TypeEngine`
- subclass stating the type of this value. In SQLAlchemy
+ :param type_: optional - a :class:`sqlalchemy.types.TypeEngine`
+ subclass stating the type of this value. In SQLAlchemy
expressions, this is usually derived automatically
from the Python type of the value itself, as well as
based on the context in which the value is used.
def execute(self, sql, execution_options=None):
"""Execute the given SQL using the current migration context.
- In a SQL script context, the statement is emitted directly to the
+ In a SQL script context, the statement is emitted directly to the
output stream. There is *no* return result, however, as this
function is oriented towards generating a change script
that can run in "offline" mode. For full interaction
- with a connected database, use the "bind" available
+ with a connected database, use the "bind" available
from the context::
from alembic import op
Also note that any parameterized statement here *will not work*
in offline mode - INSERT, UPDATE and DELETE statements which refer
to literal values would need to render
- inline expressions. For simple use cases, the
- :meth:`.inline_literal` function can be used for **rudimentary**
- quoting of string values. For "bulk" inserts, consider using
+ inline expressions. For simple use cases, the
+ :meth:`.inline_literal` function can be used for **rudimentary**
+ quoting of string values. For "bulk" inserts, consider using
:meth:`.bulk_insert`.
For example, to emit an UPDATE statement which is equally
from sqlalchemy import String
from alembic import op
- account = table('account',
+ account = table('account',
column('name', String)
)
op.execute(
values({'name':op.inline_literal('account 2')})
)
- Note above we also used the SQLAlchemy
+ Note above we also used the SQLAlchemy
:func:`sqlalchemy.sql.expression.table`
and :func:`sqlalchemy.sql.expression.column` constructs to make a brief,
ad-hoc table construct just for our UPDATE statement. A full
* a string
* a :func:`sqlalchemy.sql.expression.text` construct.
* a :func:`sqlalchemy.sql.expression.insert` construct.
- * a :func:`sqlalchemy.sql.expression.update`,
- :func:`sqlalchemy.sql.expression.insert`,
+ * a :func:`sqlalchemy.sql.expression.update`,
+ :func:`sqlalchemy.sql.expression.insert`,
or :func:`sqlalchemy.sql.expression.delete` construct.
* Pretty much anything that's "executable" as described
in :ref:`sqlexpression_toplevel`.
- :param execution_options: Optional dictionary of
- execution options, will be passed to
+ :param execution_options: Optional dictionary of
+ execution options, will be passed to
:meth:`sqlalchemy.engine.base.Connection.execution_options`.
"""
- self.migration_context.impl.execute(sql,
+ self.migration_context.impl.execute(sql,
execution_options=execution_options)
def get_bind(self):
"""Return the current 'bind'.
- Under normal circumstances, this is the
+ Under normal circumstances, this is the
:class:`~sqlalchemy.engine.base.Connection` currently being used
to emit SQL to the database.
projects / thirdparty / sqlalchemy / alembic.git / commitdiff
