gr  SSKJr SSKJr SSKrSSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr \(aSSKJr SSK J!r! SSK"J#r# SSK"J$r$ SS K"J%r% SS!K"J&r& SS"K'J(r( SS#K)J*r* SS$K)J+r+ SS%K)J,r, SS&K)J-r- SS'K)J.r. SS(K)J/r/ SS)K)J0r0 SS*K)J1r1 SS+K)J2r2 SS,K)J3r3 SS-K)J4r4 SS.K)J5r5 SS/K6J7r7 SS0K8J9r9 SS1K:J;r; SS2KJ?r? \"S4\S59r@\"S6S7S59rA"S8S95rB"S:S7\B5rC\R"S;5\R"S;S<5"S=S>\B555rE\R"S?5\R"S?S@5\CRSA5"SBSC\C5555rG\R"SD5\R"SDSE5\CRSF5"SGSH\C5555rH\R"SI5\R"SISJ5\CRSK5"SLSM\C5555rI\R"SN5\R"SNSO5\CRSP5\CRSQ5\CRSR5"SSST\C555555rJ\R"SU5\R"SUSV5"SWSX\B555rK\R"SY5\R"SYSZ5"S[S\\B555rL\R"S]5"S^S_\B55rM\R"S`5"SaSb\B55rN"ScSd\B5rO\R"Se5"SfSg\O55rP\R"Sh5\R"ShSi5"SjSk\O555rQ\R"Sl5\R"SlSm5"SnSo\O555rR\R"Sp5\R"SpSq5"SrSs\O555rS\R"St5\R"StSu5"SvSw\O555rT\R"Sx5\R"SxSy5"SzS{\O555rU\R"S|5"S}S~\B55rV\R"S5\R"SS5"SS\B555rW"SS\B5rX"SS\X5rY"SS\X5rZ"SS\X5r["SS\B5r\g)) annotations)abstractmethodN)Any)Callable)cast)Dict) FrozenSet)Iterator)List)MutableMapping)Optional)Sequence)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union)NULLTYPE) schemaobj)BatchOperations) Operations)util) sqla_compat)Literal) Executable) ColumnElement)conv) quoted_name) TextClause)Function)CheckConstraint)Column)Computed) Constraint)ForeignKeyConstraint)Identity)Index)MetaData)PrimaryKeyConstraint) SchemaItem)Table)UniqueConstraint) TableClause) TypeEngine)Rewriter)MigrationContext) _RevIdType_T)bound_ACAddConstraintOpcn\rSrSr%Sr\R S Sj5r\"5r S\ S'S Sjr S Sjr Sr g ) MigrateOperation>zbase 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` c0$)zqA dictionary that may be used to store arbitrary information along with this :class:`.MigrateOperation` object. selfs ^/Users/Alptekin/Desktop/izin_takip/venv/lib/python3.13/site-packages/alembic/operations/ops.pyinfoMigrateOperation.infoMs  zFrozenSet[Rewriter] _mutationsc[eNNotImplementedErrorr>s r@reverseMigrateOperation.reverseW!!rCc[erFrGr>s r@ to_diff_tupleMigrateOperation.to_diff_tupleZrKrCr=N)returnzDict[Any, Any])rOr:rOzTuple[Any, ...])__name__ __module__ __qualname____firstlineno____doc__rmemoized_propertyrA frozensetrD__annotations__rIrM__static_attributes__r=rCr@r:r:>s:  '0kJ#1""rCr:c\rSrSrSr\R "5r\S Sj5r \ S Sj5r \ S Sj5r \ SSSjj5rSSjrSS jrS rg)r8^z&Represent an add constraint operation.c[5erFrGr>s r@constraint_typeAddConstraintOp.constraint_typecs !##rCc^^SUU4SjjnU$)Nc^>TRRT5"UR5 U$rF)add_constraint_ops dispatch_forfrom_constraint)klassclstype_s r@go3AddConstraintOp.register_add_constraint..goks'  " " / / 6u7L7L MLrC)rd Type[_AC]rOrir=)rerfrgs`` r@register_add_constraint'AddConstraintOp.register_add_constraintgs   rCcXURRUR5"U5$rF)radispatch__visit_name__)re constraints r@rcAddConstraintOp.from_constraintqs)%%..z/H/HI   rCNcgrFr=)r?migration_contexts r@ to_constraintAddConstraintOp.to_constraintws rCcH[RUR55$rF)DropConstraintOprcrsr>s r@rIAddConstraintOp.reverse}s//0B0B0DEErCc&SUR54$)Nadd_constraintrsr>s r@rMAddConstraintOp.to_diff_tuples $"4"4"677rCr=)rOstr)rfr|rOz Callable[[Type[_AC]], Type[_AC]])ror'rOr8rF)rrOptional[MigrationContext]rOr')rOrv)rOzTuple[str, Constraint])rQrRrSrTrUr Dispatcherrapropertyr] classmethodrjrcrrsrIrMrYr=rCr@r8r8^s0* $$ )  >B !;   F8rCdrop_constraintbatch_drop_constraintc\rSrSrSrSSSS.SSjjjrSSjrSSjr\SSj5r SS jr \SSS .SS jjj5r \SSS jj5r S r g)rvz&Represent a drop constraint operation.Nschema_reversec@XlX lX0lX@lXPlgrF)constraint_name table_namer]rr)r?rrrfrrs r@__init__DropConstraintOp.__init__s /$$  rCcH[RUR55$rF)r8rcrsr>s r@rIDropConstraintOp.reverses..t/A/A/CDDrCcjURS:XaSUR54$SUR54$)N foreignkey remove_fkremove_constraint)r]rsr>s r@rMDropConstraintOp.to_diff_tuples:   < /!3!3!56 6'););)=> >rCc SSSSSSS.n[R"U5nU"[R"UR5URURUR UR 5[RU5S9$)Nuniquerprimarycheck)unique_constraintforeign_key_constraintprimary_key_constraintcheck_constraintcolumn_check_constraint table_or_column_check_constraint)rrfr) r_table_for_constraintconstraint_name_or_nonenamergetrnr8rc)rerotypesconstraint_tables r@rc DropConstraintOp.from_constraints"*&2&/ ''.07  '<? 00  OO LL ;;  gg   rCc2U"X#XES9nURU5$)aJIssue 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`. rr)rerrrrrrs r@r%CreatePrimaryKeyOp.create_primary_key-s"Xg E  $$rCcU"UURRUURRS9nURU5$)zIssue 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` rr)rerrrrs r@r+CreatePrimaryKeyOp.batch_create_primary_key\sA$  OO & & ??))     $$rCrrrrr rrrr|r Sequence[str]rrrrrOr)ror'rOrrF)rrr}rOr,) rrrrrr|r List[str]rrrOr)rrrrrrrOr) rQrRrSrTrUr]rrrcrsrrrYr=rCr@rrs  4"O!% E            ?C  !;    !%,%,%',% ,%  ,%,% ,%,%\%#%'% %  %%rCrcreate_unique_constraintbatch_create_unique_constraintrc\rSrSrSrSrSS.S Sjjr\S Sj5rSSSjjr \SS.SS jj5r \SS j5r S r g)CreateUniqueConstraintOpiwz/Represent a create unique constraint operation.rNrc @XlX lX0lX@lXPlgrFrrs r@r!CreateUniqueConstraintOp.__init__rrCc[R"U5n[SU5n0nUR(aURUS'UR(aURUS'UR UR 5 U"[R"UR5URURVs/sHoURPM sn4SUR0UD6$s snf)Nr/ deferrable initiallyr) rrrrrupdaterrrrr)reror uq_constraintrcs r@rc(CreateUniqueConstraintOp.from_constraints'<? ++  OO LL ;;  gg   rCc <U"X#U4SU0UD6nURU5$)aIssue 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`. rr)rerrrrrrrs r@r1CreateUniqueConstraintOp.create_unique_constraints,bg Kf K K  $$rCc URRUS'U"X!RRU40UD6nURU5$)zIssue 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` r)rrrr)rerrrrrs r@r7CreateUniqueConstraintOp.batch_create_unique_constraintsC&"--8 //"<"s r@rM CreateForeignKeyOp.to_diff_tuples$,,.//rCc |[SU5n0nUR(aURUS'UR(aURUS'UR(aURUS'UR(aURUS'UR (aUR US'UR (aUR US'[R"U5u nnnnnn n n n n XCS'XsS 'URUR5 U"[R"UR5UUUU 40UD6$) Nr(onupdateondeleterr use_altermatch source_schemareferent_schema) rrrrrrrr_fk_specrrrr)rero fk_constraintrrrsource_columns target_schema target_tabletarget_columnsrrrrs r@rc"CreateForeignKeyOp.from_constraints43Z@   ! !*33BzN  ! !*33BzN  " "+55B{O  # #,77B|   " "+55B{O   '--BwK   /          ,? -  -../  / / 0B0B C         rCNc[R"U5nUR"URURUR UR UR40URD6$rF) rrrrrrrrrrs r@rs CreateForeignKeyOp.to_constraintEsa,,->? 00        OO     gg   rC)rrrrrrrc NU"UUUUU4UUU U U U U S.UD6nURU5$)afIssue 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. rrrrrrrr)rerrrrrrrrrrrrr dialect_kwrs r@r%CreateForeignKeyOp.create_foreign_keyRsWJ       !'+    $$rC)rrrrrrc U"UURRUUU4UUU URRUU U S.U D6n URU 5$)aIssue 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` rr)rerrrrrrrrrrrr rs r@r+CreateForeignKeyOp.batch_create_foreign_keyskL  OO & &     !$//00+    $$rC)rrrrrr)rrrr|rr|rrrrrrrOr)rOz Tuple[str, ForeignKeyConstraint])ror'rOrrF)rrr}rOr()rrrrrr|rr|rrrrrrrrrOptional[bool]rrrrrrrrr rrOr)rrrrrr|rrrrrrrrrrrr rrrrr rrOr)rQrRrSrTrUr]rrMrrcrsrrrYr=rCr@rrs ?"OE       0' ' T?C  !;    #'"&%)#'#'+)-S%S%'S% S%  S%  S%S% S% S%#S%!S%S%%S%'S% !S%" #S%S%j*."&"&%)#'#4%#4%'4% 4%  4%  4%'4% 4% 4%#4%!4%4%4% 4%4%rCrcreate_check_constraintbatch_create_check_constraintrrrc\rSrSrSrSrSS.S Sjjr\S Sj5rSSSjjr \SS.SS jj5r \SS j5r S r g)CreateCheckConstraintOpiz.Represent a create check constraint operation.rNrc @XlX lX0lX@lXPlgrF)rr conditionrr)r?rrrrrs r@r CreateCheckConstraintOp.__init__s /$" rCc[R"U5n[SU5nU"[R"UR5UR[SUR 54SUR 0URD6$)Nr$zColumnElement[Any]r)rrrrrsqltextrr)reror ck_constraints r@rc'CreateCheckConstraintOp.from_constraints}'<? **  OO NN ;;  gg   rCc <U"X#U4SU0UD6nURU5$)aIssue 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`. rr)rerrrrrrrs r@r/CreateCheckConstraintOp.create_check_constraints,fi M M" M  $$rCc U"UURRU4SURR0UD6nURU5$)zIssue 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` rr)rerrrrrs r@r5CreateCheckConstraintOp.batch_create_check_constraintLsR&  OO & &  ??))      $$rC)rrrrr) rrrr|rz*Union[str, TextClause, ColumnElement[Any]]rrrrrOr)ror'rOrrF)rrr}rOr$)rrrrrr|r+Union[str, ColumnElement[bool], TextClause]rrrrrOr) rrrr|rrrrrOr) rQrRrSrTrUr]rrrcrsrrrYr=rCr@rrs19O!% E  >        #      ?C  !;    !%3%3%'3% 3% ? 3%3%3% 3%3%j%#%%? %  %  %%rCr create_indexbatch_create_indexc\rSrSrSrSSSS.SSjjrSSjrSSjr\SS j5r SSS jjr \SSSS.SS jj5r \SS j5r S r g) CreateIndexOpiiz#Represent a create index operation.NFrr if_not_existsc XXlX lX0lX@lXPlX`lXplgrF) index_namerrrrr%r)r?r'rrrrr%rs r@rCreateIndexOp.__init__ns(%$   *rCcH[RUR55$rF) DropIndexOp from_indexto_indexr>s r@rICreateIndexOp.reverses%%dmmo66rCc&SUR54$)N add_indexr,r>s r@rMCreateIndexOp.to_diff_tupleT]]_--rCcURceU"URURRUR4URRURS.UR D6$N)rr)tabler expressionsrrkwargsreindexs r@r+CreateIndexOp.from_indexse{{&&& JJ KK      ;;%%<<  ll   rCc[R"U5nUR"URURUR 4UR URS.URD6nU$r4) rrr9r'rrrrr)r?rrridxs r@r,CreateIndexOp.to_indexsd,,->?  OO OO LL ;;;;  gg   rCc BU"UUU4UUUS.UD6n URU 5$)azIssue 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 if_not_exists: If True, adds IF NOT EXISTS operator when creating the new index. .. versionadded:: 1.12.0 :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) rerr'rrrrr%rrs r@r CreateIndexOp.create_indexsEx    '     $$rCc U"UURRU4SURR0UD6nURU5$)zIssue a "create index" instruction using the current batch migration context. .. seealso:: :meth:`.Operations.create_index` rr)rerr'rrrs r@r! CreateIndexOp.batch_create_indexsR"  OO & &  ??))      $$rC)rr%r'rrrr)r'rrr|rz4Sequence[Union[str, TextClause, ColumnElement[Any]]]rrrboolr%r rrrOr)rOr*rOzTuple[str, Index])r9r*rOr#rFrrr}rOr*)rrr'rrr|rz/Sequence[Union[str, TextClause, Function[Any]]]rrrrBr%r rrrOr) rrr'r|rrrrrOr)rQrRrSrTrUrrIrMrr+r,r r!rYr=rCr@r#r#isg.!%(,!F   & &7.    ?C !;   !%(,D%D%"D% D% A D%D%D%&D%D% D%D%L%#%% %  %  %%rCr# drop_indexbatch_drop_indexc\rSrSrSrSSSSS.SSjjjrSSjrSSjr\SSj5r SSS jjr \SSSS .SS jjj5r \SS j5r S r g)r*iz!Represent a drop index operation.N)r if_existsrc LXlX lX0lX@lXPlX`lgrF)r'rrrHrr)r?r'rrrHrrs r@rDropIndexOp.__init__ s"%$ " rCc&SUR54$)N remove_indexr0r>s r@rMDropIndexOp.to_diff_tuple 00rCcH[RUR55$rF)r#r+r,r>s r@rIDropIndexOp.reverse'' 88rCcURceU"UR4URRURR[R U5UR S.UR D6$)N)rrrr)r5rrr#r+rr7r8s r@r+DropIndexOp.from_index sh{{&&& JJ {{'';;%%"--e4<<  ll   rCc[R"U5nUR"URURUR (aUR R OS/4SUR0URD6$)Nxr) rrr9r'rrrrrrs r@r,DropIndexOp.to_index,sk,,->?  OO OO%)]]DMM ! ! ;;  gg   rCrrHc >U"U4UUUS.UD6nURU5$)a/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 if_exists: If True, adds IF EXISTS operator when dropping the index. .. versionadded:: 1.12.0 :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. )rrrHr)rerr'rrrHrrs r@rEDropIndexOp.drop_index;s=L  !      $$rCc U"U4URRURRS.UD6nURU5$)zIssue a "drop index" instruction using the current batch migration context. .. seealso:: :meth:`.Operations.drop_index` rrr)rerr'rrs r@rFDropIndexOp.batch_drop_indexjsM  !11??))      $$rC)rrHr'rrrrF)r'zUnion[quoted_name, str, conv]rrrrrHr rzOptional[CreateIndexOp]rrrOrrC)rOr#)r9r*rOr*rD)rrr'r|rrrrrHr rrrOr)rrr'r|rrrOr)rQrRrSrTrUrrMrIrr+r,rErFrYr=rCr@r*r*s=, %) !%$(,01"   " * "19    ?C  !;     %) ,% !%$(,%,%,%" ,%  ,%",%,% ,%,%\%(%69%AD% %%rCr* create_tablec\rSrSrSrSSSSS.SSjjrSSjrSSjr\SS .SS jj5r SSS jjr \SS .SS jj5r Sr g) CreateTableOpiz#Represent a create table operation.NF)rr%_namespace_metadata_constraints_includedc XlX lX0lX@lUR S05UlUR SS5UlUR SS5UlXplXPl X`l g)NrAcommentprefixes) rrrr%poprArcrdrr`ra)r?rrrr%r`rars r@rCreateTableOp.__init__s`%  *FF62& vvi. z40 #6 %:"rCcZ[RUR5URS9$)Nr`) DropTableOp from_tableto_tabler`r>s r@rICreateTableOp.reverses+%% MMO1I1I&  rCc&SUR54$)N add_tablerkr>s r@rMCreateTableOp.to_diff_tupler2rCrhc 0Uc URnU"UR[UR5[UR5-4UR USUR [UR5[UR5S.URD6$)NT)rr`rarcrArd) metadatarlistr constraintsrrcdictrA _prefixesr7rer5r`s r@rjCreateTableOp.from_tables  &"'..  JJ MD!2!23 3 << 3#'MMejj!%//* ll  rCc [R"U5nUR"UR/URQ7UR UR (a[UR 5O/URUR(aURR5O0URS.URD6$)N)rrdrcrAra) rrr5rrrrdrsrcrAcopyrarrs r@rkCreateTableOp.to_tables,,->?  OO  \\  ;;,0MMT$--(rLL%)YY!B"&"<"<  gg  rC)r%c:U"X$4SU0UD6nURU5$)a 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 if_not_exists: If True, adds IF NOT EXISTS operator when creating the new table. .. versionadded:: 1.13.3 :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)rerrr%rrrs r@r]CreateTableOp.create_tables*t HM HR H  $$rC) rar`rrcr%rArrdrr)rr|rzSequence[SchemaItem]rrr%r r`Optional[MetaData]rarBrrrOr)rOrirOzTuple[str, Table])r5r.r`r~rOr_rFrrr}rOr.) rrrr|rr-r%r rrrOr.) rQrRrSrTrUrrIrMrrjrkr]rYr=rCr@r_r_s-!%(,26&+;;&;  ; & ;0; $;; ;, .HL  3E   2?C !;   )- Z%Z%Z% Z% & Z%  Z% Z%Z%rCr_ drop_tablec\rSrSrSrSSSSS.SSjjrSSjrSSjr\SS.SS jj5r SSS jjr \SSS .SS jj5r S r g)rii)z!Represent a drop table operation.N)rrHtable_kwrcXlX lX0lU=(d 0UlURR SS5UlURR SS5UlURR SS5UlXPlg)NrcrArd) rrrHrrercrArdr)r?rrrHrrs r@rDropTableOp.__init__-sk% " B }}((D9 MM%%fd3  ))*d;  rCc&SUR54$)N remove_tableror>s r@rMDropTableOp.to_diff_tuple?rNrCcH[RUR55$rF)r_rjrkr>s r@rIDropTableOp.reverseBrQrCrhc U"URURUR[UR5[ UR 5S.URE[RXS9S9$)N)rcrArdrh)rrr) rrrcrurArsrvr7r_rjrws r@rjDropTableOp.from_tableEsi JJ<< ==UZZ( 1,,  #--.  rCc UR(aURRnO/n[R"U5nUR"UR /UQ7UR UR(aURR5O0UR(a[UR5O/URUR(aURROSS.URD6nU$)NF)rcrArdrra)rrrrr5rrcrArzrdrsrrar)r?rrcols_and_constraintsrts r@rkDropTableOp.to_tableWs ==#'==#8#8 #% ,,->?    OO ! LL%)YY!B,0MMT$--(r;;7;}} 33% mm rCrWc 4U"X#XES9nURU5 g)aHIssue 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 if_exists: If True, adds IF EXISTS operator when dropping the table. .. versionadded:: 1.13.3 :param \**kw: Other keyword arguments are passed to the underlying :class:`sqlalchemy.schema.Table` object created for the command. )rrHrNr)rerrrrHrrs r@rDropTableOp.drop_tablens>i M"rC)rrcrHrArdrrr) rr|rrrHr rz"Optional[MutableMapping[Any, Any]]rzOptional[CreateTableOp]rOrr)rOr_)r5r.r`r~rOrirFr) rrrr|rrrHr rrrOr) rQrRrSrTrUrrMrIrrjrkrrYr=rCr@riri)s+ !%$(7;,0!! ! " ! 5 !*! !$19HL  3E   $?C!; . !%$(    "  rCric4\rSrSrSrSS.SSjjrSrg) AlterTableOpiz#Represent an alter table operation.NrcXlX lgrFr[)r?rrs r@rAlterTableOp.__init__s % rCrr)rr|rrrOr)rQrRrSrTrUrrYr=rCr@rrs0- !%    rCr rename_tablect^\rSrSrSrSS.SU4Sjjjr\SS.S Sjj5rSrU=r $) RenameTableOpiz#Represent a rename table operation.Nrc,>[TU]XS9 X lgNr)superrnew_table_name)r?old_table_namerr __class__s r@rRenameTableOp.__init__s 7,rCc2U"X#US9nURU5$)a4Emit 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`. rr)rerrrrrs r@rRenameTableOp.rename_tables!& ?  $$rC)r)rr|rr|rrrOr) rrrr|rr|rrrOr) rQrRrSrTrUrrrrY __classcell__rs@r@rrs-!% ---  -  --!% %%% %  % %%rCrcreate_table_commentbatch_create_table_commentc\rSrSrSrSSS.SSjjr\SSS.SSjj5r\SS.SS jj5rSS jr SSS jjr SS jr S r g)CreateTableCommentOpiz)Represent a COMMENT ON `table` operation.Nrexisting_commentc4XlX lX@lX0lgrF)rrcrr)r?rrcrrs r@rCreateTableCommentOp.__init__s% 0 rCrrc6U"UUUUS9nURU5$)aEmit a COMMENT ON operation to set the comment for a table. :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` rr)rerrrcrrrs r@r)CreateTableCommentOp.create_table_comments-8  -     $$rCrcU"URRUUURRS9nURU5$)aEmit a COMMENT ON operation to set the comment for a table using the current batch migration context. :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. rr)rerrcrrs r@r/CreateTableCommentOp.batch_create_table_commentsA( OO & & -??))     $$rCcURc)[URURURS9$[ URURURURS9$)2Reverses the COMMENT ON operation against a table.r)rDropTableCommentOprrcrrr>s r@rICreateTableCommentOp.reverses]  (%!%{{  (%%!%{{  rCc[R"U5nURURURUR S9$)N)rrc)rrr5rrrcrs r@rkCreateTableCommentOp.to_table's@,,->?  OODKK   rCc<SUR5UR4$)Nadd_table_comment)rkrr>s r@rM"CreateTableCommentOp.to_diff_tuple0s#T]]_d6K6KLLrC)rcrrr) rr|rcrrrrrrOr) rrrr|rcrrrrrrOr)rrrcrrrrOr)rOz/Union[CreateTableCommentOp, DropTableCommentOp]rFrrP) rQrRrSrTrUrrrrrIrkrMrYr=rCr@rrs 4!%*.      (   +/ $!%!%!% !% ( !%!% !%!%F +/ %#%% ( %  %%6"?C !;  MrCrdrop_table_commentbatch_drop_table_commentc\rSrSrSrSSS.SSjjr\SSS.SSjj5r\SS.SS jj5rSS jr SSS jjr SS jr S r g)ri4z:Represent an operation to remove the comment from a table.Nrc(XlX0lX lgrF)rrr)r?rrrs r@rDropTableCommentOp.__init__;s% 0 rCrc2U"X#US9nURU5$)adIssue a "drop table comment" operation to remove an existing comment set on a table. :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` rr)rerrrrrs r@r%DropTableCommentOp.drop_table_commentFs!0v N  $$rCrcU"URRUURRS9nURU5$)zIssue a "drop table comment" operation to remove an existing comment set on a table using the current batch operations context. :param existing_comment: An optional string value of a comment already registered on the specified table. rr)rerrrs r@r+DropTableCommentOp.batch_drop_table_commentas>  OO & &-??))    $$rCcT[URURURS9$)rr)rrrrr>s r@rIDropTableCommentOp.reversexs$# OOT224;;  rCcv[R"U5nURURURS9$r)rrr5rrrs r@rkDropTableCommentOp.to_table~s3,,->?  DDrCc&SUR54$)Nremove_table_commentror>s r@rM DropTableCommentOp.to_diff_tuples& 88rC)rrr)rr|rrrrrOr) rrrr|rrrrrOr)rrrrrOr)rOrrFrrP) rQrRrSrTrUrrrrrIrkrMrYr=rCr@rr4s E !%*.    (    +/ $ %%% ( %  % %%4 +/ %#%( %  %%, ?CE!;E E9rCr alter_columnbatch_alter_columnc p^\rSrSrSrSSSSSSSSSSS. SU4SjjjrSSjrSSjrSS jr\ SSSSSSSSSSS . SS jj5r \ SSSSSSSSSSSS . SS jj5r Sr U=r $) AlterColumnOpiz$Represent an alter column operation.NF) r existing_typeexisting_server_defaultexisting_nullablermodify_nullablemodify_commentmodify_server_default modify_name modify_typec  >[TU]XS9 X lX@lXPlX`lXplXlXlXl Xl Xl Xl gr) rr column_namerrrrrrrrrr)r?rrrrrrrrrrrrrrs r@rAlterColumnOp.__init__sV" 3&*'>$!2 0.,%:"&&rCc 0/nURURURpCnURbNUR SUUUUR UR URS.URUR45 URbNUR SUUUURUR URS.UR UR45 URSLaNUR SUUUUR URURS.UR UR45 URSLaNUR SUUUUR URUR S .URUR45 U$) Nr)rrrr)rrrFmodify_default)rrrr)rrr) rrrrappendrrrrrrr)r?col_diffrtnamecnames r@rMAlterColumnOp.to_diff_tuples#{{DOOT=M=Mu    ' OO!-1-C-C 88,0,A,A &&$$ $    + OO%)-);); 88,0,A,A **(( $  % %U 2 OO$-1-C-C)-););,0,A,A 00..     e + OO$-1-C-C)-);); 88 ))'' $rCcURSL=(d8 URSL=(d# URSL=(d URSLnU(agURHnUR S5(dM g g)NFTmodify_)rrrrr startswith)r?hc1rs r@ has_changesAlterColumnOp.has_changess}   , 0))6 0t+ 0""%/ ''B}}Y''rCcURR5nURUS'URUS'URUS'UR US'UR bUR US'URbURUS'URSLaURUS'URSLaURUS 'UVs/sHn[R"S U5PM snVs1sHnU(dM URS 5iM nnUH+nS U-U;dMUS U-nUS U-US U-'XQS U-'M- UR"URUR4SUR 0UD6$s snfs snf)NrrrrrrFrrz^(?:existing_|modify_)(.+)$rz modify_%sz existing_%sr)rrzrrrrrrrrrergrouprrrr)r?rkmall_keysswaps r@rIAlterColumnOp.reverse s WW\\^"00?"&"8"8 (,(D(D $%!%!6!6     ' $ 0 0B}     +$($8$8B !  % %U 2*.*D*DB& '   e +#'#6#6B LNN2abhh=qA2N N AGGAJN  AQ"$-!+,(*;?(;=1$%&*;?#  ~~ OOT-- 6:kk EG  O s!F5 FF) nullablercserver_defaultnew_column_namerfrrrrrc  NU"UU4U U U U U UUUUUS. UD6nURU5$)aIssue 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. :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 SQLAlchemy "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. :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. ) rrrrrrrrrrr)rerrrrrcrrrfrrrrrralts r@rAlterColumnOp.alter_column+sWT   '$;/-'"0$"     %%rC) rrcrrrfrrrr insert_before insert_afterc  U"URRU4URRUU U U UUUUUU U S. UD6nURU5$)aIssue 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. :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. .. seealso:: :meth:`.Operations.alter_column` ) rrrrrrrrrrrrr)rerrrrcrrrfrrrrrrrrs r@r AlterColumnOp.batch_alter_columnsqZ OO & &  ??))'$;/-'"0$"'%  $  %%rC) rrrrrrrrrrr)rr|rr|rrr Optional[Any]rrrr rrrr r$Optional[Union[str, Literal[False]]]rrrrrrrrrOrrOrrOrB)rOr)rrrr|rr|rr rcrrrrrrf7Optional[Union[TypeEngine[Any], Type[TypeEngine[Any]]]]rrr.Optional[Union[str, bool, Identity, Computed]]rr rrrrrrrOr)rrrr|rr rcrrrrrrfrrrrrrr rrrrrrrrrOr)rQrRrSrTrUrrMrrIrrrrYrrs@r@rrs}/!%'+',,0*.*.?D%*%)%)   % "%*((= ### !&#>&>& ! >& 6 >&>&'>&G>& >&" >& *!>&"(#>&$%%>&&$'>&()>&* +>&>&rCr add_columnbatch_add_columnc^\rSrSrSrSS.SU4SjjjrSSjrSSjrSSjr\ SS j5r \ SS j5r \ SS.SS jj5r \ SSS .SS jj5r SrU=r$) AddColumnOpiz"Represent an add column operation.Nrc 8>[TU]XS9 X lX@lgr)rrcolumnr)r?rrrrrs r@rAddColumnOp.__init__s 3 rCcl[RURURUR5$rF) DropColumnOpfrom_column_and_tablenamerrrr>s r@rIAddColumnOp.reverses(55 KK$++  rCcJSURURUR4$)Nr)rrrr>s r@rMAddColumnOp.to_diff_tuplesdkk4??DKKHHrCcUR$rF)rr>s r@ to_columnAddColumnOp.to_columns {{rCc`U"URRXRRS9$r)r5rr)recols r@ from_columnAddColumnOp.from_columns!399>>3yy/?/?@@rCcU"X#US9$rr=rerrrs r@r %AddColumnOp.from_column_and_tablename s5f--rCc2U"X#US9nURU5$)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`. rr)rerrrrrs r@rAddColumnOp.add_columns"nF 3  $$rC)rrc0nU(aX5S'U(aXES'U"URRU4SURR0UD6nURU5$)zIssue an "add column" instruction using the current batch migration context. .. seealso:: :meth:`.Operations.add_column` rrrr)rerrrrrrs r@rAddColumnOp.batch_add_columnnsj$ "/  !-~   OO & &  ??))      $$rC)rr) rr|r Column[Any]rrrrrOr)rOr rOz+Tuple[str, Optional[str], str, Column[Any]])rOr)rrrOr)rrrr|rrrOr) rrrr|rrrrrOr) rrrrrrrrrOr)rQrRrSrTrUrrIrMrrrr rrrYrrs@r@rrsM-!%           I 4I AA... .  ..!% W%W%W% W%  W% W%W%r (,&* %#%% % % $ % %%rCr drop_columnbatch_drop_columnc^\rSrSrSrSSS.SU4SjjjrSSjrSSjr\SSj5r SSS jjr \SS .SS jj5r \SS j5r S r U=r$)r iz"Represent a drop column operation.Nrc D>[TU]XS9 X lXPlX@lgr)rrrrr)r?rrrrrrs r@rDropColumnOp.__init__s% 3& rCcRSURURUR54$)N remove_column)rrrr>s r@rMDropColumnOp.to_diff_tuples)  KK OO NN    rCcURc [S5e[RURUR URR 5$)Nz;operation is not reversible; original column is not present)rrrr rrrr>s r@rIDropColumnOp.reversesL == 1  44 KK$--*>*>  rCc PU"UURU[RXU5S9$)Nr)rrr rs r@r &DropColumnOp.from_column_and_tablenames.  HH ::6#N   rCcURbURR$[R"U5nURUR[ 5$rF)rrrrrrrs r@rDropColumnOp.to_columnsH == $=='' ',,->?   !1!18< >2 >  $$rCc U"URRU4SURR0UD6nURU5$)zIssue a "drop column" instruction using the current batch migration context. .. seealso:: :meth:`.Operations.drop_column` rr)rerrrrs r@rDropColumnOp.batch_drop_columnsO OO & &  ??))      $$rC)rrr) rr|rr|rrrzOptional[AddColumnOp]rrrOrr)rOr)rrrr|rrrOr rF)rrr}rOr) rrrr|rr|rrrrrOr)rrrr|rrrOr)rQrRrSrTrUrrMrIrr rrrrYrrs@r@r r sC-!%*. ! ! !  ! ( ! !  ! ! 4               ?C=!;= =!% /%/%/% /%  /%/% /%/%b%(%7:%BE% %%rCr  bulk_insertcf\rSrSrSrSS.S Sjjr\SS.S Sjj5rSrg) BulkInsertOpi z"Represent a bulk insert operation.T multiinsertc(XlX lX0lgrF)r5rowsr4)r?r5r6r4s r@rBulkInsertOp.__init__ s  &rCc4U"X#US9nURU5 g)a 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. r3Nr)rerr5r6r4rs r@r0BulkInsertOp.bulk_insert# sR+ 6"rC)r4r6r5N)r5Union[Table, TableClause]r6List[Dict[str, Any]]r4rBrOr) rrr5r:r6r;r4rBrOr) rQrRrSrTrUrrr0rYr=rCr@r2r2 s,! '( '# '  '  '! ii)i# i  i iirCr2execute batch_executec\rSrSrSrSS.S Sjjr\SS.S Sjj5r\SS.S Sjj5rS Sjr S r g) ExecuteSQLOpi z#Represent an execute SQL operation.Nexecution_optionscXlX lgrF)rrA)r?rrAs r@rExecuteSQLOp.__init__ s  !2rCc0U"X#S9nURU5$)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 coerced 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` construct. * a :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)rerrrArs r@r<ExecuteSQLOp.execute s p >  $$rCc"URXUS9$)zkExecute the given SQL using the current migration context. .. seealso:: :meth:`.Operations.execute` r@)r<)rerrrAs r@r=ExecuteSQLOp.batch_execute s {{ 3D  rCcSUR4$)Nr<)rr>s r@rMExecuteSQLOp.to_diff_tuple s4<<((rC)rAr)rUnion[Executable, str]rAOptional[dict[str, Any]]rOr)rrrrJrArKrOr)rOz"Tuple[str, Union[Executable, str]]) rQrRrSrTrUrrr<r=rMrYr=rCr@r?r? s. 7; 3'34 3  3 7; X%X%(X% 4 X%  X%X%t 7;   ( 4     $)rCr?cV\rSrSrSrS S SjjrS SjrS Sjr\S Sj5r Sr g) OpContaineri z-Represent a sequence of operations operation.c$[U5UlgrF)rsops)r?rOs r@rOpContainer.__init__ s 9rCc$UR(+$rFrOr>s r@is_emptyOpContainer.is_empty s88|rCc>[[RU55$rF)rsrM _ops_as_diffsr>s r@as_diffsOpContainer.as_diffs sK--d344rCc## URHKn[US5(a%UR[SU55ShvN M9UR 5v MM gN7f)NrOrM)rOhasattrrVrrM)re migrationsrs r@rVOpContainer._ops_as_diffs sO..Br5!!,,T--DEEE&&(( !Es?A!AA!rRN)r=)rOSequence[MigrateOperation]rOrrr)r[rMrOzIterator[Tuple[Any, ...]]) rQrRrSrTrUrrSrWrrVrYr=rCr@rMrM s875)$) "))rCrMcP^\rSrSrSrSS.SU4SjjjrS SjrSrU=r$) ModifyTableOpsi' zCContains a sequence of operations that all apply to a single Table.Nrc<>[TU]U5 XlX0lgrF)rrrr)r?rrOrrs r@rModifyTableOps.__init__* s $ rCc [UR[[URVs/sHoR 5PM sn55UR S9$s snf)N)rOr)r_rrsreversedrOrIrr?rs r@rIModifyTableOps.reverse5 sD OOXdhh?hzz|h?@A;;  ?sAr)rr|rOr]rrrOr)rOr_ rQrRrSrTrUrrIrYrrs@r@r_r_' sEM!%  (        rCr_cV^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) UpgradeOpsi= zcontains a sequence of operations that would apply to the 'upgrade' stream of a script. .. seealso:: :ref:`customizing_revision` c,>[TU]US9 X lgNrR)rr upgrade_token)r?rOrkrs r@rUpgradeOps.__init__G s S!*rCc [[URVs/sHo"R5PM sn55URSS&U$s snfrF)rsrcrOrI)r? downgrade_opsrs r@ reverse_intoUpgradeOps.reverse_intoO sC# TXX6XrjjlX6 7 !7sA c2UR[/S95$rj)ro DowngradeOpsr>s r@rIUpgradeOps.reverseU s  "!566rC)rk)r=upgrades)rOr]rkr|rOr)rnrrrOrr)rOrr) rQrRrSrTrUrrorIrYrrs@r@rhrh= sE+-'+ '++  ++ 77rCrhcL^\rSrSrSrSSU4SjjjrSSjrSrU=r$) rriY zcontains a sequence of operations that would apply to the 'downgrade' stream of a script. .. seealso:: :ref:`customizing_revision` c,>[TU]US9 X lgrj)rrdowngrade_token)r?rOrwrs r@rDowngradeOps.__init__c s S!.rCc [[[URVs/sHoR 5PM sn55S9$s snfrj)rhrsrcrOrIrds r@rIDowngradeOps.reversek s6Xdhh?hzz|h?@A  ?sA)rw)r= downgrades)rOr]rwr|rOr)rOrhrfrs@r@rrrrY s@+-+/ '//  //  rCrrc:\rSrSr%SrS\S'S\S'S\S'S \"5S S S S S S .SS jjr\SS j5r \ RSS j5r \SSj5r \ RSSj5r \SSj5r \SSj5r Srg )MigrationScriptiq a4represents 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_renderList[UpgradeOps] _upgrade_opsList[DowngradeOps]_downgrade_opsN)messageimportsheadsplice branch_label version_path depends_onc|XlX@lXPlX`lXplXlXlXlX lX0l grF) rev_idrrrrrrr upgrade_opsrn) r?rrrnrrrrrrrs r@rMigrationScript.__init__ s:     (($&*rCc[UR5S:a [S5eUR(dgURS$)zbAn instance of :class:`.UpgradeOps`. .. seealso:: :attr:`.MigrationScript.upgrade_ops_list` rzrThis MigrationScript instance has a multiple-entry list for UpgradeOps; please use the upgrade_ops_list attribute.Nr)lenrrr>s r@rMigrationScript.upgrade_ops sH t  !A %.  ""$$Q' 'rCc[R"U5UlURHn[U[5(aMe grF)rto_listr isinstancerh)r?relems r@rr s8!LL5%%DdJ// //&rCc[UR5S:a [S5eUR(dgURS$)zfAn instance of :class:`.DowngradeOps`. .. seealso:: :attr:`.MigrationScript.downgrade_ops_list` rzvThis MigrationScript instance has a multiple-entry list for DowngradeOps; please use the downgrade_ops_list attribute.Nr)rrrr>s r@rnMigrationScript.downgrade_ops sH t"" #a '0  $$&&q) )rCc[R"U5UlURHn[U[5(aMe grF)rrrrrr)r?rnrs r@rnr s8#ll=9''DdL11 11(rCcUR$)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. )rr>s r@upgrade_ops_list MigrationScript.upgrade_ops_list s   rCcUR$)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. )rr>s r@downgrade_ops_list"MigrationScript.downgrade_ops_list s"""rC) rrrrrnrrrrrrr)rrrrhrnrrrrrzSet[str]rrrr rOptional[_RevIdType]rrrrrOr)rOzOptional[UpgradeOps])rz#Union[UpgradeOps, List[UpgradeOps]]rOr)rOzOptional[DowngradeOps])rnz'Union[DowngradeOps, List[DowngradeOps]]rOr)rOr)rOr)rQrRrSrTrUrXsetrrrsetterrnrrrYr=rCr@r}r}q sI."!""&&"&E"!%-1&*+/++ +$ +  ++++++$+)+ +2(($0>0 00**$2D2 22!!##rCr})] __future__rabcrrtypingrrrrr r r r r rrrrrrrsqlalchemy.typesrrbaserrrrrsqlalchemy.sqlrsqlalchemy.sql.elementsrr r!r"sqlalchemy.sql.functionsr#sqlalchemy.sql.schemar$r%r&r'r(r)r*r+r,r-r.r/sqlalchemy.sql.selectabler0sqlalchemy.sql.type_apir1autogenerate.rewriterr2runtime.migrationr3script.revisionr4r5r7r:r8register_operationrvrjrrrrr#r*r_rirrrrrrr r2r?rMr_rhrrr}r=rCr@rs" ! %!)5,3215,.0:.+.:0+65204, T e,-""@#8&#8L 01##$57NOr%'r%P2r%j 34##4(()ABt%t%C5 t%n 9:## @(()<=%%>; %D 34##4(()ABZ%Z%C5 Z%z 89##>(();<(()KL(()BC%o%DM=:%D ~.##N4HIV%$V%J/V%r |,##L2DEw%"w%F-w%t ~.e%$e%/e%P |,d"d-dN #  ~.!%L!%/!%H 56##8jM<jM7jMZ 34##4N9N95N9b ~.##N4HI[&L[&J/[&|  |,##L2DEa%,a%F-a%H }-##M3FG@%<@%H.@%F }-x#x.xv y)##I?{)#{)@*{)|)"). [ ,778 ; 0#&#rC