lmZddlmZddlmZdd
lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddl"m#Z#ddl"m$Z$ddl"m%Z%ddl"m&Z&dd l"m'Z'dd!l"m(Z(dd"l"m)Z)dd#l"m*Z*dd$l"m+Z+dd%l"m,Z,dd&l"m-Z-dd'l"m.Z.dd(l/m0Z0dd)l/m1Z1dd*l/m2Z2dd+l/m3Z3dd,l/m4Z4dd-l5m6Z6dd.l5m7Z7dd/l5m8Z8dd0l5m9Z9dd1l5m:Z:dd2l5m;Z;dd3l5m<Z<dd4l5m=Z=dd5l5m>Z>dd6l?m@Z@dd7lAmBZBd8d9lmCZCd8dlmZd8d:lDmEZEd8d;lDmFZFer<>dd<lmGZGdd=lmHZHdd>lmIZIdd?lmJZJdd@lmKZKddAlmLZLddBlmMZMddClmNZNddDlmOZOddElmPZPddFlmQZQddGlmRZRddHlmSZSddIlmTZUddJl"mVZVddKlWmXZXddLl/mYZYddMl5mZZZddNl5m[Z[ddOl5m\Z\ddPl5m]Z]dwdR<64>Z^dxdS<64>Z_dydT<64>Z`n6ej<>dU<64>Z^ej<>dV<64>Z_ej<>dW<64>Z`edXe<08>Y<EFBFBD>Zbeece2efZdee=e6e;fZeGdZ<64>dQe*<2A>Zfe*j<>d[d\<5C>Gd]<5D>d^ef<65><00>Zhe*j<>d[d_<64>Gd`<60>daef<65><00>Zie*j<>d[db<64>Gdc<64>ddef<65><00>ZjGde<64>dfej<>e9e.e+e:e-e7e1<65>
Selectable<EFBFBD>DMLStatec<01><00>y<00>N<><00><01>dmls<20>6D:\aitsc\.venv\Lib\site-packages\sqlalchemy\sql\dml.py<70>isupdaterX`<00><00><00>c<EFBFBD>c<01><00>yrSrTrUs rW<00>isdeleter\brYrZc<01><00>yrSrTrUs rW<00>isinsertr^drYrZrXr\r^<00>_T)<01>boundc<01>F<00>eZdZUdZdZded<dZded<dZded<dZd ed
d
Zd
Zded<dd<10>Z
edd<11><04>Zedd<12><04>Zedd<13><04>Zer ed d<14><04>Zed!d<15><04>Zed"d<16><04>Zd#d<17>Zd$d<18>Zd$d<19>Zd%d<1A>Zd&d<1B>Zy)'rQTNz0Optional[MutableMapping[_DMLColumnElement, Any]]<5D>_dict_parametersz6Optional[List[MutableMapping[_DMLColumnElement, Any]]]<5D>_multi_parameters<72>-Optional[List[Tuple[_DMLColumnElement, Any]]]<5D>_ordered_valuesz!Optional[List[_DMLColumnElement]]<5D>_parameter_orderingr/<00>_primary_tableF<65>
s<00>Ac<01>b<00>tjd|jj<00>z<00><00>)Nz6%s construct does not support multiple parameter sets.)r9<00>InvalidRequestError<6F>__visit_name__<5F>upperr<72>s rW<00>_no_multi_values_supportedz#DMLState._no_multi_values_supported<65>s2<00><00><11>%<25>%<25>
'<27>)2<>)A<>)A<>)G<>)G<>)I<>
J<01>
<EFBFBD>
rZc<01>,<00>tjd<01><00>)Nz<4E>Can't mix single and multiple VALUES formats in one INSERT statement; one style appends to a list while the other replaces values, so the intent is ambiguous.)r9r<>rs rW<00>_cant_mix_formats_errorz DMLState._cant_mix_formats_error<6F>s<00><00><11>%<25>%<25><19>
<EFBFBD><04>,rZc<01><><00>|j}|jr=d|_|<02>J<00>t|<02>|_||_|D<00><03>cgc]\}}|<03><02>c}}|_ytjd<02><00>cc}}w)NFzQCan only invoke ordered_values() once, and not mixed with any other values() call)rer<><00>dictrbrfr9r<>)rmrir<>r{r<>s rWr<>z&UpdateDMLState._process_ordered_valuesgsx<00><00><1E>.<2E>.<2E>
<EFBFBD>&
rZr<><00>deletec<01><00>eZdZdZdd<02>Zy)<05>DeleteDMLStateTc<01>r<00>||_d|_|j|<01>\}}||_||_||_yr<>)rir\r<>rgr<>r<>)rmrirnror<>r<>s rWrpzDeleteDMLState.__init__{s<<00><00>"<22><04><0E><1C><04><0A><14>&<26>&<26>y<EFBFBD>1<><05><01>2<EFBFBD><1F><04><1B><1E><04><19><1F><04>rZN)ri<00>DeleternrKror)r<>r<>r<>r\rprTrZrWr<>r<>ws<00><00><13>H<EFBFBD> rZr<>c<01><><00>eZdZUdZdZejZded<dZ e
),rhzDForm the base for ``INSERT``, ``UPDATE``, and ``DELETE`` statements.<2E>update_basez5util.immutabledict[Tuple[_DMLTableElement, str], str]<5D>_hintsFr3<00>_label_styler<65>rsNz+Optional[Tuple[_ColumnsClauseElement, ...]]<5D>_return_defaults_columns<6E>_supplemental_returningrTz!Tuple[_ColumnsClauseElement, ...]<5D>
rZc<01><00>td<01><00>)z<>Set the parameters for the statement.
This method raises ``NotImplementedError`` on the base class,
and is overridden by :class:`.ValuesBase` to provide the
SET/VALUES clause of UPDATE and INSERT.
z<>params() is not supported for INSERT/UPDATE/DELETE statements. To set the values for an INSERT or UPDATE statement, use stmt.values(**parameters).rk)rm<00>argros rW<00>paramszUpdateBase.params<6D>s<00><00>"<22>
*<2A>
<EFBFBD>
rZc<01>(<00>|j|<01>|S)aAdd dialect options to this INSERT/UPDATE/DELETE object.
c3<01>dK<00>|](}tjtj|<01><00><01><00>*y<00>wrS<00>rr<>r<00>ColumnsClauseRole<6C>rr|s rWrz-UpdateBase.return_defaults.<locals>.<genexpr><3E>s,<00><00><><00>I<16>!%<25>A<EFBFBD>"<22>(<28>(<28><15>)@<40>)@<40>!<21>D<>!%<25><><00>.0rTc3<01>dK<00>|](}tjtj|<01><00><01><00>*y<00>wrSrrs rWrz-UpdateBase.return_defaults.<locals>.<genexpr><3E>s'<00><00><><00>2<0E>FJ<46><11><09><20><20><15>!8<>!8<>!<21><<3C>d<EFBFBD>rTz]The 'sort_by_parameter_order' argument to return_defaults() only applies to INSERT statementsc3<01>dK<00>|](}tjtj|<01><00><01><00>*y<00>wrSrrs rWrz-UpdateBase.return_defaults.<locals>.<genexpr><3E>s+<00><00><><00>$<0E>*<2A>A<EFBFBD><1A><20><20><15>!8<>!8<>!<21><<3C>*<2A>r)<0C>_return_defaultsr<73>r<>r<00>
<14>+<2B>+<2B>3<>/4<><18>$<24>$<24>%9<>:<3A>0<12><04>,<2C><14><0B>05<30><18>$<24>$<24><1C>4<>4<><1F> 4<>5<>6<><16>0<12><04>,<2C><14>rZ<00>rc<01><00>|rtd|<03><00>|jrtjd<02><00>|xjtd<03>|D<00><00>z
c_|r(|jstjd<04><00>d|_|S)aRAdd a :term:`RETURNING` or equivalent clause to this statement.
{printsql}INSERT INTO some_table (first_name, last_name)
VALUES (:first_name, :last_name)
RETURNING some_table.first_name || :first_name_1 || some_table.last_name AS fullname
Upon compilation, a RETURNING clause, or database equivalent,
will be rendered within the statement. For INSERT and UPDATE,
the values are the newly inserted/updated values. For DELETE,
the values are those of the rows which were deleted.
Upon execution, the values of the columns to be returned are made
available via the result set and can be iterated using
:meth:`_engine.CursorResult.fetchone` and similar.
For DBAPIs which do not
natively support returning values (i.e. cx_oracle), SQLAlchemy will
approximate this behavior at the result level so that a reasonable
amount of behavioral neutrality is provided.
Note that not all databases/DBAPIs
support RETURNING. For those backends with no support,
an exception is raised upon compilation and/or execution.
For those who do support it, the functionality across backends
varies greatly, including restrictions on executemany()
and other statements which return multiple rows. Please
read the documentation notes for the database in use in
order to determine the availability of RETURNING.
:param \*cols: series of columns, SQL expressions, or whole tables
entities to be returned.
:param sort_by_parameter_order: for a batch INSERT that is being
executed against multiple parameter sets, organize the results of
RETURNING so that the returned rows correspond to the order of
parameter sets passed in. This applies only to an :term:`executemany`
execution for supporting dialects and typically makes use of the
:term:`insertmanyvalues` feature.
.. versionadded:: 2.0.10
.. seealso::
:ref:`engine_insertmanyvalues_returning_order` - background on
sorting of RETURNING rows for bulk INSERT (Core level discussion)
:ref:`orm_queryguide_bulk_insert_returning_ordered` - example of
use with :ref:`orm_queryguide_bulk_insert` (ORM level discussion)
.. seealso::
:meth:`.UpdateBase.return_defaults` - an alternative method tailored
towards efficient fetching of server-side defaults and triggers
for single-row INSERTs or UPDATEs.
:ref:`tutorial_insert_returning` - in the :ref:`unified_tutorial`
zUpdateBase.returning()z9return_defaults() is already configured on this statementc3<01>dK<00>|](}tjtj|<01><00><01><00>*y<00>wrSrrs rWrz'UpdateBase.returning.<locals>.<genexpr>s'<00><00><><00>!
<EFBFBD>BF<EFBFBD>Q<EFBFBD>I<EFBFBD><1C><1C>U<EFBFBD>4<>4<>a<EFBFBD>8<>$<24>rzWThe 'sort_by_parameter_order' argument to returning() only applies to INSERT statementsT) rrr9r<>r<>r<>rrr)rmrr <00>_UpdateBase__kws rW<00> returningzUpdateBase.returning<6E>s<><00><00>~<10><20>!9<>4<EFBFBD>@<40>@<40><0F><20><20><15>)<29>)<29>K<><0E><0E><0A><0F><0F>5<EFBFBD>!
rZc<01>R<00>t|j<00>D<00>cgc]}|<01><02>c}Scc}wrS)r r<>)rmr|s rWrzz UpdateBase._all_selected_columns2s%<00><00>,<2C>T<EFBFBD>_<EFBFBD>_<EFBFBD>=<3D>><3E>=<3D>a<EFBFBD><01>=<3D>><3E>><3E><>>s<00> $c<01>V<00>td<01>|jD<00><00>j<00>S)zxReturn the RETURNING columns as a column collection for this
:param selectable: optional :class:`_schema.Table` that specifies
an element of the FROM clause within an UPDATE or DELETE
to be the subject of the hint - applies only to certain backends.
:param dialect_name: defaults to ``*``, if specified as the name
of a particular dialect, will apply these hints only when
that dialect is in use.
)rsrr<>r<00>DMLTableRoler<65>r)rm<00>text<78>
selectable<EFBFBD>dialect_names rW<00> with_hintzUpdateBase.with_hintFsQ<00><00>H<16><1D><1D><1A><1A>J<EFBFBD>"<22>)<29>)<29>%<25>*<<3C>*<<3C>j<EFBFBD>I<>J<EFBFBD><1A>k<EFBFBD>k<EFBFBD>'<27>'<27>*<2A>l<EFBFBD>)C<>T<EFBFBD>(J<>K<><04><0B><13>rZc<01>P<00>tj|<00>j}||<00>S)a=Return a :term:`plugin-enabled` description of the table and/or
entity which this DML construct is operating against.
This attribute is generally useful when using the ORM, as an
extended structure which includes information about mapped
entities is returned. The section :ref:`queryguide_inspection`
contains more background.
For a Core statement, the structure returned by this accessor
is derived from the :attr:`.UpdateBase.table` attribute, and
refers to the :class:`.Table` being inserted, updated, or deleted::
>>> stmt = insert(user_table)
>>> stmt.entity_description
{
"name": "user_table",
"table": Table("user_table", ...)
}
.. versionadded:: 1.4.33
.. seealso::
:attr:`.UpdateBase.returning_column_descriptions`
:attr:`.Select.column_descriptions` - entity information for
a :func:`.select` construct
:ref:`queryguide_inspection` - ORM background
)rQr<>rv<00>rm<00>meths rW<00>entity_descriptionzUpdateBase.entity_descriptionqs%<00><00>B<18>(<28>(<28><14>.<2E>E<>E<><04><13>D<EFBFBD>z<EFBFBD>rZc<01>P<00>tj|<00>j}||<00>S)a<>Return a :term:`plugin-enabled` description of the columns
which this DML construct is RETURNING against, in other words
the expressions established as part of :meth:`.UpdateBase.returning`.
This attribute is generally useful when using the ORM, as an
extended structure which includes information about mapped
entities is returned. The section :ref:`queryguide_inspection`
contains more background.
For a Core statement, the structure returned by this accessor is
derived from the same objects that are returned by the
<0E>(<14><11>(<14>T<0E>!<1A><0E>!<1A>F<0E>,<1A><0E>,rZrhc<01><><00>eZdZUdZdZdZdZded<dZded<dZ d ed
<dZ
ded
<dZded<dZded<dZ
ded<dd<14>Zeeddddd<17><02><18>dd<19><04><00>Zy)r<>zTSupplies support for :meth:`.ValuesBase.values` to
INSERT and UPDATE constructs.<2E>values_baseFNzOptional[Select[Any]]<5D>selectzOptional[ClauseElement]<5D>_post_values_clausez4Optional[util.immutabledict[_DMLColumnElement, Any]]r<>rTzRTuple[Union[Sequence[Dict[_DMLColumnElement, Any]], Sequence[Sequence[Any]]], ...]r<>rdrezOptional[List[str]]r<>r<><00>_inlinec<01>Z<00>tjtj||<00><01>|_y<00>N<><01>apply_propagate_attrs<72>rr<>rr2rs<00>rmrss rWrpzValuesBase.__init__<5F><00>!<00><00><1E>%<25>%<25><11><1E><1E><05>T<EFBFBD>
<EFBFBD><04>
rZz,This construct already inserts from a SELECT<43>1This statement already has ordered values present)r<>re)<01>msgsc<01><><00>|<01>r5|d}|rtjd<02><00>t|<01>dkDrtjd<04><00>t|tj
<00>r<>|rQt|dt<00>r>tj|<00>j}|xj|||<03>fz
c_
|S|r1t|dttf<02>r|xj|fz
c_
|Strt|t<00>sJ<00>t|j j"|<03>D<00><05>cic]\}}|j$|<06><02>}}}n#t'd|<02>}|rtjd<04><00>tj|<00>j(}t
|||j+<00>d<06><00>}|j,r"|j,j/|<08>|_|St1j2|<08>|_|Scc}}w)aYSpecify a fixed VALUES clause for an INSERT statement, or the SET
clause for an UPDATE.
Note that the :class:`_expression.Insert` and
:class:`_expression.Update`
constructs support
per-execution time formatting of the VALUES and/or SET clauses,
based on the arguments passed to :meth:`_engine.Connection.execute`.
However, the :meth:`.ValuesBase.values` method can be used to "fix" a
particular set of parameters into the statement.
Multiple calls to :meth:`.ValuesBase.values` will produce a new
construct, each one with the parameter list modified to include
the new parameters sent. In the typical case of a single
dictionary of parameters, the newly passed keys will replace
the same keys in the previous construct. In the case of a list-based
"multiple values" construct, each new list of values is extended
onto the existing list of values.
:param \**kwargs: key value pairs representing the string key
:param \*args: As an alternative to passing key/value parameters,
a dictionary, tuple, or list of dictionaries or tuples can be passed
as a single positional argument in order to form the VALUES or
SET clause of the statement. The forms that are accepted vary
based on whether this is an :class:`_expression.Insert` or an
:class:`_expression.Update` construct.
For either an :class:`_expression.Insert` or
:class:`_expression.Update`
construct, a single dictionary can be passed, which works the same as
that of the kwargs form::
users.insert().values({"name": "some name"})
users.update().values({"name": "some new name"})
Also for either form but more typically for the
:class:`_expression.Insert` construct, a tuple that contains an
entry for every column in the table is also accepted::
users.insert().values((5, "some name"))
The :class:`_expression.Insert` construct also supports being
passed a list of dictionaries or full-table-tuples, which on the
server will render the less common SQL syntax of "multiple values" -
this syntax is supported on backends such as SQLite, PostgreSQL,
MySQL, but not necessarily others::
users.insert().values(
[
{"name": "some name"},
{"name": "some other name"},
{"name": "yet another name"},
]
)
The above form would render a multiple VALUES statement similar to:
.. sourcecode:: sql
INSERT INTO users (name) VALUES
(:name_1),
(:name_2),
(:name_3)
It is essential to note that **passing multiple values is
NOT the same as using traditional executemany() form**. The above
syntax is a **special** syntax not typically used. To emit an
INSERT statement against multiple rows, the normal method is
to pass a multiple values list to the
:meth:`_engine.Connection.execute`
method, which is supported by all database backends and is generally
more efficient for a very large number of parameters.
.. seealso::
:ref:`tutorial_multiple_parameters` - an introduction to
the traditional Core method of multiple parameter set
invocation for INSERTs and other statements.
The UPDATE construct also supports rendering the SET parameters
in a specific order. For this feature refer to the
:meth:`_expression.Update.ordered_values` method.
.. seealso::
:meth:`_expression.Update.ordered_values`
rz;Can't pass positional and kwargs to values() simultaneouslyrzWOnly a single dictionary/tuple or list of dictionaries/tuples is accepted positionally.zDict[_DMLColumnArgument, Any]T)r9r<00>lenr<6E>r<>r
r<>rQr<>r<>r<>r<>r<>rr<>r<>rsr|r{rr<>r<>r<>rr<00>
immutabledict) rm<00>args<67>kwargsr <00>multi_kv_generatorr|r<><00>kv_generator<6F>coerced_args rWr<>zValuesBase.values<65>s<><00><00>h<10><17>q<EFBFBD>'<27>C<EFBFBD><15><19>'<27>'<27>%<25><12><12><15>T<EFBFBD><19>Q<EFBFBD><1D><19>'<27>'<27>D<01><12><12>
ejfdejfdejfd
ej fdejfdejfdej"fdej$fdejfdej"fdejfgej(zej,zej0zej4zZd"<22>fd<14>Zed#d<15><04>Zed$ d%d<16><05>Ze r<>e!dd<17>d&d<18><06>Z"e!dd<17>d'd<19><06>Z"e!dd<17>d(d<1A><06>Z"e!dd<17>d)d<1B><06>Z"e!dd<17>d*d<1C><06>Z"e!dd<17>d+d<1D><06>Z"e!dd<17>d,d<1E><06>Z"e!dd<17>d-d<1F><06>Z"e!dd<17>d.d <20><06>Z"dd<17>d.d!<21>Z"<22>xZ#S<00>xZ#S)/r<>z<>Represent an INSERT construct.
The :class:`_expression.Insert` object is created using the
:func:`_expression.insert()` function.
r<>TNFr<46>rr4rsrKr<>r<>r<>rIrJr<>r<>rr<>c<01>$<00><01>t<00>|<00>|<01>yrS<00><02>superrp<00>rmrs<00> __class__s<20>rWrpzInsert.__init__<5F><00><00><><00><0A><07><18><15>rZc<01><00>d|_|S)a<>Make this :class:`_expression.Insert` construct "inline" .
When set, no attempt will be made to retrieve the
SQL-generated default values to be provided within the statement;
in particular,
this allows SQL expressions to be rendered 'inline' within the
statement without the need to pre-execute them beforehand; for
backends that support "returning", this turns off the "implicit
returning" feature for the statement.
.. versionchanged:: 1.4 the :paramref:`_expression.Insert.inline`
parameter
is now superseded by the :meth:`_expression.Insert.inline` method.
"<22> '<27>WrZr<>c<01><00>eZdZdZy)<03>ReturningInsertz<74>Typing-only class that establishes a generic type form of
:class:`.Insert` which tracks returned column types.
This datatype is delivered when calling the
:meth:`.Insert.returning` method.
.. versionadded:: 2.0
N<>r<>r<>r<>rArTrZrWr<>r<><00><00><00><00>rZr<>c<01>b<00>eZdZUded<dZded<edd<06><04>Zd
d<07>Zdd<08>Zdd <09>Z e
dd
<EFBFBD><04>Zy)r<>r<>rsrTzTuple[ColumnElement[Any], ...]r<>c<01><><00>|D]>}tjtj||<00><01>}|xj|fz
c_<00>@|S)a<>Return a new construct with the given expression(s) added to
its WHERE clause, joined to the existing clause via AND, if any.
Both :meth:`_dml.Update.where` and :meth:`_dml.Delete.where`
support multiple-table forms, including database-specific
``UPDATE...FROM`` as well as ``DELETE..USING``. For backends that
don't have multiple-table support, a backend agnostic approach
to using multiple tables is to make use of correlated subqueries.
See the linked tutorial sections below for examples.
<14>rZc<01><00>|j|<01>S)zbA synonym for the :meth:`_dml.DMLWhereBase.where` method.
.. versionadded:: 1.4
)r<>)rm<00>criterias rW<00>filterzDMLWhereBase.filter<65>s<00><00><1A>t<EFBFBD>z<EFBFBD>z<EFBFBD>8<EFBFBD>$<24>$rZc<01><00>|jSrS)rsrs rW<00>_filter_by_zerozDMLWhereBase._filter_by_zero<72>s<00><00><13>z<EFBFBD>z<EFBFBD>rZc<01><><00>|j<00>}|j<00>D<00><03>cgc]\}}t||<03>|k(<00><02>}}}|j|<05>Scc}}w)zWapply the given filtering criterion as a WHERE clause
ejfdejfdejfg e
jzej zej$zej(zZd<1A>fd
<0A>Zedd<0E><04>Zedd<0F><04>Zer<>edd<10><04>Zedd<11><04>Zedd<12><04>Zed d<13><04>Zed!d<14><04>Zed"d<15><04>Zed#d<16><04>Zed$d<17><04>Zed%d<18><04>Zd%d<19>Z<1C>xZS<00>xZS)&r<>z<>Represent an Update construct.
The :class:`_expression.Update` object is created using the
:func:`_expression.update()` function.
r<>Trsr<>rKrer<>r<>r<>rr<>c<01>$<00><01>t<00>|<00>|<01>yrSrarcs<20>rWrpzUpdate.__init__rerZc<01><><00>|jrtjd<01><00>|jrtjd<02><00>tj|<00>j}|||d<03>|_|S)a<>Specify the VALUES clause of this UPDATE statement with an explicit
parameter ordering that will be maintained in the SET clause of the
<12> '<27> '<27>4<> '<27>>A<> '<27>
!<21> '<27>krZr<>c<01><00>eZdZdZy)<03>ReturningUpdatez<65>Typing-only class that establishes a generic type form of
:class:`.Update` which tracks returned column types.
<12> '<27> '<27>4<> '<27>>A<> '<27>
!<21> '<27>krZr<>c<01><00>eZdZdZy)<03>ReturningDeletez<65>Typing-only class that establishes a generic type form of
:class:`.Delete` which tracks returned column types.
