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

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._dict_parameters: 

235 spd = compile_state._dict_parameters 

236 stmt_parameter_tuples = list(spd.items()) 

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

238 else: 

239 stmt_parameter_tuples = spd_str_key = None 

240 

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

242 # compiled params 

243 if compiler.column_keys is None: 

244 parameters = {} 

245 elif stmt_parameter_tuples: 

246 assert spd_str_key is not None 

247 parameters = { 

248 _column_as_key(key): REQUIRED 

249 for key in compiler.column_keys 

250 if key not in spd_str_key 

251 } 

252 else: 

253 parameters = { 

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

255 } 

256 

257 # create a list of column assignment clauses as tuples 

258 values: List[_CrudParamElement] = [] 

259 

260 if stmt_parameter_tuples is not None: 

261 _get_stmt_parameter_tuples_params( 

262 compiler, 

263 compile_state, 

264 parameters, 

265 stmt_parameter_tuples, 

266 _column_as_key, 

267 values, 

268 kw, 

269 ) 

270 

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

272 

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

274 # statements 

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

276 _get_update_multitable_params( 

277 compiler, 

278 stmt, 

279 compile_state, 

280 stmt_parameter_tuples, 

281 check_columns, 

282 _col_bind_name, 

283 _getattr_col_key, 

284 values, 

285 kw, 

286 ) 

287 

288 if _compile_state_isinsert(compile_state) and stmt._select_names: 

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

290 

291 assert not compile_state._has_multi_parameters 

292 

293 _scan_insert_from_select_cols( 

294 compiler, 

295 stmt, 

296 compile_state, 

297 parameters, 

298 _getattr_col_key, 

299 _column_as_key, 

300 _col_bind_name, 

301 check_columns, 

302 values, 

303 toplevel, 

304 kw, 

305 ) 

306 use_insertmanyvalues = False 

307 use_sentinel_columns = None 

308 else: 

309 use_insertmanyvalues, use_sentinel_columns = _scan_cols( 

310 compiler, 

311 stmt, 

312 compile_state, 

313 parameters, 

314 _getattr_col_key, 

315 _column_as_key, 

316 _col_bind_name, 

317 check_columns, 

318 values, 

319 toplevel, 

320 kw, 

321 ) 

322 

323 if parameters and stmt_parameter_tuples: 

324 check = ( 

325 set(parameters) 

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

327 .difference(check_columns) 

328 ) 

329 if check: 

330 

331 if dml.isupdate(compile_state): 

332 tables_mentioned = set( 

333 c.table 

334 for c, v in stmt_parameter_tuples 

335 if isinstance(c, ColumnClause) and c.table is not None 

336 ).difference([compile_state.dml_table]) 

337 

338 multi_not_in_from = tables_mentioned.difference( 

339 compile_state._extra_froms 

340 ) 

341 

342 if tables_mentioned and ( 

343 not compile_state.is_multitable 

344 or not compiler.render_table_with_column_in_update_from 

345 ): 

346 if not compiler.render_table_with_column_in_update_from: 

347 preamble = ( 

348 "Backend does not support additional " 

349 "tables in the SET clause" 

350 ) 

351 else: 

352 preamble = ( 

353 "Statement is not a multi-table UPDATE statement" 

354 ) 

355 

356 raise exc.CompileError( 

357 f"{preamble}; cannot " 

358 f"""include columns from table(s) { 

359 ", ".join(f"'{t.description}'" 

360 for t in tables_mentioned) 

361 } in SET clause""" 

362 ) 

363 

364 elif multi_not_in_from: 

365 assert compiler.render_table_with_column_in_update_from 

366 raise exc.CompileError( 

367 f"Multi-table UPDATE statement does not include " 

368 "table(s) " 

369 f"""{ 

370 ", ".join( 

371 f"'{t.description}'" for 

372 t in multi_not_in_from) 

373 }""" 

374 ) 

375 

376 raise exc.CompileError( 

377 "Unconsumed column names: %s" 

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

379 ) 

380 

381 is_default_metavalue_only = False 

382 

383 if ( 

384 _compile_state_isinsert(compile_state) 

385 and compile_state._has_multi_parameters 

386 ): 

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

388 assert not stmt._select_names 

389 multi_extended_values = _extend_values_for_multiparams( 

390 compiler, 

391 stmt, 

392 compile_state, 

393 cast( 

394 "Sequence[_CrudParamElementStr]", 

395 values, 

396 ), 

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

398 kw, 

399 ) 

400 return _CrudParams(values, multi_extended_values) 

401 elif ( 

402 not values 

403 and compiler.for_executemany 

404 and compiler.dialect.supports_default_metavalue 

405 ): 

406 # convert an "INSERT DEFAULT VALUES" 

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

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

409 # insert_executemany_returning mode :) 

410 values = [ 

411 ( 

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

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

414 compiler.dialect.default_metavalue_token, 

415 (), 

416 ) 

417 ] 

418 is_default_metavalue_only = True 

419 

420 return _CrudParams( 

421 values, 

422 [], 

423 is_default_metavalue_only=is_default_metavalue_only, 

424 use_insertmanyvalues=use_insertmanyvalues, 

425 use_sentinel_columns=use_sentinel_columns, 

426 ) 

427 

428 

429@overload 

430def _create_bind_param( 

431 compiler: SQLCompiler, 

432 col: ColumnElement[Any], 

433 value: Any, 

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

435 required: bool = False, 

436 name: Optional[str] = None, 

437 force_anonymous: bool = False, 

438 **kw: Any, 

439) -> str: ... 

440 

441 

442@overload 

443def _create_bind_param( 

444 compiler: SQLCompiler, 

445 col: ColumnElement[Any], 

446 value: Any, 

447 **kw: Any, 

448) -> str: ... 

449 

450 

451def _create_bind_param( 

452 compiler: SQLCompiler, 

453 col: ColumnElement[Any], 

454 value: Any, 

455 process: bool = True, 

456 required: bool = False, 

457 name: Optional[str] = None, 

458 force_anonymous: bool = False, 

459 **kw: Any, 

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

461 if force_anonymous: 

462 name = None 

463 elif name is None: 

464 name = col.key 

465 

466 bindparam = elements.BindParameter( 

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

468 ) 

469 bindparam._is_crud = True 

470 if process: 

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

472 else: 

473 return bindparam 

474 

475 

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

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

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

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

480 # produce bound parameters in deterministic order without invoking any 

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

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

483 # right now). 

484 # 

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

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

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

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

489 # rather than having 

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

491 # name. Saves on call counts also. 

492 

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

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

495 # multiple insert/update are combined together using CTEs 

496 is_cte = "visiting_cte" in kw 

497 

498 if ( 

499 not is_cte 

500 and value.unique 

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

502 ): 

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

504 

505 if value.type._isnull: 

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

507 # passed in directly 

508 # set type to that of the column unconditionally 

509 value = value._with_binary_element_type(col.type) 

510 

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

512 

513 

514def _key_getters_for_crud_column( 

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

516) -> Tuple[ 

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

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

519 _BindNameForColProtocol, 

520]: 

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

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

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

524 # dictionaries and when rendering bind param names. 

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

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

527 # statement. 

528 _et = set(compile_state._extra_froms) 

529 

530 c_key_role = functools.partial( 

531 coercions.expect_as_key, roles.DMLColumnRole 

532 ) 

533 

534 def _column_as_key( 

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

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

537 str_key = c_key_role(key) 

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

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

540 else: 

541 return str_key 

542 

543 def _getattr_col_key( 

544 col: ColumnClause[Any], 

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

546 if col.table in _et: 

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

548 else: 

549 return col.key 

550 

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

552 if col.table in _et: 

553 if TYPE_CHECKING: 

554 assert isinstance(col.table, TableClause) 

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

556 else: 

557 return col.key 

558 

559 else: 

560 _column_as_key = functools.partial( 

561 coercions.expect_as_key, roles.DMLColumnRole 

562 ) 

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

564 

565 return _column_as_key, _getattr_col_key, _col_bind_name 

566 

567 

568def _scan_insert_from_select_cols( 

569 compiler, 

570 stmt, 

571 compile_state, 

572 parameters, 

573 _getattr_col_key, 

574 _column_as_key, 

575 _col_bind_name, 

576 check_columns, 

577 values, 

578 toplevel, 

579 kw, 

580): 

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

582 

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

584 

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

586 

587 add_select_cols: List[_CrudParamElementSQLExpr] = [] 

588 if stmt.include_insert_from_select_defaults: 

589 col_set = set(cols) 

590 for col in stmt.table.columns: 

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

592 # this will omit columns marked as omit_from_statements naturally, 

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

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

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

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

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

598 # here so we again omit it. 

599 if ( 

600 col not in col_set 

601 and col.default 

602 and not col.default.is_sentinel 

603 ): 

604 cols.append(col) 

605 

606 for c in cols: 

607 col_key = _getattr_col_key(c) 

608 if col_key in parameters and col_key not in check_columns: 

609 parameters.pop(col_key) 

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

611 else: 

612 _append_param_insert_select_hasdefault( 

613 compiler, stmt, c, add_select_cols, kw 

614 ) 

615 

616 if add_select_cols: 

617 values.extend(add_select_cols) 

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

619 if not isinstance(ins_from_select, Select): 

620 raise exc.CompileError( 

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

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

623 f"""{ 

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

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

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

627 "columns." 

628 ) 

629 ins_from_select = ins_from_select._generate() 

630 # copy raw_columns 

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

632 expr for _, _, expr, _ in add_select_cols 

633 ] 

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

635 

636 

637def _scan_cols( 

638 compiler, 

639 stmt, 

640 compile_state, 

641 parameters, 

642 _getattr_col_key, 

643 _column_as_key, 

644 _col_bind_name, 

645 check_columns, 

646 values, 

647 toplevel, 

648 kw, 

649): 

650 ( 

651 need_pks, 

652 implicit_returning, 

653 implicit_return_defaults, 

654 postfetch_lastrowid, 

655 use_insertmanyvalues, 

656 use_sentinel_columns, 

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

658 

659 assert compile_state.isupdate or compile_state.isinsert 

660 

661 if compile_state._maintain_values_ordering: 

662 parameter_ordering = [ 

663 _column_as_key(key) for key in compile_state._dict_parameters 

664 ] 

665 ordered_keys = set(parameter_ordering) 

666 cols = [ 

667 stmt.table.c[key] 

668 for key in parameter_ordering 

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

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

671 

672 else: 

673 cols = stmt.table.columns 

674 

675 isinsert = _compile_state_isinsert(compile_state) 

676 if isinsert and not compile_state._has_multi_parameters: 

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

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

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

680 autoincrement_col = stmt.table._autoincrement_column 

681 insert_null_pk_still_autoincrements = ( 

682 compiler.dialect.insert_null_pk_still_autoincrements 

683 ) 

684 else: 

685 autoincrement_col = insert_null_pk_still_autoincrements = None 

686 

687 if stmt._supplemental_returning: 

688 supplemental_returning = set(stmt._supplemental_returning) 

689 else: 

690 supplemental_returning = set() 

691 

692 compiler_implicit_returning = compiler.implicit_returning 

693 

694 # TODO - see TODO(return_defaults_columns) below 

695 # cols_in_params = set() 

696 

697 for c in cols: 

698 # scan through every column in the target table 

699 

700 col_key = _getattr_col_key(c) 

701 

702 if col_key in parameters and col_key not in check_columns: 

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

704 

705 _append_param_parameter( 

706 compiler, 

707 stmt, 

708 compile_state, 

709 c, 

710 col_key, 

711 parameters, 

712 _col_bind_name, 

713 implicit_returning, 

714 implicit_return_defaults, 

715 postfetch_lastrowid, 

716 values, 

717 autoincrement_col, 

718 insert_null_pk_still_autoincrements, 

719 kw, 

720 ) 

721 

722 # TODO - see TODO(return_defaults_columns) below 

723 # cols_in_params.add(c) 

724 

725 elif isinsert: 

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

727 

728 if c.primary_key and need_pks: 

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

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

731 # inserted_primary_key to be available. 

732 

733 if implicit_returning: 

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

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

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

737 

738 _append_param_insert_pk_returning( 

739 compiler, stmt, c, values, kw 

740 ) 

741 else: 

742 # otherwise, find out how to invoke this column 

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

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

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

746 # autoincrement column and the dialect supports it 

747 # we can use cursor.lastrowid. 

748 

749 _append_param_insert_pk_no_returning( 

750 compiler, stmt, c, values, kw 

751 ) 

752 

753 elif c.default is not None: 

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

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

756 if not c.default.is_sentinel or ( 

757 use_sentinel_columns is not None 

758 ): 

759 _append_param_insert_hasdefault( 

760 compiler, stmt, c, implicit_return_defaults, values, kw 

761 ) 

762 

763 elif c.server_default is not None: 

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

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

766 if implicit_return_defaults and c in implicit_return_defaults: 

767 compiler_implicit_returning.append(c) 

768 elif not c.primary_key: 

769 compiler.postfetch.append(c) 

770 

771 elif implicit_return_defaults and c in implicit_return_defaults: 

772 compiler_implicit_returning.append(c) 

773 

774 elif ( 

775 c.primary_key 

776 and c is not stmt.table._autoincrement_column 

777 and not c.nullable 

778 ): 

779 _warn_pk_with_no_anticipated_value(c) 

780 

781 elif compile_state.isupdate: 

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

783 

784 _append_param_update( 

785 compiler, 

786 compile_state, 

787 stmt, 

788 c, 

789 implicit_return_defaults, 

790 values, 

791 kw, 

792 ) 

793 

794 # adding supplemental cols to implicit_returning in table 

795 # order so that order is maintained between multiple INSERT 

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

797 # have the same RETURNING clause 

798 if ( 

799 c in supplemental_returning 

800 and c not in compiler_implicit_returning 

801 ): 

802 compiler_implicit_returning.append(c) 

803 

804 if supplemental_returning: 

805 # we should have gotten every col into implicit_returning, 

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

807 # in it 

808 remaining_supplemental = supplemental_returning.difference( 

809 compiler_implicit_returning 

810 ) 

811 compiler_implicit_returning.extend( 

812 c 

813 for c in stmt._supplemental_returning 

814 if c in remaining_supplemental 

815 ) 

816 

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

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

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

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

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

822 

823 # if stmt._return_defaults_columns: 

824 # compiler_implicit_returning.extend( 

825 # set(stmt._return_defaults_columns) 

826 # .difference(compiler_implicit_returning) 

827 # .difference(cols_in_params) 

828 # ) 

829 

830 return (use_insertmanyvalues, use_sentinel_columns) 

831 

832 

833def _setup_delete_return_defaults( 

834 compiler, 

835 stmt, 

836 compile_state, 

837 parameters, 

838 _getattr_col_key, 

839 _column_as_key, 

840 _col_bind_name, 

841 check_columns, 

842 values, 

843 toplevel, 

844 kw, 

845): 

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

847 compiler, stmt, compile_state, toplevel 

848 ) 

849 

850 if not implicit_return_defaults: 

851 return 

852 

853 if stmt._return_defaults_columns: 

854 compiler.implicit_returning.extend(implicit_return_defaults) 

855 

856 if stmt._supplemental_returning: 

857 ir_set = set(compiler.implicit_returning) 

858 compiler.implicit_returning.extend( 

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

860 ) 

861 

862 

863def _append_param_parameter( 

864 compiler, 

865 stmt, 

866 compile_state, 

867 c, 

868 col_key, 

869 parameters, 

870 _col_bind_name, 

871 implicit_returning, 

872 implicit_return_defaults, 

873 postfetch_lastrowid, 

874 values, 

875 autoincrement_col, 

876 insert_null_pk_still_autoincrements, 

877 kw, 

878): 

879 value = parameters.pop(col_key) 

880 

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

882 col_value = compiler.preparer.format_column( 

883 c, use_table=compile_state.include_table_with_column_exprs 

884 ) 

885 

886 accumulated_bind_names: Set[str] = set() 

887 

888 if coercions._is_literal(value): 

889 if ( 

890 insert_null_pk_still_autoincrements 

891 and c.primary_key 

892 and c is autoincrement_col 

893 ): 

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

895 # even if value was given. 

896 

897 if postfetch_lastrowid: 

898 compiler.postfetch_lastrowid = True 

899 elif implicit_returning: 

900 compiler.implicit_returning.append(c) 

901 

902 value = _create_bind_param( 

903 compiler, 

904 c, 

905 value, 

906 required=value is REQUIRED, 

907 name=( 

908 _col_bind_name(c) 

909 if not _compile_state_isinsert(compile_state) 

910 or not compile_state._has_multi_parameters 

911 else "%s_m0" % _col_bind_name(c) 

912 ), 

913 accumulate_bind_names=accumulated_bind_names, 

914 force_anonymous=has_visiting_cte, 

915 **kw, 

916 ) 

917 elif value._is_bind_parameter: 

918 if ( 

919 insert_null_pk_still_autoincrements 

920 and value.value is None 

921 and c.primary_key 

922 and c is autoincrement_col 

923 ): 

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

925 # even if value was given 

926 if implicit_returning: 

927 compiler.implicit_returning.append(c) 

928 elif compiler.dialect.postfetch_lastrowid: 

929 compiler.postfetch_lastrowid = True 

930 

931 value = _handle_values_anonymous_param( 

932 compiler, 

933 c, 

934 value, 

935 name=( 

936 _col_bind_name(c) 

937 if not _compile_state_isinsert(compile_state) 

938 or not compile_state._has_multi_parameters 

939 else "%s_m0" % _col_bind_name(c) 

940 ), 

941 accumulate_bind_names=accumulated_bind_names, 

942 **kw, 

943 ) 

944 else: 

945 # value is a SQL expression 

946 value = compiler.process( 

947 value.self_group(), 

948 accumulate_bind_names=accumulated_bind_names, 

949 **kw, 

950 ) 

951 

952 if compile_state.isupdate: 

953 if implicit_return_defaults and c in implicit_return_defaults: 

954 compiler.implicit_returning.append(c) 

955 

956 else: 

957 compiler.postfetch.append(c) 

958 else: 

959 if c.primary_key: 

960 if implicit_returning: 

961 compiler.implicit_returning.append(c) 

962 elif compiler.dialect.postfetch_lastrowid: 

963 compiler.postfetch_lastrowid = True 

964 

965 elif implicit_return_defaults and (c in implicit_return_defaults):