Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/sqlalchemy/sql/crud.py: 41%

1# sql/crud.py 

2# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors 

3# <see AUTHORS file> 

4# 

5# This module is part of SQLAlchemy and is released under 

6# the MIT License: https://www.opensource.org/licenses/mit-license.php 

7# mypy: allow-untyped-defs, allow-untyped-calls 

8 

9"""Functions used by compiler.py to determine the parameters rendered 

10within INSERT and UPDATE statements. 

11 

12""" 

13from __future__ import annotations 

14 

15import functools 

16import operator 

17from typing import Any 

18from typing import Callable 

19from typing import cast 

20from typing import Dict 

21from typing import Iterable 

22from typing import List 

23from typing import MutableMapping 

24from typing import NamedTuple 

25from typing import Optional 

26from typing import overload 

27from typing import Sequence 

28from typing import Set 

29from typing import Tuple 

30from typing import TYPE_CHECKING 

31from typing import Union 

32 

33from . import coercions 

34from . import dml 

35from . import elements 

36from . import roles 

37from .base import _DefaultDescriptionTuple 

38from .dml import isinsert as _compile_state_isinsert 

39from .elements import ColumnClause 

40from .schema import default_is_clause_element 

41from .schema import default_is_sequence 

42from .selectable import Select 

43from .selectable import TableClause 

44from .. import exc 

45from .. import util 

46from ..util.typing import Literal 

47 

48if TYPE_CHECKING: 

49 from .compiler import _BindNameForColProtocol 

50 from .compiler import SQLCompiler 

51 from .dml import _DMLColumnElement 

52 from .dml import DMLState 

53 from .dml import ValuesBase 

54 from .elements import ColumnElement 

55 from .elements import KeyedColumnElement 

56 from .schema import _SQLExprDefault 

57 from .schema import Column 

58 

59REQUIRED = util.symbol( 

60 "REQUIRED", 

61 """ 

62Placeholder for the value within a :class:`.BindParameter` 

63which is required to be present when the statement is passed 

64to :meth:`_engine.Connection.execute`. 

65 

66This symbol is typically used when a :func:`_expression.insert` 

67or :func:`_expression.update` statement is compiled without parameter 

68values present. 

69 

70""", 

71) 

72 

73 

74def _as_dml_column(c: ColumnElement[Any]) -> ColumnClause[Any]: 

75 if not isinstance(c, ColumnClause): 

76 raise exc.CompileError( 

77 f"Can't create DML statement against column expression {c!r}" 

78 ) 

79 return c 

80 

81 

82_CrudParamElement = Tuple[ 

83 "ColumnElement[Any]", 

84 str, # column name 

85 Optional[ 

86 Union[str, "_SQLExprDefault"] 

87 ], # bound parameter string or SQL expression to apply 

88 Iterable[str], 

89] 

90_CrudParamElementStr = Tuple[ 

91 "KeyedColumnElement[Any]", 

92 str, # column name 

93 str, # bound parameter string 

94 Iterable[str], 

95] 

96_CrudParamElementSQLExpr = Tuple[ 

97 "ColumnClause[Any]", 

98 str, 

99 "_SQLExprDefault", # SQL expression to apply 

100 Iterable[str], 

101] 

102 

103_CrudParamSequence = List[_CrudParamElement] 

104 

105 

106class _CrudParams(NamedTuple): 

107 single_params: _CrudParamSequence 

108 all_multi_params: List[Sequence[_CrudParamElementStr]] 

109 is_default_metavalue_only: bool = False 

110 use_insertmanyvalues: bool = False 

111 use_sentinel_columns: Optional[Sequence[Column[Any]]] = None 

112 

113 

114def _get_crud_params( 

115 compiler: SQLCompiler, 

116 stmt: ValuesBase, 

117 compile_state: DMLState, 

118 toplevel: bool, 

119 **kw: Any, 

120) -> _CrudParams: 

121 """create a set of tuples representing column/string pairs for use 

122 in an INSERT or UPDATE statement. 

123 

124 Also generates the Compiled object's postfetch, prefetch, and 

125 returning column collections, used for default handling and ultimately 

126 populating the CursorResult's prefetch_cols() and postfetch_cols() 

127 collections. 

128 

129 """ 

130 

131 # note: the _get_crud_params() system was written with the notion in mind 

132 # that INSERT, UPDATE, DELETE are always the top level statement and 

133 # that there is only one of them. With the addition of CTEs that can 

134 # make use of DML, this assumption is no longer accurate; the DML 

135 # statement is not necessarily the top-level "row returning" thing 

136 # and it is also theoretically possible (fortunately nobody has asked yet) 

137 # to have a single statement with multiple DMLs inside of it via CTEs. 

138 

139 # the current _get_crud_params() design doesn't accommodate these cases 

140 # right now. It "just works" for a CTE that has a single DML inside of 

141 # it, and for a CTE with multiple DML, it's not clear what would happen. 

142 

143 # overall, the "compiler.XYZ" collections here would need to be in a 

144 # per-DML structure of some kind, and DefaultDialect would need to 

145 # navigate these collections on a per-statement basis, with additional 

146 # emphasis on the "toplevel returning data" statement. However we 

147 # still need to run through _get_crud_params() for all DML as we have 

148 # Python / SQL generated column defaults that need to be rendered. 

149 

150 # if there is user need for this kind of thing, it's likely a post 2.0 

151 # kind of change as it would require deep changes to DefaultDialect 

152 # as well as here. 

153 

154 compiler.postfetch = [] 

155 compiler.insert_prefetch = [] 

156 compiler.update_prefetch = [] 

157 compiler.implicit_returning = [] 

158 

159 visiting_cte = kw.get("visiting_cte", None) 

160 if visiting_cte is not None: 

161 # for insert -> CTE -> insert, don't populate an incoming 

162 # _crud_accumulate_bind_names collection; the INSERT we process here 

163 # will not be inline within the VALUES of the enclosing INSERT as the 

164 # CTE is placed on the outside. See issue #9173 

165 kw.pop("accumulate_bind_names", None) 

166 assert ( 

167 "accumulate_bind_names" not in kw 

168 ), "Don't know how to handle insert within insert without a CTE" 

169 

170 # getters - these are normally just column.key, 

171 # but in the case of mysql multi-table update, the rules for 

172 # .key must conditionally take tablename into account 

173 ( 

174 _column_as_key, 

175 _getattr_col_key, 

176 _col_bind_name, 

177 ) = _key_getters_for_crud_column(compiler, stmt, compile_state) 

178 

179 compiler._get_bind_name_for_col = _col_bind_name 

180 

181 if stmt._returning and stmt._return_defaults: 

182 raise exc.CompileError( 

183 "Can't compile statement that includes returning() and " 

184 "return_defaults() simultaneously" 

185 ) 

186 

187 if compile_state.isdelete: 

188 _setup_delete_return_defaults( 

189 compiler, 

190 stmt, 

191 compile_state, 

192 (), 

193 _getattr_col_key, 

194 _column_as_key, 

195 _col_bind_name, 

196 (), 

197 (), 

198 toplevel, 

199 kw, 

200 ) 

201 return _CrudParams([], []) 

202 

203 # no parameters in the statement, no parameters in the 

204 # compiled params - return binds for all columns 

205 if compiler.column_keys is None and compile_state._no_parameters: 

206 return _CrudParams( 

207 [ 

208 ( 

209 c, 

210 compiler.preparer.format_column(c), 

211 _create_bind_param(compiler, c, None, required=True), 

212 (c.key,), 

213 ) 

214 for c in stmt.table.columns 

215 if not c._omit_from_statements 

216 ], 

217 [], 

218 ) 

219 

220 stmt_parameter_tuples: Optional[ 

221 List[Tuple[Union[str, ColumnClause[Any]], Any]] 

222 ] 

223 spd: Optional[MutableMapping[_DMLColumnElement, Any]] 

224 

225 if ( 

226 _compile_state_isinsert(compile_state) 

227 and compile_state._has_multi_parameters 

228 ): 

229 mp = compile_state._multi_parameters 

230 assert mp is not None 

231 spd = mp[0] 

232 stmt_parameter_tuples = list(spd.items()) 

233 spd_str_key = {_column_as_key(key) for key in spd} 

234 elif compile_state._ordered_values: 

235 spd = compile_state._dict_parameters 

236 stmt_parameter_tuples = compile_state._ordered_values 

237 assert spd is not None 

238 spd_str_key = {_column_as_key(key) for key in spd} 

239 elif compile_state._dict_parameters: 

240 spd = compile_state._dict_parameters 

241 stmt_parameter_tuples = list(spd.items()) 

242 spd_str_key = {_column_as_key(key) for key in spd} 

243 else: 

244 stmt_parameter_tuples = spd_str_key = None 

245 

246 # if we have statement parameters - set defaults in the 

247 # compiled params 

248 if compiler.column_keys is None: 

249 parameters = {} 

250 elif stmt_parameter_tuples: 

251 assert spd_str_key is not None 

252 parameters = { 

253 _column_as_key(key): REQUIRED 

254 for key in compiler.column_keys 

255 if key not in spd_str_key 

256 } 

257 else: 

258 parameters = { 

259 _column_as_key(key): REQUIRED for key in compiler.column_keys 

260 } 

261 

262 # create a list of column assignment clauses as tuples 

263 values: List[_CrudParamElement] = [] 

264 

265 if stmt_parameter_tuples is not None: 

266 _get_stmt_parameter_tuples_params( 

267 compiler, 

268 compile_state, 

269 parameters, 

270 stmt_parameter_tuples, 

271 _column_as_key, 

272 values, 

273 kw, 

274 ) 

275 

276 check_columns: Dict[str, ColumnClause[Any]] = {} 

277 

278 # special logic that only occurs for multi-table UPDATE 

279 # statements 

280 if dml.isupdate(compile_state) and compile_state.is_multitable: 

281 _get_update_multitable_params( 

282 compiler, 

283 stmt, 

284 compile_state, 

285 stmt_parameter_tuples, 

286 check_columns, 

287 _col_bind_name, 

288 _getattr_col_key, 

289 values, 

290 kw, 

291 ) 

292 

293 if _compile_state_isinsert(compile_state) and stmt._select_names: 

294 # is an insert from select, is not a multiparams 

295 

296 assert not compile_state._has_multi_parameters 

297 

298 _scan_insert_from_select_cols( 

299 compiler, 

300 stmt, 

301 compile_state, 

302 parameters, 

303 _getattr_col_key, 

304 _column_as_key, 

305 _col_bind_name, 

306 check_columns, 

307 values, 

308 toplevel, 

309 kw, 

310 ) 

311 use_insertmanyvalues = False 

312 use_sentinel_columns = None 

313 else: 

314 use_insertmanyvalues, use_sentinel_columns = _scan_cols( 

315 compiler, 

316 stmt, 

317 compile_state, 

318 parameters, 

319 _getattr_col_key, 

320 _column_as_key, 

321 _col_bind_name, 

322 check_columns, 

323 values, 

324 toplevel, 

325 kw, 

326 ) 

327 

328 if parameters and stmt_parameter_tuples: 

329 check = ( 

330 set(parameters) 

331 .intersection(_column_as_key(k) for k, v in stmt_parameter_tuples) 

332 .difference(check_columns) 

333 ) 

334 if check: 

335 raise exc.CompileError( 

336 "Unconsumed column names: %s" 

337 % (", ".join("%s" % (c,) for c in check)) 

338 ) 

339 

340 is_default_metavalue_only = False 

341 

342 if ( 

343 _compile_state_isinsert(compile_state) 

344 and compile_state._has_multi_parameters 

345 ): 

346 # is a multiparams, is not an insert from a select 

347 assert not stmt._select_names 

348 multi_extended_values = _extend_values_for_multiparams( 

349 compiler, 

350 stmt, 

351 compile_state, 

352 cast( 

353 "Sequence[_CrudParamElementStr]", 

354 values, 

355 ), 

356 cast("Callable[..., str]", _column_as_key), 

357 kw, 

358 ) 

359 return _CrudParams(values, multi_extended_values) 

360 elif ( 

361 not values 

362 and compiler.for_executemany 

363 and compiler.dialect.supports_default_metavalue 

364 ): 

365 # convert an "INSERT DEFAULT VALUES" 

366 # into INSERT (firstcol) VALUES (DEFAULT) which can be turned 

367 # into an in-place multi values. This supports 

368 # insert_executemany_returning mode :) 

369 values = [ 

370 ( 

371 _as_dml_column(stmt.table.columns[0]), 

372 compiler.preparer.format_column(stmt.table.columns[0]), 

373 compiler.dialect.default_metavalue_token, 

374 (), 

375 ) 

376 ] 

377 is_default_metavalue_only = True 

378 

379 return _CrudParams( 

380 values, 

381 [], 

382 is_default_metavalue_only=is_default_metavalue_only, 

383 use_insertmanyvalues=use_insertmanyvalues, 

384 use_sentinel_columns=use_sentinel_columns, 

385 ) 

386 

387 

388@overload 

389def _create_bind_param( 

390 compiler: SQLCompiler, 

391 col: ColumnElement[Any], 

392 value: Any, 

393 process: Literal[True] = ..., 

394 required: bool = False, 

395 name: Optional[str] = None, 

396 force_anonymous: bool = False, 

397 **kw: Any, 

398) -> str: ... 

399 

400 

401@overload 

402def _create_bind_param( 

403 compiler: SQLCompiler, 

404 col: ColumnElement[Any], 

405 value: Any, 

406 **kw: Any, 

407) -> str: ... 

408 

409 

410def _create_bind_param( 

411 compiler: SQLCompiler, 

412 col: ColumnElement[Any], 

413 value: Any, 

414 process: bool = True, 

415 required: bool = False, 

416 name: Optional[str] = None, 

417 force_anonymous: bool = False, 

418 **kw: Any, 

419) -> Union[str, elements.BindParameter[Any]]: 

420 if force_anonymous: 

421 name = None 

422 elif name is None: 

423 name = col.key 

424 

425 bindparam = elements.BindParameter( 

426 name, value, type_=col.type, required=required 

427 ) 

428 bindparam._is_crud = True 

429 if process: 

430 return bindparam._compiler_dispatch(compiler, **kw) 

431 else: 

432 return bindparam 

433 

434 

435def _handle_values_anonymous_param(compiler, col, value, name, **kw): 

436 # the insert() and update() constructs as of 1.4 will now produce anonymous 

437 # bindparam() objects in the values() collections up front when given plain 

438 # literal values. This is so that cache key behaviors, which need to 

439 # produce bound parameters in deterministic order without invoking any 

440 # compilation here, can be applied to these constructs when they include 

441 # values() (but not yet multi-values, which are not included in caching 

442 # right now). 

443 # 

444 # in order to produce the desired "crud" style name for these parameters, 

445 # which will also be targetable in engine/default.py through the usual 

446 # conventions, apply our desired name to these unique parameters by 

447 # populating the compiler truncated names cache with the desired name, 

448 # rather than having 

449 # compiler.visit_bindparam()->compiler._truncated_identifier make up a 

450 # name. Saves on call counts also. 

451 

452 # for INSERT/UPDATE that's a CTE, we don't need names to match to 

453 # external parameters and these would also conflict in the case where 

454 # multiple insert/update are combined together using CTEs 

455 is_cte = "visiting_cte" in kw 

456 

457 if ( 

458 not is_cte 

459 and value.unique 

460 and isinstance(value.key, elements._truncated_label) 

461 ): 

462 compiler.truncated_names[("bindparam", value.key)] = name 

463 

464 if value.type._isnull: 

465 # either unique parameter, or other bound parameters that were 

466 # passed in directly 

467 # set type to that of the column unconditionally 

468 value = value._with_binary_element_type(col.type) 

469 

470 return value._compiler_dispatch(compiler, **kw) 

471 

472 

473def _key_getters_for_crud_column( 

474 compiler: SQLCompiler, stmt: ValuesBase, compile_state: DMLState 

475) -> Tuple[ 

476 Callable[[Union[str, ColumnClause[Any]]], Union[str, Tuple[str, str]]], 

477 Callable[[ColumnClause[Any]], Union[str, Tuple[str, str]]], 

478 _BindNameForColProtocol, 

479]: 

480 if dml.isupdate(compile_state) and compile_state._extra_froms: 

481 # when extra tables are present, refer to the columns 

482 # in those extra tables as table-qualified, including in 

483 # dictionaries and when rendering bind param names. 

484 # the "main" table of the statement remains unqualified, 

485 # allowing the most compatibility with a non-multi-table 

486 # statement. 

487 _et = set(compile_state._extra_froms) 

488 

489 c_key_role = functools.partial( 

490 coercions.expect_as_key, roles.DMLColumnRole 

491 ) 

492 

493 def _column_as_key( 

494 key: Union[ColumnClause[Any], str], 

495 ) -> Union[str, Tuple[str, str]]: 

496 str_key = c_key_role(key) 

497 if hasattr(key, "table") and key.table in _et: 

498 return (key.table.name, str_key) # type: ignore 

499 else: 

500 return str_key 

501 

502 def _getattr_col_key( 

503 col: ColumnClause[Any], 

504 ) -> Union[str, Tuple[str, str]]: 

505 if col.table in _et: 

506 return (col.table.name, col.key) # type: ignore 

507 else: 

508 return col.key 

509 

510 def _col_bind_name(col: ColumnClause[Any]) -> str: 

511 if col.table in _et: 

512 if TYPE_CHECKING: 

513 assert isinstance(col.table, TableClause) 

514 return "%s_%s" % (col.table.name, col.key) 

515 else: 

516 return col.key 

517 

518 else: 

519 _column_as_key = functools.partial( 

520 coercions.expect_as_key, roles.DMLColumnRole 

521 ) 

522 _getattr_col_key = _col_bind_name = operator.attrgetter("key") # type: ignore # noqa: E501 

523 

524 return _column_as_key, _getattr_col_key, _col_bind_name 

525 

526 

527def _scan_insert_from_select_cols( 

528 compiler, 

529 stmt, 

530 compile_state, 

531 parameters, 

532 _getattr_col_key, 

533 _column_as_key, 

534 _col_bind_name, 

535 check_columns, 

536 values, 

537 toplevel, 

538 kw, 

539): 

540 cols = [stmt.table.c[_column_as_key(name)] for name in stmt._select_names] 

541 

542 assert compiler.stack[-1]["selectable"] is stmt 

543 

544 compiler.stack[-1]["insert_from_select"] = stmt.select 

545 

546 add_select_cols: List[_CrudParamElementSQLExpr] = [] 

547 if stmt.include_insert_from_select_defaults: 

548 col_set = set(cols) 

549 for col in stmt.table.columns: 

550 # omit columns that were not in the SELECT statement. 

551 # this will omit columns marked as omit_from_statements naturally, 

552 # as long as that col was not explicit in the SELECT. 

553 # if an omit_from_statements col has a "default" on it, then 

554 # we need to include it, as these defaults should still fire off. 

555 # but, if it has that default and it's the "sentinel" default, 

556 # we don't do sentinel default operations for insert_from_select 

557 # here so we again omit it. 

558 if ( 

559 col not in col_set 

560 and col.default 

561 and not col.default.is_sentinel 

562 ): 

563 cols.append(col) 

564 

565 for c in cols: 

566 col_key = _getattr_col_key(c) 

567 if col_key in parameters and col_key not in check_columns: 

568 parameters.pop(col_key) 

569 values.append((c, compiler.preparer.format_column(c), None, ())) 

570 else: 

571 _append_param_insert_select_hasdefault( 

572 compiler, stmt, c, add_select_cols, kw 

573 ) 

574 

575 if add_select_cols: 

576 values.extend(add_select_cols) 

577 ins_from_select = compiler.stack[-1]["insert_from_select"] 

578 if not isinstance(ins_from_select, Select): 

579 raise exc.CompileError( 

580 f"Can't extend statement for INSERT..FROM SELECT to include " 

581 f"additional default-holding column(s) " 

582 f"""{ 

583 ', '.join(repr(key) for _, key, _, _ in add_select_cols) 

584 }. Convert the selectable to a subquery() first, or pass """ 

585 "include_defaults=False to Insert.from_select() to skip these " 

586 "columns." 

587 ) 

588 ins_from_select = ins_from_select._generate() 

589 # copy raw_columns 

590 ins_from_select._raw_columns = list(ins_from_select._raw_columns) + [ 

591 expr for _, _, expr, _ in add_select_cols 

592 ] 

593 compiler.stack[-1]["insert_from_select"] = ins_from_select 

594 

595 

596def _scan_cols( 

597 compiler, 

598 stmt, 

599 compile_state, 

600 parameters, 

601 _getattr_col_key, 

602 _column_as_key, 

603 _col_bind_name, 

604 check_columns, 

605 values, 

606 toplevel, 

607 kw, 

608): 

609 ( 

610 need_pks, 

611 implicit_returning, 

612 implicit_return_defaults, 

613 postfetch_lastrowid, 

614 use_insertmanyvalues, 

615 use_sentinel_columns, 

616 ) = _get_returning_modifiers(compiler, stmt, compile_state, toplevel) 

617 

618 assert compile_state.isupdate or compile_state.isinsert 

619 

620 if compile_state._parameter_ordering: 

621 parameter_ordering = [ 

622 _column_as_key(key) for key in compile_state._parameter_ordering 

623 ] 

624 ordered_keys = set(parameter_ordering) 

625 cols = [ 

626 stmt.table.c[key] 

627 for key in parameter_ordering 

628 if isinstance(key, str) and key in stmt.table.c 

629 ] + [c for c in stmt.table.c if c.key not in ordered_keys] 

630 

631 else: 

632 cols = stmt.table.columns 

633 

634 isinsert = _compile_state_isinsert(compile_state) 

635 if isinsert and not compile_state._has_multi_parameters: 

636 # new rules for #7998. fetch lastrowid or implicit returning 

637 # for autoincrement column even if parameter is NULL, for DBs that 

638 # override NULL param for primary key (sqlite, mysql/mariadb) 

639 autoincrement_col = stmt.table._autoincrement_column 

640 insert_null_pk_still_autoincrements = ( 

641 compiler.dialect.insert_null_pk_still_autoincrements 

642 ) 

643 else: 

644 autoincrement_col = insert_null_pk_still_autoincrements = None 

645 

646 if stmt._supplemental_returning: 

647 supplemental_returning = set(stmt._supplemental_returning) 

648 else: 

649 supplemental_returning = set() 

650 

651 compiler_implicit_returning = compiler.implicit_returning 

652 

653 # TODO - see TODO(return_defaults_columns) below 

654 # cols_in_params = set() 

655 

656 for c in cols: 

657 # scan through every column in the target table 

658 

659 col_key = _getattr_col_key(c) 

660 

661 if col_key in parameters and col_key not in check_columns: 

662 # parameter is present for the column. use that. 

663 

664 _append_param_parameter( 

665 compiler, 

666 stmt, 

667 compile_state, 

668 c, 

669 col_key, 

670 parameters, 

671 _col_bind_name, 

672 implicit_returning, 

673 implicit_return_defaults, 

674 postfetch_lastrowid, 

675 values, 

676 autoincrement_col, 

677 insert_null_pk_still_autoincrements, 

678 kw, 

679 ) 

680 

681 # TODO - see TODO(return_defaults_columns) below 

682 # cols_in_params.add(c) 

683 

684 elif isinsert: 

685 # no parameter is present and it's an insert. 

686 

687 if c.primary_key and need_pks: 

688 # it's a primary key column, it will need to be generated by a 

689 # default generator of some kind, and the statement expects 

690 # inserted_primary_key to be available. 

691 

692 if implicit_returning: 

693 # we can use RETURNING, find out how to invoke this 

694 # column and get the value where RETURNING is an option. 

695 # we can inline server-side functions in this case. 

696 

697 _append_param_insert_pk_returning( 

698 compiler, stmt, c, values, kw 

699 ) 

700 else: 

701 # otherwise, find out how to invoke this column 

702 # and get its value where RETURNING is not an option. 

703 # if we have to invoke a server-side function, we need 

704 # to pre-execute it. or if this is a straight 

705 # autoincrement column and the dialect supports it 

706 # we can use cursor.lastrowid. 

707 

708 _append_param_insert_pk_no_returning( 

709 compiler, stmt, c, values, kw 

710 ) 

711 

712 elif c.default is not None: 

713 # column has a default, but it's not a pk column, or it is but 

714 # we don't need to get the pk back. 

715 if not c.default.is_sentinel or ( 

716 use_sentinel_columns is not None 

717 ): 

718 _append_param_insert_hasdefault( 

719 compiler, stmt, c, implicit_return_defaults, values, kw 

720 ) 

721 

722 elif c.server_default is not None: 

723 # column has a DDL-level default, and is either not a pk 

724 # column or we don't need the pk. 

725 if implicit_return_defaults and c in implicit_return_defaults: 

726 compiler_implicit_returning.append(c) 

727 elif not c.primary_key: 

728 compiler.postfetch.append(c) 

729 

730 elif implicit_return_defaults and c in implicit_return_defaults: 

731 compiler_implicit_returning.append(c) 

732 

733 elif ( 

734 c.primary_key 

735 and c is not stmt.table._autoincrement_column 

736 and not c.nullable 

737 ): 

738 _warn_pk_with_no_anticipated_value(c) 

739 

740 elif compile_state.isupdate: 

741 # no parameter is present and it's an insert. 

742 

743 _append_param_update( 

744 compiler, 

745 compile_state, 

746 stmt, 

747 c, 

748 implicit_return_defaults, 

749 values, 

750 kw, 

751 ) 

752 

753 # adding supplemental cols to implicit_returning in table 

754 # order so that order is maintained between multiple INSERT 

755 # statements which may have different parameters included, but all 

756 # have the same RETURNING clause 

757 if ( 

758 c in supplemental_returning 

759 and c not in compiler_implicit_returning 

760 ): 

761 compiler_implicit_returning.append(c) 

762 

763 if supplemental_returning: 

764 # we should have gotten every col into implicit_returning, 

765 # however supplemental returning can also have SQL functions etc. 

766 # in it 

767 remaining_supplemental = supplemental_returning.difference( 

768 compiler_implicit_returning 

769 ) 

770 compiler_implicit_returning.extend( 

771 c 

772 for c in stmt._supplemental_returning 

773 if c in remaining_supplemental 

774 ) 

775 

776 # TODO(return_defaults_columns): there can still be more columns in 

777 # _return_defaults_columns in the case that they are from something like an 

778 # aliased of the table. we can add them here, however this breaks other ORM 

779 # things. so this is for another day. see 

780 # test/orm/dml/test_update_delete_where.py -> test_update_from_alias 

781 

782 # if stmt._return_defaults_columns: 

783 # compiler_implicit_returning.extend( 

784 # set(stmt._return_defaults_columns) 

785 # .difference(compiler_implicit_returning) 

786 # .difference(cols_in_params) 

787 # ) 

788 

789 return (use_insertmanyvalues, use_sentinel_columns) 

790 

791 

792def _setup_delete_return_defaults( 

793 compiler, 

794 stmt, 

795 compile_state, 

796 parameters, 

797 _getattr_col_key, 

798 _column_as_key, 

799 _col_bind_name, 

800 check_columns, 

801 values, 

802 toplevel, 

803 kw, 

804): 

805 (_, _, implicit_return_defaults, *_) = _get_returning_modifiers( 

806 compiler, stmt, compile_state, toplevel 

807 ) 

808 

809 if not implicit_return_defaults: 

810 return 

811 

812 if stmt._return_defaults_columns: 

813 compiler.implicit_returning.extend(implicit_return_defaults) 

814 

815 if stmt._supplemental_returning: 

816 ir_set = set(compiler.implicit_returning) 

817 compiler.implicit_returning.extend( 

818 c for c in stmt._supplemental_returning if c not in ir_set 

819 ) 

820 

821 

822def _append_param_parameter( 

823 compiler, 

824 stmt, 

825 compile_state, 

826 c, 

827 col_key, 

828 parameters, 

829 _col_bind_name, 

830 implicit_returning, 

831 implicit_return_defaults, 

832 postfetch_lastrowid, 

833 values, 

834 autoincrement_col, 

835 insert_null_pk_still_autoincrements, 

836 kw, 

837): 

838 value = parameters.pop(col_key) 

839 

840 has_visiting_cte = kw.get("visiting_cte") is not None 

841 col_value = compiler.preparer.format_column( 

842 c, use_table=compile_state.include_table_with_column_exprs 

843 ) 

844 

845 accumulated_bind_names: Set[str] = set() 

846 

847 if coercions._is_literal(value): 

848 if ( 

849 insert_null_pk_still_autoincrements 

850 and c.primary_key 

851 and c is autoincrement_col 

852 ): 

853 # support use case for #7998, fetch autoincrement cols 

854 # even if value was given. 

855 

856 if postfetch_lastrowid: 

857 compiler.postfetch_lastrowid = True 

858 elif implicit_returning: 

859 compiler.implicit_returning.append(c) 

860 

861 value = _create_bind_param( 

862 compiler, 

863 c, 

864 value, 

865 required=value is REQUIRED, 

866 name=( 

867 _col_bind_name(c) 

868 if not _compile_state_isinsert(compile_state) 

869 or not compile_state._has_multi_parameters 

870 else "%s_m0" % _col_bind_name(c) 

871 ), 

872 accumulate_bind_names=accumulated_bind_names, 

873 force_anonymous=has_visiting_cte, 

874 **kw, 

875 ) 

876 elif value._is_bind_parameter: 

877 if ( 

878 insert_null_pk_still_autoincrements 

879 and value.value is None 

880 and c.primary_key 

881 and c is autoincrement_col 

882 ): 

883 # support use case for #7998, fetch autoincrement cols 

884 # even if value was given 

885 if implicit_returning: 

886 compiler.implicit_returning.append(c) 

887 elif compiler.dialect.postfetch_lastrowid: 

888 compiler.postfetch_lastrowid = True 

889 

890 value = _handle_values_anonymous_param( 

891 compiler, 

892 c, 

893 value, 

894 name=( 

895 _col_bind_name(c) 

896 if not _compile_state_isinsert(compile_state) 

897 or not compile_state._has_multi_parameters 

898 else "%s_m0" % _col_bind_name(c) 

899 ), 

900 accumulate_bind_names=accumulated_bind_names, 

901 **kw, 

902 ) 

903 else: 

904 # value is a SQL expression 

905 value = compiler.process( 

906 value.self_group(), 

907 accumulate_bind_names=accumulated_bind_names, 

908 **kw, 

909 ) 

910 

911 if compile_state.isupdate: 

912 if implicit_return_defaults and c in implicit_return_defaults: 

913 compiler.implicit_returning.append(c) 

914 

915 else: 

916 compiler.postfetch.append(c) 

917 else: 

918 if c.primary_key: 

919 if implicit_returning: 

920 compiler.implicit_returning.append(c) 

921 elif compiler.dialect.postfetch_lastrowid: 

922 compiler.postfetch_lastrowid = True 

923 

924 elif implicit_return_defaults and (c in implicit_return_defaults): 

925 compiler.implicit_returning.append(c) 

926 

927 else: 

928 # postfetch specifically means, "we can SELECT the row we just 

929 # inserted by primary key to get back the server generated 

930 # defaults". so by definition this can't be used to get the 

931 # primary key value back, because we need to have it ahead of 

932 # time. 

933 

934 compiler.postfetch.append(c) 

935 

936 values.append((c, col_value, value, accumulated_bind_names)) 

937 

938 

939def _append_param_insert_pk_returning(compiler, stmt, c, values, kw): 

940 """Create a primary key expression in the INSERT statement where 

941 we want to populate result.inserted_primary_key and RETURNING 

942 is available. 

943 

944 """ 

945 if c.default is not None: 

946 if c.default.is_sequence: 

947 if compiler.dialect.supports_sequences and ( 

948 not c.default.optional 

949 or not compiler.dialect.sequences_optional 

950 ): 

951 accumulated_bind_names: Set[str] = set() 

952 values.append( 

953 ( 

954 c, 

955 compiler.preparer.format_column(c), 

956 compiler.process(