dzMhm
d dl mZ d dlmZ d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dlm
Z
d d lm Z d d
lm Z d d lm
Z
d d lmZ d d
lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z erd dlm Z d dl m Z d d l m Z d d l!m"Z" d d l!m#Z# d d l!m$Z$ d d l!m%Z% d d!l!m&Z& d d"l'm(Z( d d#l)m*Z* d d$l)m+Z+ d d%l)m,Z, d d&l)m-Z- d d'l)m.Z. d d(l)m/Z/ d d)l)m0Z0 d d*l)m1Z1 d d+l)m2Z2 d d,l)m3Z3 d d-l)m4Z4 d d.l)m5Z5 d d/l6m7Z7 d d0l8m9Z9 dd1l:m;Z; dd2l G d5 d6e> Z? ej@ d7 ej@ d7d8 G d9 d:e> ZA ej@ d; ej@ d;d< e?B d= G d> d?e? ZC ej@ d@ ej@ d@dA e?B dB G dC dDe? ZD ej@ dE ej@ dEdF e?B dG G dH dIe? ZE ej@ dJ ej@ dJdK e?B dL e?B dM e?B dN G dO dPe? ZF ej@ dQ ej@ dQdR G dS dTe> ZG ej@ dU ej@ dUdV G dW dXe> ZH ej@ dY G dZ d[e> ZI ej@ d\ G d] d^e> ZJ G d_ d`e> ZK ej@ da G db dceK ZL ej@ dd ej@ ddde G df dgeK ZM ej@ dh ej@ dhdi G dj dkeK ZN ej@ dl ej@ dldm G dn doeK ZO ej@ dp ej@ dpdq G dr dseK ZP ej@ dt ej@ dtdu G dv dweK ZQ ej@ dx G dy dze> ZR ej@ d{ ej@ d{d| G d} d~e> ZS G d de> ZT G d deT ZU G d deT ZV G d deT ZW G d de> ZXdS ) ) annotations)abstractmethodN)Any)Callable)cast) FrozenSet)Iterator)List)MutableMapping)Optional)Sequence)Set)Tuple)Type)
TYPE_CHECKING)Union)NULLTYPE ) schemaobj)BatchOperations)
Operations )util) sqla_compat)Literal)Insert)Update)BinaryExpression)
ColumnElement)conv) quoted_name)
TextClause)Function)CheckConstraint)Column)Computed)
Constraint)ForeignKeyConstraint)Identity)Index)MetaData)PrimaryKeyConstraint)
SchemaItem)Table)UniqueConstraint) TableClause)
TypeEngine)Rewriter)MigrationContextc b e Zd ZU dZej d Z e Zde d< d
dZ
d dZ d S ) MigrateOperationzbase class for migration command and organization objects.
This system is part of the operation extensibility API.
.. seealso::
:ref:`operation_objects`
:ref:`operation_plugins`
:ref:`customizing_revision`
c i S )zA dictionary that may be used to store arbitrary information
along with this :class:`.MigrateOperation` object.
selfs h/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/alembic/operations/ops.pyinfozMigrateOperation.infoI s zFrozenSet[Rewriter]
_mutationsreturnc t NNotImplementedErrorr8 s r: reversezMigrateOperation.reverseS !!r< Tuple[Any, ...]c t r@ rA r8 s r:
to_diff_tuplez MigrateOperation.to_diff_tupleV rD r< N)r> r5 )r> rE ) __name__
__module__ __qualname____doc__r memoized_propertyr; frozensetr= __annotations__rC rG r7 r< r: r5 r5 : s
'0ikkJ1111" " " "" " " " " "r< r5 c e Zd ZdZ ej Zed Ze dd Z
e dd
Z e ddd Z
ddZddZd S )AddConstraintOpz&Represent an add constraint operation.c t r@ rA r8 s r: constraint_typez AddConstraintOp.constraint_type_ s !###r< type_strr> r c fd}|S )Nc X j | j | S r@ )add_constraint_ops dispatch_forfrom_constraint)klassclsrS s r: goz3AddConstraintOp.register_add_constraint..goe s, 6C " / / 6 6u7L M M MLr< r7 )r[ rS r\ s `` r: register_add_constraintz'AddConstraintOp.register_add_constraintc s) r<
constraintr' c R | j |j | S r@ )rW dispatch__visit_name__)r[ r^ s r: rY z AddConstraintOp.from_constraintk s- Is%..z/HII
r< Nmigration_contextOptional[MigrationContext]c d S r@ r7 )r9 rb s r:
to_constraintz AddConstraintOp.to_constraintq s
r< DropConstraintOpc Z t | S r@ )rf rY re r8 s r: rC zAddConstraintOp.reversew s" //0B0B0D0DEEEr< Tuple[str, Constraint]c . d| fS )Nadd_constraintre r8 s r: rG z AddConstraintOp.to_diff_tuplez s $"4"4"6"677r< )rS rT r> r )r^ r' r> rP r@ )rb rc r> r' )r> rf )r> rh )rH rI rJ rK r
DispatcherrW propertyrR classmethodr] rY r re rC rG r7 r< r: rP rP Z s 00( **
$ $ X$ [
[
>B
^
F F F F8 8 8 8 8 8r< rP drop_constraintbatch_drop_constraintc e Zd ZdZ d dddd dZd dZd!dZed"d Zd#dZ e d ddd$d Z
e d d%d Z dS )&rf z&Represent a drop constraint operation.Nschema_reverseconstraint_name,Optional[sqla_compat._ConstraintNameDefined]
table_namerT rS
Optional[str]rs rt Optional[AddConstraintOp]r> Nonec L || _ || _ || _ || _ || _ d S r@ )ru rw rR rs rt )r9 ru rw rS rs rt s r: __init__zDropConstraintOp.__init__ s- / $ $
r< rP c Z t | S r@ )rP rY re r8 s r: rC zDropConstraintOp.reverse s" ..t/A/A/C/CDDDr< Tuple[str, SchemaItem]c p | j dk rd| fS d| fS )N
foreignkey remove_fkremove_constraint)rR re r8 s r: rG z DropConstraintOp.to_diff_tuple s@ < / / !3!3!5!56 6'););)=)=> >r< r^ r' c ddddddd}t j | } | t j |j |j |j ||j t | S )Nuniquer primarycheck)unique_constraintforeign_key_constraintprimary_key_constraintcheck_constraintcolumn_check_constraint table_or_column_check_constraint)rs rS rt )r _table_for_constraintconstraint_name_or_nonenamers ra rP rY )r[ r^ typesconstraint_tables r: rY z DropConstraintOp.from_constraint s "*&2&/ ''.07
' rz )r> rP )r> r~ )r^ r' r> rf )r> r' ) r r ru rT rw rT rS rx rs rx r> rz )r r ru rT rS rx r> rz ) rH rI rJ rK r| rC rG rn rY re ro rp r7 r< r: rf rf ~ s 10 $
! !%.2
!
!
!
!
!
! E E E E? ? ? ?
[
& $ % !%% % % % % [%2
$ % % % % [% % %r< rf create_primary_keybatch_create_primary_keyr c ~ e Zd ZdZdZddd dZed d Z d!d"dZeddd#d Z ed$d Z
dS )%CreatePrimaryKeyOpz)Represent a create primary key operation.
primarykeyNr ru rv rw rT columns
Sequence[str]rs rx kwr r> rz c L || _ || _ || _ || _ || _ d S r@ ru rw r rs r r9 ru rw r rs r s r: r| zCreatePrimaryKeyOp.__init__ , / $ r< r^ r' c t j | }t d| } | t j |j |j |j fd|j i|j S )Nr, rs ) r r r r r r keysrs dialect_kwargs)r[ r^ r
pk_constraints r: rY z"CreatePrimaryKeyOp.from_constraint s &??
0z0 O L
;
g
r< r r List[str]c J | |||| }| | S )a" Issue a "create primary key" instruction using the current
migration context.
e.g.::
from alembic import op
op.create_primary_key("pk_my_table", "my_table", ["id", "version"])
This internally generates a :class:`~sqlalchemy.schema.Table` object
containing the necessary columns, then generates a new
:class:`~sqlalchemy.schema.PrimaryKeyConstraint`
object which it then associates with the
:class:`~sqlalchemy.schema.Table`.
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 constraint_name: Name of the primary 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
:ref:`sqla:constraint_naming_conventions`
``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 table_name: String name of the target table.
:param columns: a list of string column names to be applied to the
primary key constraint.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
r r )r[ r ru rw r rs r s r: r z%CreatePrimaryKeyOp.create_primary_key( s1 X S *gf
E
E
E $$$r< r c r | ||j j ||j j }| | S )a Issue a "create primary key" instruction using the
current batch migration context.
The batch form of this call omits the ``table_name`` and ``schema``
arguments from the call.
.. seealso::
:meth:`.Operations.create_primary_key`
r r )r[ r ru r r s r: r z+CreatePrimaryKeyOp.batch_create_primary_keyW sF $ S O & ?)
$$$r< ru rv rw rT r r rs rx r r r> rz )r^ r' r> r r@ )rb rc r> r, ) r r ru rx rw rT r r rs rx r> rz )r r ru rT r r r> rz ) rH rI rJ rK rR r| rn rY re r r r7 r< r: r r s 43"O !%
[
?C
!%,% ,% ,% ,% ,% [,%\ % % % [% % %r< r create_unique_constraint batch_create_unique_constraintr c ~ e Zd ZdZdZddd dZed d Z d d!dZeddd"d Z ed#d Z
dS )$CreateUniqueConstraintOpz/Represent a create unique constraint operation.r Nr ru rv rw rT r r rs rx r r r> rz c L || _ || _ || _ || _ || _ d S r@ r r s r: r| z!CreateUniqueConstraintOp.__init__| r r< r^ r' c @ t j | }t d| }i }|j r
|j |d< |j r
|j |d< | |j | t j |j |j d |j D fd|j
i|S )Nr/
deferrable initiallyc g | ] }|j
S r7 )r ).0cs r:
z. s 3 3 3QV 3 3 3r< rs ) r r r r r updater r r r rs )r[ r^ r
uq_constraintr s r: rY z(CreateUniqueConstraintOp.from_constraint s
'??
+z+ O L
;
g
r< r r c F | |||fd|i|}| | S )a Issue a "create unique constraint" instruction using the
current migration context.
e.g.::
from alembic import op
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
: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
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
:ref:`sqla:constraint_naming_conventions`,
``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 table_name: String name of the source table.
:param columns: 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.
:param initially: optional string. If set, emit INITIALLY
when issuing DDL for this constraint.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
rs r )r[ r ru rw r rs r r s r: r z1CreateUniqueConstraintOp.create_unique_constraint s9 b S *g
K
Kf
K
K
K $$$r< r c t |j j |d< | ||j j |fi |}| | S )a% Issue a "create unique constraint" instruction using the
current batch migration context.
The batch form of this call omits the ``source`` and ``schema``
arguments from the call.
.. seealso::
:meth:`.Operations.create_unique_constraint`
rs )r rs rw r )r[ r ru r r r s r: r z7CreateUniqueConstraintOp.batch_create_unique_constraint sF & "-8
S */" r r@ )rb rc r> r/ )r r ru rx rw rT r r rs rx r r r> r )
r r ru rT r r r r r> r ) rH rI rJ rK rR r| rn rY re r r r7 r< r: r r r s :9 O !%
[
. ?C
!%1% 1% 1% 1% 1% [1%f % % % [% % %r< r create_foreign_keybatch_create_foreign_keyr c e Zd ZdZdZd+dZd,dZed-d Z d.d/dZ eddddddddd0d' Z
eddddddd(d1d* Z dS )2CreateForeignKeyOpz4Represent a create foreign key constraint operation.r ru rv source_tablerT referent_table
local_colsr remote_colsr r r> rz c Z || _ || _ || _ || _ || _ || _ d S r@ )ru r r r r r )r9 ru r r r r r s r: r| zCreateForeignKeyOp.__init__ s6 / ( ,$&r< Tuple[str, ForeignKeyConstraint]c . d| fS )Nadd_fkrk r8 s r: rG z CreateForeignKeyOp.to_diff_tuple s $,,..//r< r^ r' c
t d| }i }|j r
|j |d< |j r
|j |d< |j r
|j |d< |j r
|j |d< |j r
|j |d< t
j | \
}}}}}} }
} } }
||d< ||d< | |j | t
j
|j |||| fi |S ) Nr( onupdateondeleter r use_alter
source_schemareferent_schema) r r r r r r r _fk_specr r r r )r[ r^
fk_constraintr r r source_columns
target_schema target_tabletarget_columnsr r r r s r: rY z"CreateForeignKeyOp.from_constraint s, 3Z@@
! 4 * 3BzN ! 4 * 3BzN " 6 + 5B{O # 8 , 7B| " 6 + 5B{O
/ /
,? -
-.///s /
0B C C
r< Nrb rc r( c t j | } |j | j | j | j | j | j fi | j S r@ ) r r r ru r r r r r r s r: re z CreateForeignKeyOp.to_constraint@ sZ ,->??
0z0 O
g
r< )r r r r matchr r r r rx r r r Optional[bool]r r r r
dialect_kwc V | |||||f||| | |
|
| d|}| | S )a 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",
"user",
["user_id"],
["id"],
)
This internally generates a :class:`~sqlalchemy.schema.Table` object
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
off normally. The :class:`~sqlalchemy.schema.AddConstraint`
construct is ultimately used to generate the ALTER statement.
:param constraint_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
:ref:`sqla:constraint_naming_conventions`,
``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_table: String name of the source table.
:param referent_table: String name of the destination table.
: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.
:param onupdate: Optional string. If set, emit ON UPDATE when
issuing DDL for this constraint. Typical values include CASCADE,
DELETE and RESTRICT.
:param ondelete: Optional string. If set, emit ON DELETE when
issuing DDL for this constraint. Typical values include CASCADE,
DELETE and RESTRICT.
:param deferrable: optional bool. If set, emit DEFERRABLE or NOT
DEFERRABLE when issuing DDL for this constraint.
:param source_schema: Optional schema name of the source table.
:param referent_schema: Optional schema name of the destination table.
r r r r r r r r )r[ r ru r r r r r r r r r r r r r s r: r z%CreateForeignKeyOp.create_foreign_keyM sf J S
!' +
$$$r< )r r r r r r r c ~ | ||j j |||f||| |j j ||
| d| }
| |
S )a+ Issue a "create foreign key" instruction using the
current batch migration context.
The batch form of this call omits the ``source`` and ``source_schema``
arguments from the call.
e.g.::
with batch_alter_table("address") as batch_op:
batch_op.create_foreign_key(
"fk_user_address",
"user",
["user_id"],
["id"],
)
.. seealso::
:meth:`.Operations.create_foreign_key`
r r )r[ r ru r r r r r r r r r r r s r: r z+CreateForeignKeyOp.batch_create_foreign_key sp L S O &
!$/0 +
$$$r< )ru rv r rT r rT r r r r r r r> rz )r> r )r^ r' r> r r@ )rb rc r> r( ) r r ru rx r rT r rT r r r r r rx r rx r r r rx r rx r rx r rx r r r> rz )r r ru rT r rT r r r r r rx r rx r rx r r r rx r rx r r r> rz ) rH rI rJ rK rR r| rG rn rY re r r r7 r< r: r r s ?>"O 0 0 0 0 &
&
&
[&
R ?C
#'"&%)#' #'+)- S% S% S% S% S% [S%j *."&"&%)#' #4% 4% 4% 4% 4% [4% 4% 4%r< r create_check_constraint batch_create_check_constraintr r r c ~ e Zd ZdZdZddd dZed d Z d!d"dZeddd#d Z ed$d Z
dS )%CreateCheckConstraintOpz.Represent a create check constraint operation.r Nr ru rv rw rT condition*Union[str, TextClause, ColumnElement[Any]]rs rx r r r> rz c L || _ || _ || _ || _ || _ d S r@ )ru rw r rs r )r9 ru rw r rs r s r: r| z CreateCheckConstraintOp.__init__ s, / $" r< r^ r' c t j | }t d| } | t j |j |j t d|j fd|j i|j S )Nr$ zColumnElement[Any]rs )r r r r r sqltextrs r )r[ r^ r
ck_constraints r: rY z'CreateCheckConstraintOp.from_constraint s '??
*z* O N
;
g
r< r r (Union[str, BinaryExpression, TextClause]c F | |||fd|i|}| | S )a Issue a "create check constraint" instruction using the
current migration context.
e.g.::
from alembic import op
from sqlalchemy.sql import column, func
op.create_check_constraint(
"ck_user_name_len",
"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
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
:ref:`sqla:constraint_naming_conventions`,
``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 table_name: String name of the source table.
:param condition: SQL expression that's the condition of the
constraint. Can be a string or SQLAlchemy expression language
structure.
:param deferrable: optional bool. If set, emit DEFERRABLE or
NOT DEFERRABLE when issuing DDL for this constraint.
:param initially: optional string. If set, emit INITIALLY
when issuing DDL for this constraint.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
rs r )r[ r ru rw r rs r r s r: r z/CreateCheckConstraintOp.create_check_constraint s9 f S *i
M
M
M"
M
M $$$r< r c n | ||j j |fd|j j i|}| | S )a# Issue a "create check constraint" instruction using the
current batch migration context.
The batch form of this call omits the ``source`` and ``schema``
arguments from the call.
.. seealso::
:meth:`.Operations.create_check_constraint`
rs r )r[ r ru r r r s r: r z5CreateCheckConstraintOp.batch_create_check_constraintG sW & S O &
?)
$$$r< ) ru rv rw rT r r rs rx r r r> rz )r^ r' r> r r@ )rb rc r> r$ )r r ru rx rw rT r r rs rx r r r> rz )
r r ru rT r r r r r> rz ) rH rI rJ rK rR r| rn rY re r r r7 r< r: r r s 98 O !%
[
?C
!%3% 3% 3% 3% 3% [3%j % % % [% % %r< r create_indexbatch_create_indexc e Zd ZdZdddd$dZd%dZd&dZed'd Z d(d)d Z edddd*d Z
ed+d# Z dS ),
CreateIndexOpz#Represent a create index operation.NFrs r
index_namerx rw rT r 4Sequence[Union[str, TextClause, ColumnElement[Any]]]rs r boolr r r> rz c Z || _ || _ || _ || _ || _ || _ d S r@ )r rw r rs r r )r9 r rw r rs r r s r: r| zCreateIndexOp.__init__i s2 %$ r< DropIndexOpc Z t | S r@ )r
from_indexto_indexr8 s r: rC zCreateIndexOp.reversez s %%dmmoo666r< Tuple[str, Index]c . d| fS )N add_indexr r8 s r: rG zCreateIndexOp.to_diff_tuple} T]]__--r< indexr* c |j J | |j |j j t j | f|j j |j d|j S Nr )tabler r _get_index_expressionsrs r kwargsr[ r s r: r zCreateIndexOp.from_index sd {&&&s J K .u 5 5
;%<
l
r< rb rc c t j | } |j | j | j | j f| j | j d| j }|S r ) r r r r rw r rs r r )r9 rb r idxs r: r zCreateIndexOp.to_index sa ,->??
j O O L
;;
g
r< r r /Sequence[Union[str, TextClause, Function[Any]]]c H | |||f||d|}| | S )a' Issue a "create index" instruction using the current
migration context.
e.g.::
from alembic import op
op.create_index("ik_test", "t1", ["foo", "bar"])
Functional indexes can be produced by using the
:func:`sqlalchemy.sql.expression.text` construct::
from alembic import op
from sqlalchemy import text
op.create_index("ik_test", "t1", [text("lower(foo)")])
:param index_name: name of the index.
:param table_name: name of the owning table.
:param columns: a list consisting of string column names and/or
:func:`~sqlalchemy.sql.expression.text` constructs.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
:param unique: If True, create a unique index.
:param quote:
Force quoting of this column's name on or off, corresponding
to ``True`` or ``False``. When left at its default
of ``None``, the column identifier will be quoted according to
whether the name is case sensitive (identifiers with at least one
upper case character are treated as case sensitive), or if it's a
reserved word. This flag is only needed to force quoting of a
reserved word which is not known by the SQLAlchemy dialect.
:param \**kw: Additional keyword arguments not mentioned above are
dialect specific, and passed in the form
``_``.
See the documentation regarding an individual dialect at
:ref:`dialect_toplevel` for detail on documented arguments.
r r ) r[ r r rw r rs r r r s r: r zCreateIndexOp.create_index sJ n S
G
4:6
MO
$$$r< r r c n | ||j j |fd|j j i|}| | S )zIssue a "create index" instruction using the
current batch migration context.
.. seealso::
:meth:`.Operations.create_index`
rs r )r[ r r r r r s r: r z CreateIndexOp.batch_create_index sW " S O &
?)
$$$r< )r rx rw rT r r rs rx r r r r r> rz )r> r r> r )r r* r> r r@ rb rc r> r* )r r r rx rw rT r r rs rx r r r r r> rz )
r r r rT r r r r r> rz ) rH rI rJ rK r| rC rG rn r r r r r7 r< r: r r d s .- !% "7 7 7 7. . . .
[
?C
!% 9% 9% 9% 9% 9% [9%v % % % [% % %r< r
drop_indexbatch_drop_indexc e Zd ZdZ d!dddd"dZd#dZd$dZed%d Z d!d&dZ e d!ddd'd Z
ed(d Z dS ))r z!Represent a drop index operation.Nrr r Union[quoted_name, str, conv]rw rx rs rt Optional[CreateIndexOp]r r r> rz c L || _ || _ || _ || _ || _ d S r@ )r rw rs rt r )r9 r rw rs rt r s r: r| zDropIndexOp.__init__ s+ %$
r< r c . d| fS )N remove_indexr r8 s r: rG zDropIndexOp.to_diff_tuple
00r< r c Z t | S r@ )r r r r8 s r: rC zDropIndexOp.reverse ''
888r< r r* c |j J | |j f|j j |j j t | d|j S )N)rw rs rt )r
r rs r r r r
s r: r zDropIndexOp.from_index s` {&&&s J
{';%"--e44
l
r< rb rc c t j | } |j | j | j | j r | j j ndgfd| j i| j S )Nxrs ) r r r r rw rt r rs r r s r: r zDropIndexOp.to_index sk ,->??
z O O%)] =DM ! !
;
g
r< r r r rT c D | |f||d|}| | S )aQ Issue a "drop index" instruction using the current
migration context.
e.g.::
drop_index("accounts")
:param index_name: name of the index.
:param table_name: name of the owning table. Some
backends such as Microsoft SQL Server require this.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
:param \**kw: Additional keyword arguments not mentioned above are
dialect specific, and passed in the form
``_``.
See the documentation regarding an individual dialect at
:ref:`dialect_toplevel` for detail on documented arguments.
rw rs r )r[ r r rw rs r r s r: r zDropIndexOp.drop_index& s6 > S
H
6
H
HR
H
H $$$r< r c l | |f|j j |j j d|}| | S )zIssue a "drop index" instruction using the
current batch migration context.
.. seealso::
:meth:`.Operations.drop_index`
r$ r )r[ r r r r s r: r z DropIndexOp.batch_drop_indexH sR S
!1 ?)
$$$r< r@ ) r r rw rx rs rx rt r r r r> rz r )r> r )r r* r> r r ) r r r rT rw rx rs rx r r r> rz )r r r rT r r r> rz ) rH rI rJ rK r| rG rC rn r r r r r7 r< r: r r s
,+
%)
!%,0
1 1 1 19 9 9 9
[
?C
%) % !%
% % % % % [ %B % % % [% % %r< r create_tablec v e Zd ZdZddddd#dZd$dZd%dZeddd&d Z d'd(d Z ed)d" Z
dS )*
CreateTableOpz#Represent a create table operation.NF)rs _namespace_metadata_constraints_includedrw rT r Sequence[SchemaItem]rs rx r) Optional[MetaData]r* r r r r> rz c || _ || _ || _ | di | _ | dd | _ | dd | _ || _ || _ || _ d S )Nr; commentprefixes)
rw r rs popr; r. r/ r r) r* )r9 rw r rs r) r* r s r: r| zCreateTableOp.__init__b su % FF62&& vvi.. z400
#6 %:"""r< DropTableOpc h t | | j S )Nr) )r1
from_tableto_tabler) r8 s r: rC zCreateTableOp.reversev s/ %% MMOO1I &
r< Tuple[str, Table]c . d| fS )N add_tabler5 r8 s r: rG zCreateTableOp.to_diff_tuple{ r r< r3 r
r. c ||j } | |j t |j t |j z f|j |d|j t |j t |j d|j
S )NT)rs r) r* r. r; r/ ) metadatar listr constraintsrs r. dictr; _prefixesr r[ r
r) s r: r4 zCreateTableOp.from_table~ s &"'. s J MMD!2 3 3 3
< 3 #'Mej!!%/**
l
r< rb rc c
t j | } |j | j g| j R | j | j rt | j ng | j | j r| j
ni | j d| j S )N)rs r/ r. r; r* )
r r r
rw r rs r/ r< r. r; copyr* r r s r: r5 zCreateTableOp.to_table s ,->??
z O
\
;,0MAT$-(((rL%)Y6 !!!B"&"<
g
r< r r r- c @ | ||fi |}| | S )aM Issue a "create table" instruction using the current migration
context.
This directive receives an argument list similar to that of the
traditional :class:`sqlalchemy.schema.Table` construct, but without the
metadata::
from sqlalchemy import INTEGER, VARCHAR, NVARCHAR, Column
from alembic import op
op.create_table(
"account",
Column("id", INTEGER, primary_key=True),
Column("name", VARCHAR(50), nullable=False),
Column("description", NVARCHAR(200)),
Column("timestamp", TIMESTAMP, server_default=func.now()),
)
Note that :meth:`.create_table` accepts
:class:`~sqlalchemy.schema.Column`
constructs directly from the SQLAlchemy library. In particular,
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
# specify "DEFAULT NOW" along with the "timestamp" column
op.create_table(
"account",
Column("id", INTEGER, primary_key=True),
Column("timestamp", TIMESTAMP, server_default=func.now()),
)
The function also returns a newly created
:class:`~sqlalchemy.schema.Table` object, corresponding to the table
specification given, which is suitable for
immediate SQL operations, in particular
:meth:`.Operations.bulk_insert`::
from sqlalchemy import INTEGER, VARCHAR, NVARCHAR, Column
from alembic import op
account_table = op.create_table(
"account",
Column("id", INTEGER, primary_key=True),
Column("name", VARCHAR(50), nullable=False),
Column("description", NVARCHAR(200)),
Column("timestamp", TIMESTAMP, server_default=func.now()),
)
op.bulk_insert(
account_table,
[
{"name": "A1", "description": "account 1"},
{"name": "A2", "description": "account 2"},
],
)
:param table_name: Name of the table
:param \*columns: collection of :class:`~sqlalchemy.schema.Column`
objects within
the table, as well as optional :class:`~sqlalchemy.schema.Constraint`
objects
and :class:`~.sqlalchemy.schema.Index` objects.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
:param \**kw: Other keyword arguments are passed to the underlying
:class:`sqlalchemy.schema.Table` object created for the command.
:return: the :class:`~sqlalchemy.schema.Table` object corresponding
to the parameters given.
r )r[ r rw r r r s r: r& zCreateTableOp.create_table s2 j SW
+
+
+
+ $$$r< )rw rT r r+ rs rx r) r, r* r r r r> rz )r> r1 r> r6 )r
r. r) r, r> r( r@ rb rc r> r. )
r r rw rT r r- r r r> r. ) rH rI rJ rK r| rC rG rn r4 r5 r& r7 r< r: r( r( ^ s -- !%26&+; ; ; ; ; ;(
. . . . HL
[
2 ?C
U% U% U% [U% U% U%r< r(
drop_tablec | e Zd ZdZddddd"dZd#dZd$dZeddd%d Z d&d'dZ edd d(d! Z
dS ))r1 z!Represent a drop table operation.Nrs table_kwrt rw rT rs rx rI "Optional[MutableMapping[Any, Any]]rt Optional[CreateTableOp]r> rz c || _ || _ |pi | _ | j dd | _ | j dd | _ | j dd | _ || _ d S )Nr. r; r/ )rw rs rI r0 r. r; r/ rt )r9 rw rs rI rt s r: r| zDropTableOp.__init__ ss % B
}((D99 M%%fd33
))*d;;
r< r6 c . d| fS )N remove_tabler9 r8 s r: rG zDropTableOp.to_diff_tuple r r< r( c Z t | S r@ )r( r4 r5 r8 s r: rC zDropTableOp.reverse r r< r3 r
r. r) r, c | |j |j |j t |j t |j d|j t || S )N)r. r; r/ r3 rH )
r rs r. r> r; r< r? r r( r4 r@ s r: r4 zDropTableOp.from_table s| s J< = UZ(( 1 1 , #--+> .
r< rb rc c L | j r
| j j }ng }t j | } |j | j g|R | j | j r| j ni | j rt | j ng | j | j r | j j ndd| j
}|S )NF)r. r; r/ rs r* )rt r r r r
rw r. r; rB r/ r< rs r* rI )r9 rb cols_and_constraintsr ts r: r5 zDropTableOp.to_table, s = &#'=#8 #% ,->??
J O
!
L%)Y6 !!!B,0MAT$-(((r;}#$-"E"E
m
r< r r r r r c L | ||| }| | dS )a8 Issue a "drop table" instruction using the current
migration context.
e.g.::
drop_table("accounts")
:param table_name: Name of the table
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
:param \**kw: Other keyword arguments are passed to the underlying
:class:`sqlalchemy.schema.Table` object created for the command.
)rs rI Nr )r[ r rw rs r r s r: rF zDropTableOp.drop_tableC s4 4 SFR
8
8
8" r< )
rw rT rs rx rI rJ rt rK r> rz rD )r> r( )r
r. r) r, r> r1 r@ rE )
r r rw rT rs rx r r r> rz ) rH rI rJ rK r| rG rC rn r4 r5 rF r7 r< r: r1 r1 s ++ !%7;,0
! ! ! ! ! ! 1 1 1 19 9 9 9 HL
[
$ ?C . !% [ r< r1 c e Zd ZdZddd d
ZdS ) AlterTableOpz#Represent an alter table operation.Nr rw rT rs rx r> rz c " || _ || _ d S r@ r$ )r9 rw rs s r: r| zAlterTableOp.__init__d s % r< )rw rT rs rx r> rz )rH rI rJ rK r| r7 r< r: rV rV a s= -- !% r< rV rename_tablec H e Zd ZdZddd fd Zedddd Z xZS )
RenameTableOpz#Represent a rename table operation.Nr old_table_namerT new_table_namers rx r> rz c \ t || || _ d S Nr )superr| r\ )r9 r[ r\ rs __class__s r: r| zRenameTableOp.__init__r s0 777 ,r< r r c H | ||| }| | S )al Emit an ALTER TABLE to rename a table.
:param old_table_name: old name.
:param new_table_name: new name.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
r r )r[ r r[ r\ rs r s r: rX zRenameTableOp.rename_table| s. & S
?
?
? $$$r< )r[ rT r\ rT rs rx r> rz )
r r r[ rT r\ rT rs rx r> rz )rH rI rJ rK r| rn rX
__classcell__r` s @r: rZ rZ n s -- !% - - - - - - - - !%
% % % % % [% % % % %r< rZ create_table_commentbatch_create_table_commentc t e Zd ZdZddddd Zeddd
dd Zedddd Zd ZddZ d Z
dS )CreateTableCommentOpz)Represent a COMMENT ON `table` operation.Nrs existing_commentrw rT r. rx rs ri r> rz c > || _ || _ || _ || _ d S r@ )rw r. ri rs )r9 rw r. rs ri s r: r| z CreateTableCommentOp.__init__ s% % 0 r< ri rs r r c J | |||| }| | S )ar Emit a COMMENT ON operation to set the comment for a table.
.. versionadded:: 1.0.6
:param table_name: string name of the target table.
:param comment: string value of the comment being registered against
the specified table.
:param existing_comment: String value of a comment
already registered on the specified table, used within autogenerate
so that the operation is reversible, but not required for direct
use.
.. seealso::
:meth:`.Operations.drop_table_comment`
:paramref:`.Operations.alter_column.comment`
rk r )r[ r rw r. ri rs r s r: rd z)CreateTableCommentOp.create_table_comment s< < S -
$$$r< ri r c r | |j j |||j j }| | S )a Emit a COMMENT ON operation to set the comment for a table
using the current batch migration context.
.. versionadded:: 1.6.0
:param comment: string value of the comment being registered against
the specified table.
:param existing_comment: String value of a comment
already registered on the specified table, used within autogenerate
so that the operation is reversible, but not required for direct
use.
rk r )r[ r r. ri r s r: re z/CreateTableCommentOp.batch_create_table_comment sF , S O & - ?)
$$$r< c | j !t | j | j | j S t | j | j | j | j S )2Reverses the COMMENT ON operation against a table.Nrk )ri DropTableCommentOprw r. rs rg r8 s r: rC z CreateTableCommentOp.reverse s_ (%!% {
(%!% {
r< c x t j | }| | j | j | j S )N)rs r. )r r r
rw rs r. r s r: r5 z CreateTableCommentOp.to_table s= ,->??
ODK
r< c : d| | j fS )Nadd_table_comment)r5 ri r8 s r: rG z"CreateTableCommentOp.to_diff_tuple s #T]]__d6KLLr< )
rw rT r. rx rs rx ri rx r> rz ) r r rw rT r. rx ri rx rs rx r> rz )r r r. rx ri rx r> rz r@ ) rH rI rJ rK r| rn rd re rC r5 rG r7 r< r: rg rg s
43 !%*.
+/ $#% #% #% #% #% [#%J +/ % % % % % [%:
M M M M Mr< rg drop_table_commentbatch_drop_table_commentc t e Zd ZdZddddd Zeddd dd Zedddd Zd ZddZ d Z
dS )rq z:Represent an operation to remove the comment from a table.Nrh rw rT rs rx ri r> rz c 0 || _ || _ || _ d S r@ )rw ri rs )r9 rw rs ri s r: r| zDropTableCommentOp.__init__
s % 0 r< rk r r c H | ||| }| | S )a Issue a "drop table comment" operation to
remove an existing comment set on a table.
.. versionadded:: 1.0.6
:param table_name: string name of the target table.
:param existing_comment: An optional string value of a comment already
registered on the specified table.
.. seealso::
:meth:`.Operations.create_table_comment`
:paramref:`.Operations.alter_column.comment`
rk r )r[ r rw ri rs r s r: ru z%DropTableCommentOp.drop_table_comment s/ 4 S.>v
N
N
N $$$r< rm r c p | |j j ||j j }| | S )a6 Issue a "drop table comment" operation to
remove an existing comment set on a table using the current
batch operations context.
.. versionadded:: 1.6.0
:param existing_comment: An optional string value of a comment already
registered on the specified table.
rk r )r[ r ri r s r: rv z+DropTableCommentOp.batch_drop_table_comment5 sC $ S O & - ?)
$$$r< c D t | j | j | j S )rp r )rg rw ri rs r8 s r: rC zDropTableCommentOp.reverseN s' # OT 24;
r< c l t j | }| | j | j S r^ )r r r
rw rs r s r: r5 zDropTableCommentOp.to_tableT s0 ,->??
DDDr< c . d| fS )Nremove_table_commentr9 r8 s r: rG z DropTableCommentOp.to_diff_tupleY s &
88r< )rw rT rs rx ri rx r> rz )
r r rw rT ri rx rs rx r> rz )r r ri rx r> rz r@ ) rH rI rJ rK r| rn ru rv rC r5 rG r7 r< r: rq rq s
ED !%*. +/ $
% % % % % [%8
+/ % % % % % [%0
E E E E
9 9 9 9 9r< rq alter_columnbatch_alter_columnc
e Zd ZdZddddddddddd
d/ fdZd0dZd1d Zd2d Zeddddddddddd
d3d) Z edddddddddddd* d4d. Z
xZ S )5
AlterColumnOpz$Represent an alter column operation.NF)
rs
existing_typeexisting_server_defaultexisting_nullableri modify_nullablemodify_commentmodify_server_default modify_name modify_typerw rT column_namers rx r
Optional[Any]r r r r ri r r $Optional[Union[str, Literal[False]]]r r r r r> rz c
t || || _ || _ || _ || _ || _ || _ | | _ |
| _ | | _
| | _ |
| _ d S r^ )
r_ r| r r r r ri r r r r r r )r9 rw r rs r r r ri r r r r r r r` s r: r| zAlterColumnOp.__init__b s} " F333& *'>$!2 0 . ,%:"&&r< c
< g }| j | j | j }}}| j 9| d|||| j | j | j d| j | j f | j 9| d|||| j | j | j d| j | j f | j
dur9| d|||| j | j | j d| j | j
f | j dur9| d|||| j | j | j d | j | j f |S )
Nr )r r ri r )r r ri Fmodify_default)r r ri r )r r r ) rs rw r r appendr r ri r r r r )r9 col_diffrs tnamecnames r: rG zAlterColumnOp.to_diff_tuple s #{DOT=Mu ' OO!-1-C 8,0,A &$
$ + OO%)-); 8,0,A *(
$ %U 2 2 OO$-1-C)-);,0,A
0.
e + + OO$-1-C)-); 8 )'
$ r< r c | j d up| j dup| j d up| j du}|rdS | j D ]}| d r dS dS )NFTmodify_)r r r r r
startswith)r9 hc1r s r: has_changeszAlterColumnOp.has_changes s ,
0)6
0 t+
0 "%/ 4' B}}Y''
tt
5r< c | j }| j |d< | j |d< | j |d< | j |d< | j
| j |d< | j
| j |d< | j dur
| j |d< | j dur
| j |d < d
d |D D }|D ]-}d |z |v r$|d
|z }|d |z |d
|z < ||d |z < . | j
| j | j fd| j
i|S )Nr r r ri r r Fr r c < h | ]}|| d S )r )group)r ms r: z(AlterColumnOp.reverse.. s8
GGAJJ
r< c 8 g | ]}t j d | S )z^(?:existing_|modify_)(.+)$)rer )r ks r: r z)AlterColumnOp.reverse.. s% NNNabh =qAANNNr< z modify_%sz existing_%srs )r rB r r r ri r r r r r` rw r rs )r9 r all_keysr swaps r: rC zAlterColumnOp.reverse sf
W\\^^ " 0?"&"8 (,(D $%!%!6 ' $ 0B} +$($8B ! %U 2 2*.*DB& ' e + +#'#6B
NN2NNN
+ +AQ"$$-!+,(*;?(;=1$%&*;?# t~ OT -
6:k
EG
r< )
nullabler. server_defaultnew_column_namerS r r r ri rs r r r r. r r rS -Optional[Union[TypeEngine, Type[TypeEngine]]].Optional[Union[str, bool, Identity, Computed]]c
V | ||f|
| |
| | |||||d
|}| | S )a Issue an "alter column" instruction using the
current migration context.
Generally, only that aspect of the column which
is being changed, i.e. name, type, nullability,
default, needs to be specified. Multiple changes
can also be specified at once and the backend should
"do the right thing", emitting each change either
separately or together as the backend allows.
MySQL has special requirements here, since MySQL
cannot ALTER a column without a full specification.
When producing MySQL-compatible migration files,
it is recommended that the ``existing_type``,
``existing_server_default``, and ``existing_nullable``
parameters be present, if not being altered.
Type changes which are against the SQLAlchemy
"schema" types :class:`~sqlalchemy.types.Boolean`
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_type`` argument is
used in this case to identify and remove a previous
constraint that was bound to the type object.
:param table_name: string name of the target table.
: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
SQL expression, :func:`~sqlalchemy.sql.expression.text`,
or :class:`~sqlalchemy.schema.DefaultClause` to indicate
an alteration to the column's default value.
Set to ``None`` to have the default removed.
:param comment: optional string text of a new comment to add to the
column.
.. versionadded:: 1.0.6
:param new_column_name: Optional; specify a string name here to
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`),
the constraint is also generated.
:param autoincrement: set the ``AUTO_INCREMENT`` flag of the column;
currently understood by the MySQL dialect.
: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
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
SQLlchemy "schema" type which 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
removes the default.
:param existing_nullable: Optional; the existing nullability
of the column. Required on MySQL if the existing nullability
is not being changed; else MySQL sets this to NULL.
:param existing_autoincrement: Optional; the existing autoincrement
of the column. Used for MySQL's system of altering a column
that specifies ``AUTO_INCREMENT``.
:param existing_comment: string text of the existing comment on the
column to be maintained. Required on MySQL if the existing comment
on the column is not being changed.
.. versionadded:: 1.0.6
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
:param postgresql_using: String argument which will indicate a
SQL expression to render within the Postgresql-specific USING clause
within ALTER COLUMN. This string is taken directly as raw SQL which
must explicitly include any necessary quoting or escaping of tokens
within the expression.
)
rs r r r ri r r r r r r )r[ r rw r r r. r r rS r r r ri rs r alts r: r zAlterColumnOp.alter_column sf \ c
'$; / -' "0 $"
%%%r< ) r r. r r rS r r r ri
insert_before insert_afterr r r c | |j j |f|j j || |
| |||||| |
d |}| | S )av Issue an "alter column" instruction using the current
batch migration context.
Parameters are the same as that of :meth:`.Operations.alter_column`,
as well as the following option(s):
:param insert_before: String name of an existing column which this
column should be placed before, when creating the new table.
.. versionadded:: 1.4.0
:param insert_after: String name of an existing column which this
column should be placed after, when creating the new table. If
both :paramref:`.BatchOperations.alter_column.insert_before`
and :paramref:`.BatchOperations.alter_column.insert_after` are
omitted, the column is inserted after the last existing column
in the table.
.. versionadded:: 1.4.0
.. seealso::
:meth:`.Operations.alter_column`
) rs r r r ri r r r r r r r r )r[ r r r r. r r rS r r r ri r r r r s r: r z AlterColumnOp.batch_alter_column sv ^ c O &
?)'$; / -' "0 $"'%
$ %%%r< ) rw rT r rT rs rx r r r r r r ri rx r r r r r r r rx r r r r r> rz r> r r> r )r> r ) r r rw rT r rT r r r. r r r r rx rS r r r r r r r ri rx rs rx r r r> rz ) r r r rT r r r. r r r r rx rS r r r r r r r ri rx r rx r rx r r r> rz ) rH rI rJ rK r| rG r rC rn r r rb rc s @r: r r ] s] /. !%'+',,0*.*.?D%*%)%) rz c j t || || _ || _ d S r^ )r_ r| r r )r9 rw r rs r r` s r: r| zAddColumnOp.__init__ s4 F333 r< DropColumnOpc X t | j | j | j S r@ )r from_column_and_tablenamers rw r r8 s r: rC zAddColumnOp.reverse s' 55 K $+
r< +Tuple[str, Optional[str], str, Column[Any]]c , d| j | j | j fS )Nr )rs rw r r8 s r: rG zAddColumnOp.to_diff_tuple s dk4?DKHHr< r% c | j S r@ )r r8 s r: to_columnzAddColumnOp.to_column s
{r< colc F | |j j ||j j S r^ )r
r rs )r[ r s r: from_columnzAddColumnOp.from_column s" s39>3sy/?@@@@r< r c | ||| S r^ r7 r[ rs r r s r: r z%AddColumnOp.from_column_and_tablename s s5#f----r< r r c H | ||| }| | S )a
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", Column("name", String()))
The :meth:`.Operations.add_column` method typically corresponds
to the SQL command "ALTER TABLE... ADD COLUMN". Within the scope
of this command, the column's name, datatype, nullability,
and optional server-generated defaults may be indicated.
.. note::
With the exception of NOT NULL constraints or single-column FOREIGN
KEY constraints, other kinds of constraints such as PRIMARY KEY,
UNIQUE or CHECK constraints **cannot** be generated using this
method; for these constraints, refer to operations such as
:meth:`.Operations.create_primary_key` and
:meth:`.Operations.create_check_constraint`. In particular, the
following :class:`~sqlalchemy.schema.Column` parameters are
**ignored**:
* :paramref:`~sqlalchemy.schema.Column.primary_key` - SQL databases
typically do not support an ALTER operation that can add
individual columns one at a time to an existing primary key
constraint, therefore it's less ambiguous to use the
:meth:`.Operations.create_primary_key` method, which assumes no
existing primary key constraint is present.
* :paramref:`~sqlalchemy.schema.Column.unique` - use the
:meth:`.Operations.create_unique_constraint` method
* :paramref:`~sqlalchemy.schema.Column.index` - use the
:meth:`.Operations.create_index` method
The provided :class:`~sqlalchemy.schema.Column` object may include a
:class:`~sqlalchemy.schema.ForeignKey` constraint directive,
referencing a remote table name. For this specific type of constraint,
Alembic will automatically emit a second ALTER statement in order to
add the single-column FOREIGN KEY constraint separately::
from alembic import op
from sqlalchemy import Column, INTEGER, ForeignKey
op.add_column(
"organization",
Column("account_id", INTEGER, ForeignKey("accounts.id")),
)
The column argument passed to :meth:`.Operations.add_column` is a
:class:`~sqlalchemy.schema.Column` construct, used in the same way it's
used in SQLAlchemy. In particular, values or functions to be indicated
as producing the column's default value 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
# specify "DEFAULT NOW" along with the column add
op.add_column(
"account",
Column("timestamp", TIMESTAMP, server_default=func.now()),
)
:param table_name: String name of the parent table.
:param column: a :class:`sqlalchemy.schema.Column` object
representing the new column.
:param schema: Optional schema name to operate within. To control
quoting of the schema outside of the default behavior, use
the SQLAlchemy construct
:class:`~sqlalchemy.sql.elements.quoted_name`.
r r )r[ r rw r rs r s r: r zAddColumnOp.add_column s/ n SVF
3
3
3 $$$r< )r r r r r c i }|r||d< |r||d< | |j j |fd|j j i|}| | S )zIssue an "add column" instruction using the current
batch migration context.
.. seealso::
:meth:`.Operations.add_column`
r r rs r )r[ r r r r r r s r: r z AddColumnOp.batch_add_columnI s} $ 0"/B .!-B~
S O &
?)
$$$r< )
rw rT r r rs rx r r r> rz )r> r r> r )r> r% )r r% r> r )rs rx r rT r r r> r )
r r rw rT r r rs rx r> rz )
r r r r r rx r rx r> rz )rH rI rJ rK r| rC rG r rn r r r r rb rc s @r: r r s@ -, !%
I I I I
A A A [A . . . [. !%
W% W% W% W% W% [W%r (,&*
% % % % % [ % % % % %r< r drop_columnbatch_drop_columnc e Zd ZdZdddd" fdZd#dZd$dZed%d Z d&d'dZ edd d(d Z
ed)d! Z xZ S )*r z"Represent a drop column operation.Nrr rw rT r rs rx rt Optional[AddColumnOp]r r r> rz c x t || || _ || _ || _ d S r^ )r_ r| r r rt )r9 rw r rs rt r r` s r: r| zDropColumnOp.__init__o s< F333&
r< r c F d| j | j | fS )N
remove_column)rs rw r r8 s r: rG zDropColumnOp.to_diff_tuple} s(
K O NN
r< r c | j t d t | j | j | j j S )Nz;operation is not reversible; original column is not present)rt r r r rs rw r r8 s r: rC zDropColumnOp.reverse sK = 1
44 K $-*>
r< r r r c
^ | ||j |t ||| S )Nrr )r r r r s r: r z&DropColumnOp.from_column_and_tablename s= s H ::65#NN
r< rb rc r% c | j | j j S t j | }| | j t
S r@ )rt r r r r r r s r: r zDropColumnOp.to_column sA = $=' ' ,->??
!18<<
>
>2
>
> $$$r< r c l | |j j |fd|j j i|}| | S )zIssue a "drop column" instruction using the current
batch migration context.
.. seealso::
:meth:`.Operations.drop_column`
rs r )r[ r r r r s r: r z DropColumnOp.batch_drop_column sT S O &
?)
$$$r< ) rw rT r rT rs rx rt r r r r> rz r )r> r )rs rx r rT r r r> r r@ )rb rc r> r% ) r r rw rT r rT rs rx r r r> rz )r r r rT r r r> rz )
rH rI rJ rK r| rG rC rn r r r r rb rc s @r: r r j s -, !%*.
! ! ! ! ! ! ! !
[
?C= = = = = !%
/% /% /% /% /% [/%b % % % [% % % % %r< r bulk_insertc > e Zd ZdZdddd Zedddd ZdS ) BulkInsertOpz"Represent a bulk insert operation.T multiinsertr
Union[Table, TableClause]rows
List[dict]r r r> rz c 0 || _ || _ || _ d S r@ )r
r r )r9 r
r r s r: r| zBulkInsertOp.__init__ s
&r< r r c L | ||| }| | dS )ax 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
statement.
e.g.::
from alembic import op
from datetime import date
from sqlalchemy.sql import table, column
from sqlalchemy import String, Integer, Date
# Create an ad-hoc table to use for the insert statement.
accounts_table = table(
"account",
column("id", Integer),
column("name", String),
column("create_date", Date),
)
op.bulk_insert(
accounts_table,
[
{
"id": 1,
"name": "John Smith",
"create_date": date(2010, 10, 5),
},
{
"id": 2,
"name": "Ed Williams",
"create_date": date(2007, 5, 27),
},
{
"id": 3,
"name": "Wendy Jones",
"create_date": date(2008, 8, 15),
},
],
)
When using --sql mode, some datatypes may not render inline
automatically, such as dates and other special types. When this
issue is present, :meth:`.Operations.inline_literal` may be used::
op.bulk_insert(
accounts_table,
[
{
"id": 1,
"name": "John Smith",
"create_date": op.inline_literal("2010-10-05"),
},
{
"id": 2,
"name": "Ed Williams",
"create_date": op.inline_literal("2007-05-27"),
},
{
"id": 3,
"name": "Wendy Jones",
"create_date": op.inline_literal("2008-08-15"),
},
],
multiinsert=False,
)
When using :meth:`.Operations.inline_literal` in conjunction with
:meth:`.Operations.bulk_insert`, in order for the statement to work
in "online" (e.g. non --sql) mode, the
:paramref:`~.Operations.bulk_insert.multiinsert`
flag should be set to ``False``, which will have the effect of
individual INSERT statements being emitted to the database, each
with a distinct VALUES clause, so that the "inline" values can
still be rendered, rather than attempting to pass the values
as bound parameters.
:param table: a table object which represents the target of the INSERT.
:param rows: a list of dictionaries indicating rows.
:param multiinsert: when at its default of True and --sql mode is not
enabled, the INSERT statement will be executed using
"executemany()" style, where all elements in the list of
dictionaries are passed as bound parameters in a single
list. Setting this to False results in individual INSERT
statements being emitted per parameter set, and is needed
in those cases where non-literal values are present in the
parameter sets.
r Nr )r[ r r
r r r s r: r zBulkInsertOp.bulk_insert s5 R S+
6
6
6" r< N)r
r r r r r r> rz )
r r r
r r r r r r> rz )rH rI rJ rK r| rn r r7 r< r: r r st ,, ! ' ' ' ' ' ' !
i i i i i [i i i r< r execute
batch_executec \ e Zd ZdZdddd
Zedddd Zedddd ZdS ) ExecuteSQLOpz#Represent an execute SQL operation.Nexecution_optionsr &Union[Update, str, Insert, TextClause]r Optional[dict[str, Any]]r> rz c " || _ || _ d S r@ )r r )r9 r r s r: r| zExecuteSQLOp.__init__p s !2 r< r r Union[str, TextClause, Update]c F | || }| | S )a
Execute the given SQL using the current migration context.
The given SQL can be a plain string, e.g.::
op.execute("INSERT INTO table (foo) VALUES ('some value')")
Or it can be any kind of Core SQL Expression construct, such as
below where we use an update construct::
from sqlalchemy.sql import table, column
from sqlalchemy import String
from alembic import op
account = table("account", column("name", String))
op.execute(
account.update()
.where(account.c.name == op.inline_literal("account 1"))
.values({"name": op.inline_literal("account 2")})
)
Above, we made use of 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
:class:`~sqlalchemy.schema.Table` construct of course works perfectly
fine as well, though note it's a recommended practice to at least
ensure the definition of a table is self-contained within the migration
script, rather than imported from a module that may break compatibility
with older migrations.
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. Additionally, parameterized
statements are discouraged here, as they *will not work* in offline
mode. Above, we use :meth:`.inline_literal` where parameters are
to be used.
For full interaction with a connected database where parameters can
also be used normally, use the "bind" available from the context::
from alembic import op
connection = op.get_bind()
connection.execute(
account.update()
.where(account.c.name == "account 1")
.values({"name": "account 2"})
)
Additionally, when passing the statement as a plain string, it is first
coerceed into a :func:`sqlalchemy.sql.expression.text` construct
before being passed along. In the less likely case that the
literal SQL string contains a colon, it must be escaped with a
backslash, as::
op.execute(r"INSERT INTO table (foo) VALUES ('\:colon_value')")
:param sqltext: Any legal SQLAlchemy expression, including:
* 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`,
or :func:`sqlalchemy.sql.expression.delete` construct.
* Any "executable" described in SQLAlchemy Core documentation,
noting that no result set is returned.
.. note:: when passing a plain string, the statement is coerced into
a :func:`sqlalchemy.sql.expression.text` construct. This construct
considers symbols with colons, e.g. ``:foo`` to be bound parameters.
To avoid this, ensure that colon symbols are escaped, e.g.
``\:foo``.
:param execution_options: Optional dictionary of
execution options, will be passed to
:meth:`sqlalchemy.engine.Connection.execution_options`.
r r )r[ r r r r s r: r zExecuteSQLOp.executey s. r S,=
>
>
> $$$r< c 2 | ||| S )zExecute the given SQL using the current migration context.
.. seealso::
:meth:`.Operations.execute`
r )r )r[ r r r s r: r zExecuteSQLOp.batch_execute s' {{ 3D
r< )r r r r r> rz )r r r r r r r> rz )rH rI rJ rK r| rn r r r7 r< r: r r k s .- 7; 3 3 3 3 3 3 7; Y% Y% Y% Y% Y% [Y%v 7;
[
r< r c D e Zd ZdZdddZdd Zdd Zedd ZdS ) OpContainerz-Represent a sequence of operations operation.r7 opsSequence[MigrateOperation]r> rz c . t | | _ d S r@ )r< r )r9 r s r: r| zOpContainer.__init__ s 99r< r c | j S r@ r r8 s r: is_emptyzOpContainer.is_empty s 8|r< r c P t t | S r@ )r< r
_ops_as_diffsr8 s r: as_diffszOpContainer.as_diffs s K--d33444r<
migrationsIterator[Tuple[Any, ...]]c # K |j D ]R}t |d r*| t d| E d {V <| V Sd S )Nr r )r hasattrr r rG )r[ r r s r: r zOpContainer._ops_as_diffs s . ) )Br5!!
) ,,T--D-DEEEEEEEEEE&&(((((( ) )r< N)r7 )r r r> rz r r )r r r> r ) rH rI rJ rK r| r r rn r r7 r< r: r r s{ 77 5 5 5 5 ) ) ) [) ) )r< r c 2 e Zd ZdZddd fd Zdd
Z xZS )ModifyTableOpszCContains a sequence of operations that all apply to a single Table.Nr rw rT r r rs rx r> rz c f t | || _ || _ d S r@ )r_ r| rw rs )r9 rw r rs r` s r: r| zModifyTableOps.__init__
s/ $ r< c t | j t t d | j D | j S )Nc 6 g | ]}| S r7 rC r r s r: r z*ModifyTableOps.reverse..
? ? ?rzz|| ? ? ?r< )r rs )r rw r< reversedr rs r8 s r: rC zModifyTableOps.reverse
sG OX ? ?dh ? ? ?@@AA;
r< )rw rT r r rs rx r> rz )r> r rH rI rJ rK r| rC rb rc s @r: r r
sf MM !%
r< r c : e Zd ZdZ dd fd
Zdd
ZddZ xZS )
UpgradeOpszcontains a sequence of operations that would apply to the
'upgrade' stream of a script.
.. seealso::
:ref:`customizing_revision`
r7 upgradesr r
upgrade_tokenrT r> rz c Z t | || _ d S Nr )r_ r| r )r9 r r r` s r: r| zUpgradeOps.__init__
s.
S!!! *r<
downgrade_ops DowngradeOpsc p t t d | j D |j d d < |S )Nc 6 g | ]}| S r7 r r s r: r z+UpgradeOps.reverse_into..*
s 666rbjjll666r< )r< r r )r9 r s r: reverse_intozUpgradeOps.reverse_into(
sA # 66TX666 7 7
!!! r< c H | t g S r )r r r8 s r: rC zUpgradeOps.reverse.
s! "!5!5!5666r< )r7 r )r r r rT r> rz )r r r> r )r> r )rH rI rJ rK r| r rC rb rc s @r: r r
s| +- '+ + + + + + + 7 7 7 7 7 7 7 7r< r c 0 e Zd ZdZ d d
fd
Zd Z xZS )r zcontains a sequence of operations that would apply to the
'downgrade' stream of a script.
.. seealso::
:ref:`customizing_revision`
r7
downgradesr r downgrade_tokenrT r> rz c Z t | || _ d S r )r_ r| r )r9 r r r` s r: r| zDowngradeOps.__init__<
s.
S!!! . r< c t t t t d | j D S )Nc 6 g | ]}| S r7 r r s r: r z(DowngradeOps.reverse..F
r r< r )r r< r r r8 s r: rC zDowngradeOps.reverseD
s= X ? ?dh ? ? ?@@AA
r< )r7 r )r r r rT r> rz r rc s @r: r r 2
sc +- +/ / / / / / /
r< r c e Zd ZU dZded< d e ddddddd dZed Zej d Zed Z
e
j d Z
ed!d Z ed"d Z dS )#MigrationScriptap represents a migration script.
E.g. when autogenerate encounters this object, this corresponds to the
production of an actual script file.
A normal :class:`.MigrationScript` object would contain a single
:class:`.UpgradeOps` and a single :class:`.DowngradeOps` directive.
These are accessible via the ``.upgrade_ops`` and ``.downgrade_ops``
attributes.
In the case of an autogenerate operation that runs multiple times,
such as the multiple database example in the "multidb" template,
the ``.upgrade_ops`` and ``.downgrade_ops`` attributes are disabled,
and instead these objects should be accessed via the ``.upgrade_ops_list``
and ``.downgrade_ops_list`` list-based attributes. These latter
attributes are always available at the very least as single-element lists.
.. seealso::
:ref:`customizing_revision`
r
_needs_renderN)messageimportsheadsplice branch_label version_path
depends_onrev_idrx upgrade_opsr r r r r Set[str]r r r r r #Optional[Union[str, Sequence[str]]]r> rz c || _ || _ || _ || _ || _ || _ | | _ |
| _ || _ || _ d S r@ )
r r r r r r r r r r ) r9 r r r r r r r r r r s r: r| zMigrationScript.__init__d
sT ( ($& *r< c | t | j dk rt d | j sdS | j d S )zzAn instance of :class:`.UpgradeOps`.
.. seealso::
:attr:`.MigrationScript.upgrade_ops_list`
r zrThis MigrationScript instance has a multiple-entry list for UpgradeOps; please use the upgrade_ops_list attribute.Nr )len _upgrade_opsr r8 s r: r zMigrationScript.upgrade_ops}
sQ t ! !A % % .
" (4$Q' 'r< c z t j | | _ | j D ]}t |t sJ d S r@ )r to_listr$
isinstancer )r9 r elems r: r zMigrationScript.upgrade_ops
sI L 5 5% 0 0D dJ// / // / 0 0r< c | t | j dk rt d | j sdS | j d S )z~An instance of :class:`.DowngradeOps`.
.. seealso::
:attr:`.MigrationScript.downgrade_ops_list`
r zvThis MigrationScript instance has a multiple-entry list for DowngradeOps; please use the downgrade_ops_list attribute.Nr )r# _downgrade_opsr r8 s r: r z MigrationScript.downgrade_ops
sQ t" # #a ' ' 0
$ *4&q) )r< c z t j | | _ | j D ]}t |t sJ d S r@ )r r& r* r' r )r9 r r( s r: r z MigrationScript.downgrade_ops
sI "l= 9 9' 2 2D dL11 1 11 1 2 2r< List[UpgradeOps]c | j S )zA list of :class:`.UpgradeOps` instances.
This is used in place of the :attr:`.MigrationScript.upgrade_ops`
attribute when dealing with a revision operation that does
multiple autogenerate passes.
)r$ r8 s r: upgrade_ops_listz MigrationScript.upgrade_ops_list
s
r< List[DowngradeOps]c | j S )zA list of :class:`.DowngradeOps` instances.
This is used in place of the :attr:`.MigrationScript.downgrade_ops`
attribute when dealing with a revision operation that does
multiple autogenerate passes.
)r* r8 s r: downgrade_ops_listz"MigrationScript.downgrade_ops_list
s
""r< )r rx r r r r r rx r r r rx r r r rx r rx r r r> rz )r> r, )r> r/ )
rH rI rJ rK rN setr| rm r setterr r. r1 r7 r< r: r r J
s . "!!! "& CEE "!%&*&*:>+ + + + + +2 ( ( X($ 0 0 0
* * X*$ 2 2 2
! ! ! X! # # # X# # #r< r )Y
__future__r abcr r typingr r r r r r
r r r
r r r r r sqlalchemy.typesr r baser r r r r sqlalchemy.sql.dmlr r sqlalchemy.sql.elementsr r r r! r" sqlalchemy.sql.functionsr# sqlalchemy.sql.schemar$ r% r& r' r( r) r* r+ r, r- r. r/ sqlalchemy.sql.selectabler0 sqlalchemy.sql.type_apir1 autogenerate.rewriterr2 runtime.migrationr3 r5 rP register_operationrf r] r r r r r r r( r1 rV rZ rg rq r r r r r r r r r r r7 r< r: rC s/ " " " " " " ! ! ! ! ! ! % % % % % % ! ! ! ! ! ! 5 ))))))))))))888888555555,,,,,,333333222222111111555555,,,,,,......000000::::::......++++++......::::::000000++++++666666555555222222000000444444 " " " " " " " "@!8 !8 !8 !8 !8& !8 !8 !8H 011# #$57NOOs% s% s% s% s%' s% s% PO 21s%l 344# #4 (()ABBt% t% t% t% t% t% t% CB 54
t%n 9::# # @ (()<==@% @% @% @% @% @% @% >= ;:
@%F 344# #4 (()ABBY% Y% Y% Y% Y% Y% Y% CB 54
Y%x 899# # > (();<<(()KLL(()BCC% % % % %o % % DC ML =< :9%D ~..# #N4HIII% I% I% I% I%$ I% I% JI /.I%X |,,# #L2DEEg% g% g% g% g%" g% g% FE -,g%T ~..^% ^% ^% ^% ^%$ ^% ^% /.^%B |,,] ] ] ] ] " ] ] -,] @
#
~..!% !% !% !% !%L !% !% /.!%H 566# # 8 lM lM lM lM lM< lM lM 76lM^ 344# #4 P9 P9 P9 P9 P9 P9 P9 54P9f ~..# #N4HIIb& b& b& b& b&L b& b& JI /.b&J |,,# #L2DEEa% a% a% a% a%, a% a% FE -,a%H }--# #M3FGG@% @% @% @% @%< @% @% HG .-@%F }--x x x x x # x x .-x v y))# #I??y
y
y
y
y
# y
y
@? *)y
x) ) ) ) )" ) ) ).
[
,7 7 7 7 7 7 7 78
;
0y# y# y# y# y#& y# y# y# y# y#r<