Ruud
13 years ago
38 changed files with 2292 additions and 1025 deletions
@ -0,0 +1,777 @@ |
|||
# orm/persistence.py |
|||
# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file> |
|||
# |
|||
# This module is part of SQLAlchemy and is released under |
|||
# the MIT License: http://www.opensource.org/licenses/mit-license.php |
|||
|
|||
"""private module containing functions used to emit INSERT, UPDATE |
|||
and DELETE statements on behalf of a :class:`.Mapper` and its descending |
|||
mappers. |
|||
|
|||
The functions here are called only by the unit of work functions |
|||
in unitofwork.py. |
|||
|
|||
""" |
|||
|
|||
import operator |
|||
from itertools import groupby |
|||
|
|||
from sqlalchemy import sql, util, exc as sa_exc |
|||
from sqlalchemy.orm import attributes, sync, \ |
|||
exc as orm_exc |
|||
|
|||
from sqlalchemy.orm.util import _state_mapper, state_str |
|||
|
|||
def save_obj(base_mapper, states, uowtransaction, single=False): |
|||
"""Issue ``INSERT`` and/or ``UPDATE`` statements for a list |
|||
of objects. |
|||
|
|||
This is called within the context of a UOWTransaction during a |
|||
flush operation, given a list of states to be flushed. The |
|||
base mapper in an inheritance hierarchy handles the inserts/ |
|||
updates for all descendant mappers. |
|||
|
|||
""" |
|||
|
|||
# if batch=false, call _save_obj separately for each object |
|||
if not single and not base_mapper.batch: |
|||
for state in _sort_states(states): |
|||
save_obj(base_mapper, [state], uowtransaction, single=True) |
|||
return |
|||
|
|||
states_to_insert, states_to_update = _organize_states_for_save( |
|||
base_mapper, |
|||
states, |
|||
uowtransaction) |
|||
|
|||
cached_connections = _cached_connection_dict(base_mapper) |
|||
|
|||
for table, mapper in base_mapper._sorted_tables.iteritems(): |
|||
insert = _collect_insert_commands(base_mapper, uowtransaction, |
|||
table, states_to_insert) |
|||
|
|||
update = _collect_update_commands(base_mapper, uowtransaction, |
|||
table, states_to_update) |
|||
|
|||
if update: |
|||
_emit_update_statements(base_mapper, uowtransaction, |
|||
cached_connections, |
|||
mapper, table, update) |
|||
|
|||
if insert: |
|||
_emit_insert_statements(base_mapper, uowtransaction, |
|||
cached_connections, |
|||
table, insert) |
|||
|
|||
_finalize_insert_update_commands(base_mapper, uowtransaction, |
|||
states_to_insert, states_to_update) |
|||
|
|||
def post_update(base_mapper, states, uowtransaction, post_update_cols): |
|||
"""Issue UPDATE statements on behalf of a relationship() which |
|||
specifies post_update. |
|||
|
|||
""" |
|||
cached_connections = _cached_connection_dict(base_mapper) |
|||
|
|||
states_to_update = _organize_states_for_post_update( |
|||
base_mapper, |
|||
states, uowtransaction) |
|||
|
|||
|
|||
for table, mapper in base_mapper._sorted_tables.iteritems(): |
|||
update = _collect_post_update_commands(base_mapper, uowtransaction, |
|||
table, states_to_update, |
|||
post_update_cols) |
|||
|
|||
if update: |
|||
_emit_post_update_statements(base_mapper, uowtransaction, |
|||
cached_connections, |
|||
mapper, table, update) |
|||
|
|||
def delete_obj(base_mapper, states, uowtransaction): |
|||
"""Issue ``DELETE`` statements for a list of objects. |
|||
|
|||
This is called within the context of a UOWTransaction during a |
|||
flush operation. |
|||
|
|||
""" |
|||
|
|||
cached_connections = _cached_connection_dict(base_mapper) |
|||
|
|||
states_to_delete = _organize_states_for_delete( |
|||
base_mapper, |
|||
states, |
|||
uowtransaction) |
|||
|
|||
table_to_mapper = base_mapper._sorted_tables |
|||
|
|||
for table in reversed(table_to_mapper.keys()): |
|||
delete = _collect_delete_commands(base_mapper, uowtransaction, |
|||
table, states_to_delete) |
|||
|
|||
mapper = table_to_mapper[table] |
|||
|
|||
_emit_delete_statements(base_mapper, uowtransaction, |
|||
cached_connections, mapper, table, delete) |
|||
|
|||
for state, state_dict, mapper, has_identity, connection \ |
|||
in states_to_delete: |
|||
mapper.dispatch.after_delete(mapper, connection, state) |
|||
|
|||
def _organize_states_for_save(base_mapper, states, uowtransaction): |
|||
"""Make an initial pass across a set of states for INSERT or |
|||
UPDATE. |
|||
|
|||
This includes splitting out into distinct lists for |
|||
each, calling before_insert/before_update, obtaining |
|||
key information for each state including its dictionary, |
|||
mapper, the connection to use for the execution per state, |
|||
and the identity flag. |
|||
|
|||
""" |
|||
|
|||
states_to_insert = [] |
|||
states_to_update = [] |
|||
|
|||
for state, dict_, mapper, connection in _connections_for_states( |
|||
base_mapper, uowtransaction, |
|||
states): |
|||
|
|||
has_identity = bool(state.key) |
|||
instance_key = state.key or mapper._identity_key_from_state(state) |
|||
|
|||
row_switch = None |
|||
|
|||
# call before_XXX extensions |
|||
if not has_identity: |
|||
mapper.dispatch.before_insert(mapper, connection, state) |
|||
else: |
|||
mapper.dispatch.before_update(mapper, connection, state) |
|||
|
|||
# detect if we have a "pending" instance (i.e. has |
|||
# no instance_key attached to it), and another instance |
|||
# with the same identity key already exists as persistent. |
|||
# convert to an UPDATE if so. |
|||
if not has_identity and \ |
|||
instance_key in uowtransaction.session.identity_map: |
|||
instance = \ |
|||
uowtransaction.session.identity_map[instance_key] |
|||
existing = attributes.instance_state(instance) |
|||
if not uowtransaction.is_deleted(existing): |
|||
raise orm_exc.FlushError( |
|||
"New instance %s with identity key %s conflicts " |
|||
"with persistent instance %s" % |
|||
(state_str(state), instance_key, |
|||
state_str(existing))) |
|||
|
|||
base_mapper._log_debug( |
|||
"detected row switch for identity %s. " |
|||
"will update %s, remove %s from " |
|||
"transaction", instance_key, |
|||
state_str(state), state_str(existing)) |
|||
|
|||
# remove the "delete" flag from the existing element |
|||
uowtransaction.remove_state_actions(existing) |
|||
row_switch = existing |
|||
|
|||
if not has_identity and not row_switch: |
|||
states_to_insert.append( |
|||
(state, dict_, mapper, connection, |
|||
has_identity, instance_key, row_switch) |
|||
) |
|||
else: |
|||
states_to_update.append( |
|||
(state, dict_, mapper, connection, |
|||
has_identity, instance_key, row_switch) |
|||
) |
|||
|
|||
return states_to_insert, states_to_update |
|||
|
|||
def _organize_states_for_post_update(base_mapper, states, |
|||
uowtransaction): |
|||
"""Make an initial pass across a set of states for UPDATE |
|||
corresponding to post_update. |
|||
|
|||
This includes obtaining key information for each state |
|||
including its dictionary, mapper, the connection to use for |
|||
the execution per state. |
|||
|
|||
""" |
|||
return list(_connections_for_states(base_mapper, uowtransaction, |
|||
states)) |
|||
|
|||
def _organize_states_for_delete(base_mapper, states, uowtransaction): |
|||
"""Make an initial pass across a set of states for DELETE. |
|||
|
|||
This includes calling out before_delete and obtaining |
|||
key information for each state including its dictionary, |
|||
mapper, the connection to use for the execution per state. |
|||
|
|||
""" |
|||
states_to_delete = [] |
|||
|
|||
for state, dict_, mapper, connection in _connections_for_states( |
|||
base_mapper, uowtransaction, |
|||
states): |
|||
|
|||
mapper.dispatch.before_delete(mapper, connection, state) |
|||
|
|||
states_to_delete.append((state, dict_, mapper, |
|||
bool(state.key), connection)) |
|||
return states_to_delete |
|||
|
|||
def _collect_insert_commands(base_mapper, uowtransaction, table, |
|||
states_to_insert): |
|||
"""Identify sets of values to use in INSERT statements for a |
|||
list of states. |
|||
|
|||
""" |
|||
insert = [] |
|||
for state, state_dict, mapper, connection, has_identity, \ |
|||
instance_key, row_switch in states_to_insert: |
|||
if table not in mapper._pks_by_table: |
|||
continue |
|||
|
|||
pks = mapper._pks_by_table[table] |
|||
|
|||
params = {} |
|||
value_params = {} |
|||
|
|||
has_all_pks = True |
|||
for col in mapper._cols_by_table[table]: |
|||
if col is mapper.version_id_col: |
|||
params[col.key] = mapper.version_id_generator(None) |
|||
else: |
|||
# pull straight from the dict for |
|||
# pending objects |
|||
prop = mapper._columntoproperty[col] |
|||
value = state_dict.get(prop.key, None) |
|||
|
|||
if value is None: |
|||
if col in pks: |
|||
has_all_pks = False |
|||
elif col.default is None and \ |
|||
col.server_default is None: |
|||
params[col.key] = value |
|||
|
|||
elif isinstance(value, sql.ClauseElement): |
|||
value_params[col] = value |
|||
else: |
|||
params[col.key] = value |
|||
|
|||
insert.append((state, state_dict, params, mapper, |
|||
connection, value_params, has_all_pks)) |
|||
return insert |
|||
|
|||
def _collect_update_commands(base_mapper, uowtransaction, |
|||
table, states_to_update): |
|||
"""Identify sets of values to use in UPDATE statements for a |
|||
list of states. |
|||
|
|||
This function works intricately with the history system |
|||
to determine exactly what values should be updated |
|||
as well as how the row should be matched within an UPDATE |
|||
statement. Includes some tricky scenarios where the primary |
|||
key of an object might have been changed. |
|||
|
|||
""" |
|||
|
|||
update = [] |
|||
for state, state_dict, mapper, connection, has_identity, \ |
|||
instance_key, row_switch in states_to_update: |
|||
if table not in mapper._pks_by_table: |
|||
continue |
|||
|
|||
pks = mapper._pks_by_table[table] |
|||
|
|||
params = {} |
|||
value_params = {} |
|||
|
|||
hasdata = hasnull = False |
|||
for col in mapper._cols_by_table[table]: |
|||
if col is mapper.version_id_col: |
|||
params[col._label] = \ |
|||
mapper._get_committed_state_attr_by_column( |
|||
row_switch or state, |
|||
row_switch and row_switch.dict |
|||
or state_dict, |
|||
col) |
|||
|
|||
prop = mapper._columntoproperty[col] |
|||
history = attributes.get_state_history( |
|||
state, prop.key, |
|||
attributes.PASSIVE_NO_INITIALIZE |
|||
) |
|||
if history.added: |
|||
params[col.key] = history.added[0] |
|||
hasdata = True |
|||
else: |
|||
params[col.key] = mapper.version_id_generator( |
|||
params[col._label]) |
|||
|
|||
# HACK: check for history, in case the |
|||
# history is only |
|||
# in a different table than the one |
|||
# where the version_id_col is. |
|||
for prop in mapper._columntoproperty.itervalues(): |
|||
history = attributes.get_state_history( |
|||
state, prop.key, |
|||
attributes.PASSIVE_NO_INITIALIZE) |
|||
if history.added: |
|||
hasdata = True |
|||
else: |
|||
prop = mapper._columntoproperty[col] |
|||
history = attributes.get_state_history( |
|||
state, prop.key, |
|||
attributes.PASSIVE_NO_INITIALIZE) |
|||
if history.added: |
|||
if isinstance(history.added[0], |
|||
sql.ClauseElement): |
|||
value_params[col] = history.added[0] |
|||
else: |
|||
value = history.added[0] |
|||
params[col.key] = value |
|||
|
|||
if col in pks: |
|||
if history.deleted and \ |
|||
not row_switch: |
|||
# if passive_updates and sync detected |
|||
# this was a pk->pk sync, use the new |
|||
# value to locate the row, since the |
|||
# DB would already have set this |
|||
if ("pk_cascaded", state, col) in \ |
|||
uowtransaction.attributes: |
|||
value = history.added[0] |
|||
params[col._label] = value |
|||
else: |
|||
# use the old value to |
|||
# locate the row |
|||
value = history.deleted[0] |
|||
params[col._label] = value |
|||
hasdata = True |
|||
else: |
|||
# row switch logic can reach us here |
|||
# remove the pk from the update params |
|||
# so the update doesn't |
|||
# attempt to include the pk in the |
|||
# update statement |
|||
del params[col.key] |
|||
value = history.added[0] |
|||
params[col._label] = value |
|||
if value is None: |
|||
hasnull = True |
|||
else: |
|||
hasdata = True |
|||
elif col in pks: |
|||
value = state.manager[prop.key].impl.get( |
|||
state, state_dict) |
|||
if value is None: |
|||
hasnull = True |
|||
params[col._label] = value |
|||
if hasdata: |
|||
if hasnull: |
|||
raise sa_exc.FlushError( |
|||
"Can't update table " |
|||
"using NULL for primary " |
|||
"key value") |
|||
update.append((state, state_dict, params, mapper, |
|||
connection, value_params)) |
|||
return update |
|||
|
|||
|
|||
def _collect_post_update_commands(base_mapper, uowtransaction, table, |
|||
states_to_update, post_update_cols): |
|||
"""Identify sets of values to use in UPDATE statements for a |
|||
list of states within a post_update operation. |
|||
|
|||
""" |
|||
|
|||
update = [] |
|||
for state, state_dict, mapper, connection in states_to_update: |
|||
if table not in mapper._pks_by_table: |
|||
continue |
|||
pks = mapper._pks_by_table[table] |
|||
params = {} |
|||
hasdata = False |
|||
|
|||
for col in mapper._cols_by_table[table]: |
|||
if col in pks: |
|||
params[col._label] = \ |
|||
mapper._get_state_attr_by_column( |
|||
state, |
|||
state_dict, col) |
|||
elif col in post_update_cols: |
|||
prop = mapper._columntoproperty[col] |
|||
history = attributes.get_state_history( |
|||
state, prop.key, |
|||
attributes.PASSIVE_NO_INITIALIZE) |
|||
if history.added: |
|||
value = history.added[0] |
|||
params[col.key] = value |
|||
hasdata = True |
|||
if hasdata: |
|||
update.append((state, state_dict, params, mapper, |
|||
connection)) |
|||
return update |
|||
|
|||
def _collect_delete_commands(base_mapper, uowtransaction, table, |
|||
states_to_delete): |
|||
"""Identify values to use in DELETE statements for a list of |
|||
states to be deleted.""" |
|||
|
|||
delete = util.defaultdict(list) |
|||
|
|||
for state, state_dict, mapper, has_identity, connection \ |
|||
in states_to_delete: |
|||
if not has_identity or table not in mapper._pks_by_table: |
|||
continue |
|||
|
|||
params = {} |
|||
delete[connection].append(params) |
|||
for col in mapper._pks_by_table[table]: |
|||
params[col.key] = \ |
|||
value = \ |
|||
mapper._get_state_attr_by_column( |
|||
state, state_dict, col) |
|||
if value is None: |
|||
raise sa_exc.FlushError( |
|||
"Can't delete from table " |
|||
"using NULL for primary " |
|||
"key value") |
|||
|
|||
if mapper.version_id_col is not None and \ |
|||
table.c.contains_column(mapper.version_id_col): |
|||
params[mapper.version_id_col.key] = \ |
|||
mapper._get_committed_state_attr_by_column( |
|||
state, state_dict, |
|||
mapper.version_id_col) |
|||
return delete |
|||
|
|||
|
|||
def _emit_update_statements(base_mapper, uowtransaction, |
|||
cached_connections, mapper, table, update): |
|||
"""Emit UPDATE statements corresponding to value lists collected |
|||
by _collect_update_commands().""" |
|||
|
|||
needs_version_id = mapper.version_id_col is not None and \ |
|||
table.c.contains_column(mapper.version_id_col) |
|||
|
|||
def update_stmt(): |
|||
clause = sql.and_() |
|||
|
|||
for col in mapper._pks_by_table[table]: |
|||
clause.clauses.append(col == sql.bindparam(col._label, |
|||
type_=col.type)) |
|||
|
|||
if needs_version_id: |
|||
clause.clauses.append(mapper.version_id_col ==\ |
|||
sql.bindparam(mapper.version_id_col._label, |
|||
type_=col.type)) |
|||
|
|||
return table.update(clause) |
|||
|
|||
statement = base_mapper._memo(('update', table), update_stmt) |
|||
|
|||
rows = 0 |
|||
for state, state_dict, params, mapper, \ |
|||
connection, value_params in update: |
|||
|
|||
if value_params: |
|||
c = connection.execute( |
|||
statement.values(value_params), |
|||
params) |
|||
else: |
|||
c = cached_connections[connection].\ |
|||
execute(statement, params) |
|||
|
|||
_postfetch( |
|||
mapper, |
|||
uowtransaction, |
|||
table, |
|||
state, |
|||
state_dict, |
|||
c.context.prefetch_cols, |
|||
c.context.postfetch_cols, |
|||
c.context.compiled_parameters[0], |
|||
value_params) |
|||
rows += c.rowcount |
|||
|
|||
if connection.dialect.supports_sane_rowcount: |
|||
if rows != len(update): |
|||
raise orm_exc.StaleDataError( |
|||
"UPDATE statement on table '%s' expected to " |
|||
"update %d row(s); %d were matched." % |
|||
(table.description, len(update), rows)) |
|||
|
|||
elif needs_version_id: |
|||
util.warn("Dialect %s does not support updated rowcount " |
|||
"- versioning cannot be verified." % |
|||
c.dialect.dialect_description, |
|||
stacklevel=12) |
|||
|
|||
def _emit_insert_statements(base_mapper, uowtransaction, |
|||
cached_connections, table, insert): |
|||
"""Emit INSERT statements corresponding to value lists collected |
|||
by _collect_insert_commands().""" |
|||
|
|||
statement = base_mapper._memo(('insert', table), table.insert) |
|||
|
|||
for (connection, pkeys, hasvalue, has_all_pks), \ |
|||
records in groupby(insert, |
|||
lambda rec: (rec[4], |
|||
rec[2].keys(), |
|||
bool(rec[5]), |
|||
rec[6]) |
|||
): |
|||
if has_all_pks and not hasvalue: |
|||
records = list(records) |
|||
multiparams = [rec[2] for rec in records] |
|||
c = cached_connections[connection].\ |
|||
execute(statement, multiparams) |
|||
|
|||
for (state, state_dict, params, mapper, |
|||
conn, value_params, has_all_pks), \ |
|||
last_inserted_params in \ |
|||
zip(records, c.context.compiled_parameters): |
|||
_postfetch( |
|||
mapper, |
|||
uowtransaction, |
|||
table, |
|||
state, |
|||
state_dict, |
|||
c.context.prefetch_cols, |
|||
c.context.postfetch_cols, |
|||
last_inserted_params, |
|||
value_params) |
|||
|
|||
else: |
|||
for state, state_dict, params, mapper, \ |
|||
connection, value_params, \ |
|||
has_all_pks in records: |
|||
|
|||
if value_params: |
|||
result = connection.execute( |
|||
statement.values(value_params), |
|||
params) |
|||
else: |
|||
result = cached_connections[connection].\ |
|||
execute(statement, params) |
|||
|
|||
primary_key = result.context.inserted_primary_key |
|||
|
|||
if primary_key is not None: |
|||
# set primary key attributes |
|||
for pk, col in zip(primary_key, |
|||
mapper._pks_by_table[table]): |
|||
prop = mapper._columntoproperty[col] |
|||
if state_dict.get(prop.key) is None: |
|||
# TODO: would rather say: |
|||
#state_dict[prop.key] = pk |
|||
mapper._set_state_attr_by_column( |
|||
state, |
|||
state_dict, |
|||
col, pk) |
|||
|
|||
_postfetch( |
|||
mapper, |
|||
uowtransaction, |
|||
table, |
|||
state, |
|||
state_dict, |
|||
result.context.prefetch_cols, |
|||
result.context.postfetch_cols, |
|||
result.context.compiled_parameters[0], |
|||
value_params) |
|||
|
|||
|
|||
|
|||
def _emit_post_update_statements(base_mapper, uowtransaction, |
|||
cached_connections, mapper, table, update): |
|||
"""Emit UPDATE statements corresponding to value lists collected |
|||
by _collect_post_update_commands().""" |
|||
|
|||
def update_stmt(): |
|||
clause = sql.and_() |
|||
|
|||
for col in mapper._pks_by_table[table]: |
|||
clause.clauses.append(col == sql.bindparam(col._label, |
|||
type_=col.type)) |
|||
|
|||
return table.update(clause) |
|||
|
|||
statement = base_mapper._memo(('post_update', table), update_stmt) |
|||
|
|||
# execute each UPDATE in the order according to the original |
|||
# list of states to guarantee row access order, but |
|||
# also group them into common (connection, cols) sets |
|||
# to support executemany(). |
|||
for key, grouper in groupby( |
|||
update, lambda rec: (rec[4], rec[2].keys()) |
|||
): |
|||
connection = key[0] |
|||
multiparams = [params for state, state_dict, |
|||
params, mapper, conn in grouper] |
|||
cached_connections[connection].\ |
|||
execute(statement, multiparams) |
|||
|
|||
|
|||
def _emit_delete_statements(base_mapper, uowtransaction, cached_connections, |
|||
mapper, table, delete): |
|||
"""Emit DELETE statements corresponding to value lists collected |
|||
by _collect_delete_commands().""" |
|||
|
|||
need_version_id = mapper.version_id_col is not None and \ |
|||
table.c.contains_column(mapper.version_id_col) |
|||
|
|||
def delete_stmt(): |
|||
clause = sql.and_() |
|||
for col in mapper._pks_by_table[table]: |
|||
clause.clauses.append( |
|||
col == sql.bindparam(col.key, type_=col.type)) |
|||
|
|||
if need_version_id: |
|||
clause.clauses.append( |
|||
mapper.version_id_col == |
|||
sql.bindparam( |
|||
mapper.version_id_col.key, |
|||
type_=mapper.version_id_col.type |
|||
) |
|||
) |
|||
|
|||
return table.delete(clause) |
|||
|
|||
for connection, del_objects in delete.iteritems(): |
|||
statement = base_mapper._memo(('delete', table), delete_stmt) |
|||
|
|||
connection = cached_connections[connection] |
|||
|
|||
if need_version_id: |
|||
# TODO: need test coverage for this [ticket:1761] |
|||
if connection.dialect.supports_sane_rowcount: |
|||
rows = 0 |
|||
# execute deletes individually so that versioned |
|||
# rows can be verified |
|||
for params in del_objects: |
|||
c = connection.execute(statement, params) |
|||
rows += c.rowcount |
|||
if rows != len(del_objects): |
|||
raise orm_exc.StaleDataError( |
|||
"DELETE statement on table '%s' expected to " |
|||
"delete %d row(s); %d were matched." % |
|||
(table.description, len(del_objects), c.rowcount) |
|||
) |
|||
else: |
|||
util.warn( |
|||
"Dialect %s does not support deleted rowcount " |
|||
"- versioning cannot be verified." % |
|||
connection.dialect.dialect_description, |
|||
stacklevel=12) |
|||
connection.execute(statement, del_objects) |
|||
else: |
|||
connection.execute(statement, del_objects) |
|||
|
|||
|
|||
def _finalize_insert_update_commands(base_mapper, uowtransaction, |
|||
states_to_insert, states_to_update): |
|||
"""finalize state on states that have been inserted or updated, |
|||
including calling after_insert/after_update events. |
|||
|
|||
""" |
|||
for state, state_dict, mapper, connection, has_identity, \ |
|||
instance_key, row_switch in states_to_insert + \ |
|||
states_to_update: |
|||
|
|||
if mapper._readonly_props: |
|||
readonly = state.unmodified_intersection( |
|||
[p.key for p in mapper._readonly_props |
|||
if p.expire_on_flush or p.key not in state.dict] |
|||
) |
|||
if readonly: |
|||
state.expire_attributes(state.dict, readonly) |
|||
|
|||
# if eager_defaults option is enabled, |
|||
# refresh whatever has been expired. |
|||
if base_mapper.eager_defaults and state.unloaded: |
|||
state.key = base_mapper._identity_key_from_state(state) |
|||
uowtransaction.session.query(base_mapper)._load_on_ident( |
|||
state.key, refresh_state=state, |
|||
only_load_props=state.unloaded) |
|||
|
|||
# call after_XXX extensions |
|||
if not has_identity: |
|||
mapper.dispatch.after_insert(mapper, connection, state) |
|||
else: |
|||
mapper.dispatch.after_update(mapper, connection, state) |
|||
|
|||
def _postfetch(mapper, uowtransaction, table, |
|||
state, dict_, prefetch_cols, postfetch_cols, |
|||
params, value_params): |
|||
"""Expire attributes in need of newly persisted database state, |
|||
after an INSERT or UPDATE statement has proceeded for that |
|||
state.""" |
|||
|
|||
if mapper.version_id_col is not None: |
|||
prefetch_cols = list(prefetch_cols) + [mapper.version_id_col] |
|||
|
|||
for c in prefetch_cols: |
|||
if c.key in params and c in mapper._columntoproperty: |
|||
mapper._set_state_attr_by_column(state, dict_, c, params[c.key]) |
|||
|
|||
if postfetch_cols: |
|||
state.expire_attributes(state.dict, |
|||
[mapper._columntoproperty[c].key |
|||
for c in postfetch_cols if c in |
|||
mapper._columntoproperty] |
|||
) |
|||
|
|||
# synchronize newly inserted ids from one table to the next |
|||
# TODO: this still goes a little too often. would be nice to |
|||
# have definitive list of "columns that changed" here |
|||
for m, equated_pairs in mapper._table_to_equated[table]: |
|||
sync.populate(state, m, state, m, |
|||
equated_pairs, |
|||
uowtransaction, |
|||
mapper.passive_updates) |
|||
|
|||
def _connections_for_states(base_mapper, uowtransaction, states): |
|||
"""Return an iterator of (state, state.dict, mapper, connection). |
|||
|
|||
The states are sorted according to _sort_states, then paired |
|||
with the connection they should be using for the given |
|||
unit of work transaction. |
|||
|
|||
""" |
|||
# if session has a connection callable, |
|||
# organize individual states with the connection |
|||
# to use for update |
|||
if uowtransaction.session.connection_callable: |
|||
connection_callable = \ |
|||
uowtransaction.session.connection_callable |
|||
else: |
|||
connection = uowtransaction.transaction.connection( |
|||
base_mapper) |
|||
connection_callable = None |
|||
|
|||
for state in _sort_states(states): |
|||
if connection_callable: |
|||
connection = connection_callable(base_mapper, state.obj()) |
|||
|
|||
mapper = _state_mapper(state) |
|||
|
|||
yield state, state.dict, mapper, connection |
|||
|
|||
def _cached_connection_dict(base_mapper): |
|||
# dictionary of connection->connection_with_cache_options. |
|||
return util.PopulateDict( |
|||
lambda conn:conn.execution_options( |
|||
compiled_cache=base_mapper._compiled_cache |
|||
)) |
|||
|
|||
def _sort_states(states): |
|||
pending = set(states) |
|||
persistent = set(s for s in pending if s.key is not None) |
|||
pending.difference_update(persistent) |
|||
return sorted(pending, key=operator.attrgetter("insert_order")) + \ |
|||
sorted(persistent, key=lambda q:q.key[1]) |
|||
|
|||
|
|||
Loading…
Reference in new issue