From 12cf076118570eebbff08c6b3090e0d4798447a1 Mon Sep 17 00:00:00 2001 From: cyfraeviolae Date: Wed, 3 Apr 2024 03:17:55 -0400 Subject: no venv --- .../site-packages/sqlalchemy/orm/dependency.py | 1304 -------------------- 1 file changed, 1304 deletions(-) delete mode 100644 venv/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py (limited to 'venv/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py') diff --git a/venv/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py b/venv/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py deleted file mode 100644 index 71c06fb..0000000 --- a/venv/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py +++ /dev/null @@ -1,1304 +0,0 @@ -# orm/dependency.py -# Copyright (C) 2005-2024 the SQLAlchemy authors and contributors -# -# -# This module is part of SQLAlchemy and is released under -# the MIT License: https://www.opensource.org/licenses/mit-license.php -# mypy: ignore-errors - - -"""Relationship dependencies. - -""" - -from __future__ import annotations - -from . import attributes -from . import exc -from . import sync -from . import unitofwork -from . import util as mapperutil -from .interfaces import MANYTOMANY -from .interfaces import MANYTOONE -from .interfaces import ONETOMANY -from .. import exc as sa_exc -from .. import sql -from .. import util - - -class DependencyProcessor: - def __init__(self, prop): - self.prop = prop - self.cascade = prop.cascade - self.mapper = prop.mapper - self.parent = prop.parent - self.secondary = prop.secondary - self.direction = prop.direction - self.post_update = prop.post_update - self.passive_deletes = prop.passive_deletes - self.passive_updates = prop.passive_updates - self.enable_typechecks = prop.enable_typechecks - if self.passive_deletes: - self._passive_delete_flag = attributes.PASSIVE_NO_INITIALIZE - else: - self._passive_delete_flag = attributes.PASSIVE_OFF - if self.passive_updates: - self._passive_update_flag = attributes.PASSIVE_NO_INITIALIZE - else: - self._passive_update_flag = attributes.PASSIVE_OFF - - self.sort_key = "%s_%s" % (self.parent._sort_key, prop.key) - self.key = prop.key - if not self.prop.synchronize_pairs: - raise sa_exc.ArgumentError( - "Can't build a DependencyProcessor for relationship %s. " - "No target attributes to populate between parent and " - "child are present" % self.prop - ) - - @classmethod - def from_relationship(cls, prop): - return _direction_to_processor[prop.direction](prop) - - def hasparent(self, state): - """return True if the given object instance has a parent, - according to the ``InstrumentedAttribute`` handled by this - ``DependencyProcessor``. - - """ - return self.parent.class_manager.get_impl(self.key).hasparent(state) - - def per_property_preprocessors(self, uow): - """establish actions and dependencies related to a flush. - - These actions will operate on all relevant states in - the aggregate. - - """ - uow.register_preprocessor(self, True) - - def per_property_flush_actions(self, uow): - after_save = unitofwork.ProcessAll(uow, self, False, True) - before_delete = unitofwork.ProcessAll(uow, self, True, True) - - parent_saves = unitofwork.SaveUpdateAll( - uow, self.parent.primary_base_mapper - ) - child_saves = unitofwork.SaveUpdateAll( - uow, self.mapper.primary_base_mapper - ) - - parent_deletes = unitofwork.DeleteAll( - uow, self.parent.primary_base_mapper - ) - child_deletes = unitofwork.DeleteAll( - uow, self.mapper.primary_base_mapper - ) - - self.per_property_dependencies( - uow, - parent_saves, - child_saves, - parent_deletes, - child_deletes, - after_save, - before_delete, - ) - - def per_state_flush_actions(self, uow, states, isdelete): - """establish actions and dependencies related to a flush. - - These actions will operate on all relevant states - individually. This occurs only if there are cycles - in the 'aggregated' version of events. - - """ - - child_base_mapper = self.mapper.primary_base_mapper - child_saves = unitofwork.SaveUpdateAll(uow, child_base_mapper) - child_deletes = unitofwork.DeleteAll(uow, child_base_mapper) - - # locate and disable the aggregate processors - # for this dependency - - if isdelete: - before_delete = unitofwork.ProcessAll(uow, self, True, True) - before_delete.disabled = True - else: - after_save = unitofwork.ProcessAll(uow, self, False, True) - after_save.disabled = True - - # check if the "child" side is part of the cycle - - if child_saves not in uow.cycles: - # based on the current dependencies we use, the saves/ - # deletes should always be in the 'cycles' collection - # together. if this changes, we will have to break up - # this method a bit more. - assert child_deletes not in uow.cycles - - # child side is not part of the cycle, so we will link per-state - # actions to the aggregate "saves", "deletes" actions - child_actions = [(child_saves, False), (child_deletes, True)] - child_in_cycles = False - else: - child_in_cycles = True - - # check if the "parent" side is part of the cycle - if not isdelete: - parent_saves = unitofwork.SaveUpdateAll( - uow, self.parent.base_mapper - ) - parent_deletes = before_delete = None - if parent_saves in uow.cycles: - parent_in_cycles = True - else: - parent_deletes = unitofwork.DeleteAll(uow, self.parent.base_mapper) - parent_saves = after_save = None - if parent_deletes in uow.cycles: - parent_in_cycles = True - - # now create actions /dependencies for each state. - - for state in states: - # detect if there's anything changed or loaded - # by a preprocessor on this state/attribute. In the - # case of deletes we may try to load missing items here as well. - sum_ = state.manager[self.key].impl.get_all_pending( - state, - state.dict, - ( - self._passive_delete_flag - if isdelete - else attributes.PASSIVE_NO_INITIALIZE - ), - ) - - if not sum_: - continue - - if isdelete: - before_delete = unitofwork.ProcessState(uow, self, True, state) - if parent_in_cycles: - parent_deletes = unitofwork.DeleteState(uow, state) - else: - after_save = unitofwork.ProcessState(uow, self, False, state) - if parent_in_cycles: - parent_saves = unitofwork.SaveUpdateState(uow, state) - - if child_in_cycles: - child_actions = [] - for child_state, child in sum_: - if child_state not in uow.states: - child_action = (None, None) - else: - (deleted, listonly) = uow.states[child_state] - if deleted: - child_action = ( - unitofwork.DeleteState(uow, child_state), - True, - ) - else: - child_action = ( - unitofwork.SaveUpdateState(uow, child_state), - False, - ) - child_actions.append(child_action) - - # establish dependencies between our possibly per-state - # parent action and our possibly per-state child action. - for child_action, childisdelete in child_actions: - self.per_state_dependencies( - uow, - parent_saves, - parent_deletes, - child_action, - after_save, - before_delete, - isdelete, - childisdelete, - ) - - def presort_deletes(self, uowcommit, states): - return False - - def presort_saves(self, uowcommit, states): - return False - - def process_deletes(self, uowcommit, states): - pass - - def process_saves(self, uowcommit, states): - pass - - def prop_has_changes(self, uowcommit, states, isdelete): - if not isdelete or self.passive_deletes: - passive = ( - attributes.PASSIVE_NO_INITIALIZE - | attributes.INCLUDE_PENDING_MUTATIONS - ) - elif self.direction is MANYTOONE: - # here, we were hoping to optimize having to fetch many-to-one - # for history and ignore it, if there's no further cascades - # to take place. however there are too many less common conditions - # that still take place and tests in test_relationships / - # test_cascade etc. will still fail. - passive = attributes.PASSIVE_NO_FETCH_RELATED - else: - passive = ( - attributes.PASSIVE_OFF | attributes.INCLUDE_PENDING_MUTATIONS - ) - - for s in states: - # TODO: add a high speed method - # to InstanceState which returns: attribute - # has a non-None value, or had one - history = uowcommit.get_attribute_history(s, self.key, passive) - if history and not history.empty(): - return True - else: - return ( - states - and not self.prop._is_self_referential - and self.mapper in uowcommit.mappers - ) - - def _verify_canload(self, state): - if self.prop.uselist and state is None: - raise exc.FlushError( - "Can't flush None value found in " - "collection %s" % (self.prop,) - ) - elif state is not None and not self.mapper._canload( - state, allow_subtypes=not self.enable_typechecks - ): - if self.mapper._canload(state, allow_subtypes=True): - raise exc.FlushError( - "Attempting to flush an item of type " - "%(x)s as a member of collection " - '"%(y)s". Expected an object of type ' - "%(z)s or a polymorphic subclass of " - "this type. If %(x)s is a subclass of " - '%(z)s, configure mapper "%(zm)s" to ' - "load this subtype polymorphically, or " - "set enable_typechecks=False to allow " - "any subtype to be accepted for flush. " - % { - "x": state.class_, - "y": self.prop, - "z": self.mapper.class_, - "zm": self.mapper, - } - ) - else: - raise exc.FlushError( - "Attempting to flush an item of type " - "%(x)s as a member of collection " - '"%(y)s". Expected an object of type ' - "%(z)s or a polymorphic subclass of " - "this type." - % { - "x": state.class_, - "y": self.prop, - "z": self.mapper.class_, - } - ) - - def _synchronize(self, state, child, associationrow, clearkeys, uowcommit): - raise NotImplementedError() - - def _get_reversed_processed_set(self, uow): - if not self.prop._reverse_property: - return None - - process_key = tuple( - sorted([self.key] + [p.key for p in self.prop._reverse_property]) - ) - return uow.memo(("reverse_key", process_key), set) - - def _post_update(self, state, uowcommit, related, is_m2o_delete=False): - for x in related: - if not is_m2o_delete or x is not None: - uowcommit.register_post_update( - state, [r for l, r in self.prop.synchronize_pairs] - ) - break - - def _pks_changed(self, uowcommit, state): - raise NotImplementedError() - - def __repr__(self): - return "%s(%s)" % (self.__class__.__name__, self.prop) - - -class OneToManyDP(DependencyProcessor): - def per_property_dependencies( - self, - uow, - parent_saves, - child_saves, - parent_deletes, - child_deletes, - after_save, - before_delete, - ): - if self.post_update: - child_post_updates = unitofwork.PostUpdateAll( - uow, self.mapper.primary_base_mapper, False - ) - child_pre_updates = unitofwork.PostUpdateAll( - uow, self.mapper.primary_base_mapper, True - ) - - uow.dependencies.update( - [ - (child_saves, after_save), - (parent_saves, after_save), - (after_save, child_post_updates), - (before_delete, child_pre_updates), - (child_pre_updates, parent_deletes), - (child_pre_updates, child_deletes), - ] - ) - else: - uow.dependencies.update( - [ - (parent_saves, after_save), - (after_save, child_saves), - (after_save, child_deletes), - (child_saves, parent_deletes), - (child_deletes, parent_deletes), - (before_delete, child_saves), - (before_delete, child_deletes), - ] - ) - - def per_state_dependencies( - self, - uow, - save_parent, - delete_parent, - child_action, - after_save, - before_delete, - isdelete, - childisdelete, - ): - if self.post_update: - child_post_updates = unitofwork.PostUpdateAll( - uow, self.mapper.primary_base_mapper, False - ) - child_pre_updates = unitofwork.PostUpdateAll( - uow, self.mapper.primary_base_mapper, True - ) - - # TODO: this whole block is not covered - # by any tests - if not isdelete: - if childisdelete: - uow.dependencies.update( - [ - (child_action, after_save), - (after_save, child_post_updates), - ] - ) - else: - uow.dependencies.update( - [ - (save_parent, after_save), - (child_action, after_save), - (after_save, child_post_updates), - ] - ) - else: - if childisdelete: - uow.dependencies.update( - [ - (before_delete, child_pre_updates), - (child_pre_updates, delete_parent), - ] - ) - else: - uow.dependencies.update( - [ - (before_delete, child_pre_updates), - (child_pre_updates, delete_parent), - ] - ) - elif not isdelete: - uow.dependencies.update( - [ - (save_parent, after_save), - (after_save, child_action), - (save_parent, child_action), - ] - ) - else: - uow.dependencies.update( - [(before_delete, child_action), (child_action, delete_parent)] - ) - - def presort_deletes(self, uowcommit, states): - # head object is being deleted, and we manage its list of - # child objects the child objects have to have their - # foreign key to the parent set to NULL - should_null_fks = ( - not self.cascade.delete and not self.passive_deletes == "all" - ) - - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - for child in history.deleted: - if child is not None and self.hasparent(child) is False: - if self.cascade.delete_orphan: - uowcommit.register_object(child, isdelete=True) - else: - uowcommit.register_object(child) - - if should_null_fks: - for child in history.unchanged: - if child is not None: - uowcommit.register_object( - child, operation="delete", prop=self.prop - ) - - def presort_saves(self, uowcommit, states): - children_added = uowcommit.memo(("children_added", self), set) - - should_null_fks = ( - not self.cascade.delete_orphan - and not self.passive_deletes == "all" - ) - - for state in states: - pks_changed = self._pks_changed(uowcommit, state) - - if not pks_changed or self.passive_updates: - passive = ( - attributes.PASSIVE_NO_INITIALIZE - | attributes.INCLUDE_PENDING_MUTATIONS - ) - else: - passive = ( - attributes.PASSIVE_OFF - | attributes.INCLUDE_PENDING_MUTATIONS - ) - - history = uowcommit.get_attribute_history(state, self.key, passive) - if history: - for child in history.added: - if child is not None: - uowcommit.register_object( - child, - cancel_delete=True, - operation="add", - prop=self.prop, - ) - - children_added.update(history.added) - - for child in history.deleted: - if not self.cascade.delete_orphan: - if should_null_fks: - uowcommit.register_object( - child, - isdelete=False, - operation="delete", - prop=self.prop, - ) - elif self.hasparent(child) is False: - uowcommit.register_object( - child, - isdelete=True, - operation="delete", - prop=self.prop, - ) - for c, m, st_, dct_ in self.mapper.cascade_iterator( - "delete", child - ): - uowcommit.register_object(st_, isdelete=True) - - if pks_changed: - if history: - for child in history.unchanged: - if child is not None: - uowcommit.register_object( - child, - False, - self.passive_updates, - operation="pk change", - prop=self.prop, - ) - - def process_deletes(self, uowcommit, states): - # head object is being deleted, and we manage its list of - # child objects the child objects have to have their foreign - # key to the parent set to NULL this phase can be called - # safely for any cascade but is unnecessary if delete cascade - # is on. - - if self.post_update or not self.passive_deletes == "all": - children_added = uowcommit.memo(("children_added", self), set) - - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - for child in history.deleted: - if ( - child is not None - and self.hasparent(child) is False - ): - self._synchronize( - state, child, None, True, uowcommit, False - ) - if self.post_update and child: - self._post_update(child, uowcommit, [state]) - - if self.post_update or not self.cascade.delete: - for child in set(history.unchanged).difference( - children_added - ): - if child is not None: - self._synchronize( - state, child, None, True, uowcommit, False - ) - if self.post_update and child: - self._post_update( - child, uowcommit, [state] - ) - - # technically, we can even remove each child from the - # collection here too. but this would be a somewhat - # inconsistent behavior since it wouldn't happen - # if the old parent wasn't deleted but child was moved. - - def process_saves(self, uowcommit, states): - should_null_fks = ( - not self.cascade.delete_orphan - and not self.passive_deletes == "all" - ) - - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, attributes.PASSIVE_NO_INITIALIZE - ) - if history: - for child in history.added: - self._synchronize( - state, child, None, False, uowcommit, False - ) - if child is not None and self.post_update: - self._post_update(child, uowcommit, [state]) - - for child in history.deleted: - if ( - should_null_fks - and not self.cascade.delete_orphan - and not self.hasparent(child) - ): - self._synchronize( - state, child, None, True, uowcommit, False - ) - - if self._pks_changed(uowcommit, state): - for child in history.unchanged: - self._synchronize( - state, child, None, False, uowcommit, True - ) - - def _synchronize( - self, state, child, associationrow, clearkeys, uowcommit, pks_changed - ): - source = state - dest = child - self._verify_canload(child) - if dest is None or ( - not self.post_update and uowcommit.is_deleted(dest) - ): - return - if clearkeys: - sync.clear(dest, self.mapper, self.prop.synchronize_pairs) - else: - sync.populate( - source, - self.parent, - dest, - self.mapper, - self.prop.synchronize_pairs, - uowcommit, - self.passive_updates and pks_changed, - ) - - def _pks_changed(self, uowcommit, state): - return sync.source_modified( - uowcommit, state, self.parent, self.prop.synchronize_pairs - ) - - -class ManyToOneDP(DependencyProcessor): - def __init__(self, prop): - DependencyProcessor.__init__(self, prop) - for mapper in self.mapper.self_and_descendants: - mapper._dependency_processors.append(DetectKeySwitch(prop)) - - def per_property_dependencies( - self, - uow, - parent_saves, - child_saves, - parent_deletes, - child_deletes, - after_save, - before_delete, - ): - if self.post_update: - parent_post_updates = unitofwork.PostUpdateAll( - uow, self.parent.primary_base_mapper, False - ) - parent_pre_updates = unitofwork.PostUpdateAll( - uow, self.parent.primary_base_mapper, True - ) - - uow.dependencies.update( - [ - (child_saves, after_save), - (parent_saves, after_save), - (after_save, parent_post_updates), - (after_save, parent_pre_updates), - (before_delete, parent_pre_updates), - (parent_pre_updates, child_deletes), - (parent_pre_updates, parent_deletes), - ] - ) - else: - uow.dependencies.update( - [ - (child_saves, after_save), - (after_save, parent_saves), - (parent_saves, child_deletes), - (parent_deletes, child_deletes), - ] - ) - - def per_state_dependencies( - self, - uow, - save_parent, - delete_parent, - child_action, - after_save, - before_delete, - isdelete, - childisdelete, - ): - if self.post_update: - if not isdelete: - parent_post_updates = unitofwork.PostUpdateAll( - uow, self.parent.primary_base_mapper, False - ) - if childisdelete: - uow.dependencies.update( - [ - (after_save, parent_post_updates), - (parent_post_updates, child_action), - ] - ) - else: - uow.dependencies.update( - [ - (save_parent, after_save), - (child_action, after_save), - (after_save, parent_post_updates), - ] - ) - else: - parent_pre_updates = unitofwork.PostUpdateAll( - uow, self.parent.primary_base_mapper, True - ) - - uow.dependencies.update( - [ - (before_delete, parent_pre_updates), - (parent_pre_updates, delete_parent), - (parent_pre_updates, child_action), - ] - ) - - elif not isdelete: - if not childisdelete: - uow.dependencies.update( - [(child_action, after_save), (after_save, save_parent)] - ) - else: - uow.dependencies.update([(after_save, save_parent)]) - - else: - if childisdelete: - uow.dependencies.update([(delete_parent, child_action)]) - - def presort_deletes(self, uowcommit, states): - if self.cascade.delete or self.cascade.delete_orphan: - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - if self.cascade.delete_orphan: - todelete = history.sum() - else: - todelete = history.non_deleted() - for child in todelete: - if child is None: - continue - uowcommit.register_object( - child, - isdelete=True, - operation="delete", - prop=self.prop, - ) - t = self.mapper.cascade_iterator("delete", child) - for c, m, st_, dct_ in t: - uowcommit.register_object(st_, isdelete=True) - - def presort_saves(self, uowcommit, states): - for state in states: - uowcommit.register_object(state, operation="add", prop=self.prop) - if self.cascade.delete_orphan: - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - for child in history.deleted: - if self.hasparent(child) is False: - uowcommit.register_object( - child, - isdelete=True, - operation="delete", - prop=self.prop, - ) - - t = self.mapper.cascade_iterator("delete", child) - for c, m, st_, dct_ in t: - uowcommit.register_object(st_, isdelete=True) - - def process_deletes(self, uowcommit, states): - if ( - self.post_update - and not self.cascade.delete_orphan - and not self.passive_deletes == "all" - ): - # post_update means we have to update our - # row to not reference the child object - # before we can DELETE the row - for state in states: - self._synchronize(state, None, None, True, uowcommit) - if state and self.post_update: - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - self._post_update( - state, uowcommit, history.sum(), is_m2o_delete=True - ) - - def process_saves(self, uowcommit, states): - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, attributes.PASSIVE_NO_INITIALIZE - ) - if history: - if history.added: - for child in history.added: - self._synchronize( - state, child, None, False, uowcommit, "add" - ) - elif history.deleted: - self._synchronize( - state, None, None, True, uowcommit, "delete" - ) - if self.post_update: - self._post_update(state, uowcommit, history.sum()) - - def _synchronize( - self, - state, - child, - associationrow, - clearkeys, - uowcommit, - operation=None, - ): - if state is None or ( - not self.post_update and uowcommit.is_deleted(state) - ): - return - - if ( - operation is not None - and child is not None - and not uowcommit.session._contains_state(child) - ): - util.warn( - "Object of type %s not in session, %s " - "operation along '%s' won't proceed" - % (mapperutil.state_class_str(child), operation, self.prop) - ) - return - - if clearkeys or child is None: - sync.clear(state, self.parent, self.prop.synchronize_pairs) - else: - self._verify_canload(child) - sync.populate( - child, - self.mapper, - state, - self.parent, - self.prop.synchronize_pairs, - uowcommit, - False, - ) - - -class DetectKeySwitch(DependencyProcessor): - """For many-to-one relationships with no one-to-many backref, - searches for parents through the unit of work when a primary - key has changed and updates them. - - Theoretically, this approach could be expanded to support transparent - deletion of objects referenced via many-to-one as well, although - the current attribute system doesn't do enough bookkeeping for this - to be efficient. - - """ - - def per_property_preprocessors(self, uow): - if self.prop._reverse_property: - if self.passive_updates: - return - else: - if False in ( - prop.passive_updates - for prop in self.prop._reverse_property - ): - return - - uow.register_preprocessor(self, False) - - def per_property_flush_actions(self, uow): - parent_saves = unitofwork.SaveUpdateAll(uow, self.parent.base_mapper) - after_save = unitofwork.ProcessAll(uow, self, False, False) - uow.dependencies.update([(parent_saves, after_save)]) - - def per_state_flush_actions(self, uow, states, isdelete): - pass - - def presort_deletes(self, uowcommit, states): - pass - - def presort_saves(self, uow, states): - if not self.passive_updates: - # for non-passive updates, register in the preprocess stage - # so that mapper save_obj() gets a hold of changes - self._process_key_switches(states, uow) - - def prop_has_changes(self, uow, states, isdelete): - if not isdelete and self.passive_updates: - d = self._key_switchers(uow, states) - return bool(d) - - return False - - def process_deletes(self, uowcommit, states): - assert False - - def process_saves(self, uowcommit, states): - # for passive updates, register objects in the process stage - # so that we avoid ManyToOneDP's registering the object without - # the listonly flag in its own preprocess stage (results in UPDATE) - # statements being emitted - assert self.passive_updates - self._process_key_switches(states, uowcommit) - - def _key_switchers(self, uow, states): - switched, notswitched = uow.memo( - ("pk_switchers", self), lambda: (set(), set()) - ) - - allstates = switched.union(notswitched) - for s in states: - if s not in allstates: - if self._pks_changed(uow, s): - switched.add(s) - else: - notswitched.add(s) - return switched - - def _process_key_switches(self, deplist, uowcommit): - switchers = self._key_switchers(uowcommit, deplist) - if switchers: - # if primary key values have actually changed somewhere, perform - # a linear search through the UOW in search of a parent. - for state in uowcommit.session.identity_map.all_states(): - if not issubclass(state.class_, self.parent.class_): - continue - dict_ = state.dict - related = state.get_impl(self.key).get( - state, dict_, passive=self._passive_update_flag - ) - if ( - related is not attributes.PASSIVE_NO_RESULT - and related is not None - ): - if self.prop.uselist: - if not related: - continue - related_obj = related[0] - else: - related_obj = related - related_state = attributes.instance_state(related_obj) - if related_state in switchers: - uowcommit.register_object( - state, False, self.passive_updates - ) - sync.populate( - related_state, - self.mapper, - state, - self.parent, - self.prop.synchronize_pairs, - uowcommit, - self.passive_updates, - ) - - def _pks_changed(self, uowcommit, state): - return bool(state.key) and sync.source_modified( - uowcommit, state, self.mapper, self.prop.synchronize_pairs - ) - - -class ManyToManyDP(DependencyProcessor): - def per_property_dependencies( - self, - uow, - parent_saves, - child_saves, - parent_deletes, - child_deletes, - after_save, - before_delete, - ): - uow.dependencies.update( - [ - (parent_saves, after_save), - (child_saves, after_save), - (after_save, child_deletes), - # a rowswitch on the parent from deleted to saved - # can make this one occur, as the "save" may remove - # an element from the - # "deleted" list before we have a chance to - # process its child rows - (before_delete, parent_saves), - (before_delete, parent_deletes), - (before_delete, child_deletes), - (before_delete, child_saves), - ] - ) - - def per_state_dependencies( - self, - uow, - save_parent, - delete_parent, - child_action, - after_save, - before_delete, - isdelete, - childisdelete, - ): - if not isdelete: - if childisdelete: - uow.dependencies.update( - [(save_parent, after_save), (after_save, child_action)] - ) - else: - uow.dependencies.update( - [(save_parent, after_save), (child_action, after_save)] - ) - else: - uow.dependencies.update( - [(before_delete, child_action), (before_delete, delete_parent)] - ) - - def presort_deletes(self, uowcommit, states): - # TODO: no tests fail if this whole - # thing is removed !!!! - if not self.passive_deletes: - # if no passive deletes, load history on - # the collection, so that prop_has_changes() - # returns True - for state in states: - uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - - def presort_saves(self, uowcommit, states): - if not self.passive_updates: - # if no passive updates, load history on - # each collection where parent has changed PK, - # so that prop_has_changes() returns True - for state in states: - if self._pks_changed(uowcommit, state): - history = uowcommit.get_attribute_history( - state, self.key, attributes.PASSIVE_OFF - ) - - if not self.cascade.delete_orphan: - return - - # check for child items removed from the collection - # if delete_orphan check is turned on. - for state in states: - history = uowcommit.get_attribute_history( - state, self.key, attributes.PASSIVE_NO_INITIALIZE - ) - if history: - for child in history.deleted: - if self.hasparent(child) is False: - uowcommit.register_object( - child, - isdelete=True, - operation="delete", - prop=self.prop, - ) - for c, m, st_, dct_ in self.mapper.cascade_iterator( - "delete", child - ): - uowcommit.register_object(st_, isdelete=True) - - def process_deletes(self, uowcommit, states): - secondary_delete = [] - secondary_insert = [] - secondary_update = [] - - processed = self._get_reversed_processed_set(uowcommit) - tmp = set() - for state in states: - # this history should be cached already, as - # we loaded it in preprocess_deletes - history = uowcommit.get_attribute_history( - state, self.key, self._passive_delete_flag - ) - if history: - for child in history.non_added(): - if child is None or ( - processed is not None and (state, child) in processed - ): - continue - associationrow = {} - if not self._synchronize( - state, - child, - associationrow, - False, - uowcommit, - "delete", - ): - continue - secondary_delete.append(associationrow) - - tmp.update((c, state) for c in history.non_added()) - - if processed is not None: - processed.update(tmp) - - self._run_crud( - uowcommit, secondary_insert, secondary_update, secondary_delete - ) - - def process_saves(self, uowcommit, states): - secondary_delete = [] - secondary_insert = [] - secondary_update = [] - - processed = self._get_reversed_processed_set(uowcommit) - tmp = set() - - for state in states: - need_cascade_pks = not self.passive_updates and self._pks_changed( - uowcommit, state - ) - if need_cascade_pks: - passive = ( - attributes.PASSIVE_OFF - | attributes.INCLUDE_PENDING_MUTATIONS - ) - else: - passive = ( - attributes.PASSIVE_NO_INITIALIZE - | attributes.INCLUDE_PENDING_MUTATIONS - ) - history = uowcommit.get_attribute_history(state, self.key, passive) - if history: - for child in history.added: - if processed is not None and (state, child) in processed: - continue - associationrow = {} - if not self._synchronize( - state, child, associationrow, False, uowcommit, "add" - ): - continue - secondary_insert.append(associationrow) - for child in history.deleted: - if processed is not None and (state, child) in processed: - continue - associationrow = {} - if not self._synchronize( - state, - child, - associationrow, - False, - uowcommit, - "delete", - ): - continue - secondary_delete.append(associationrow) - - tmp.update((c, state) for c in history.added + history.deleted) - - if need_cascade_pks: - for child in history.unchanged: - associationrow = {} - sync.update( - state, - self.parent, - associationrow, - "old_", - self.prop.synchronize_pairs, - ) - sync.update( - child, - self.mapper, - associationrow, - "old_", - self.prop.secondary_synchronize_pairs, - ) - - secondary_update.append(associationrow) - - if processed is not None: - processed.update(tmp) - - self._run_crud( - uowcommit, secondary_insert, secondary_update, secondary_delete - ) - - def _run_crud( - self, uowcommit, secondary_insert, secondary_update, secondary_delete - ): - connection = uowcommit.transaction.connection(self.mapper) - - if secondary_delete: - associationrow = secondary_delete[0] - statement = self.secondary.delete().where( - sql.and_( - *[ - c == sql.bindparam(c.key, type_=c.type) - for c in self.secondary.c - if c.key in associationrow - ] - ) - ) - result = connection.execute(statement, secondary_delete) - - if ( - result.supports_sane_multi_rowcount() - ) and result.rowcount != len(secondary_delete): - raise exc.StaleDataError( - "DELETE statement on table '%s' expected to delete " - "%d row(s); Only %d were matched." - % ( - self.secondary.description, - len(secondary_delete), - result.rowcount, - ) - ) - - if secondary_update: - associationrow = secondary_update[0] - statement = self.secondary.update().where( - sql.and_( - *[ - c == sql.bindparam("old_" + c.key, type_=c.type) - for c in self.secondary.c - if c.key in associationrow - ] - ) - ) - result = connection.execute(statement, secondary_update) - - if ( - result.supports_sane_multi_rowcount() - ) and result.rowcount != len(secondary_update): - raise exc.StaleDataError( - "UPDATE statement on table '%s' expected to update " - "%d row(s); Only %d were matched." - % ( - self.secondary.description, - len(secondary_update), - result.rowcount, - ) - ) - - if secondary_insert: - statement = self.secondary.insert() - connection.execute(statement, secondary_insert) - - def _synchronize( - self, state, child, associationrow, clearkeys, uowcommit, operation - ): - # this checks for None if uselist=True - self._verify_canload(child) - - # but if uselist=False we get here. If child is None, - # no association row can be generated, so return. - if child is None: - return False - - if child is not None and not uowcommit.session._contains_state(child): - if not child.deleted: - util.warn( - "Object of type %s not in session, %s " - "operation along '%s' won't proceed" - % (mapperutil.state_class_str(child), operation, self.prop) - ) - return False - - sync.populate_dict( - state, self.parent, associationrow, self.prop.synchronize_pairs - ) - sync.populate_dict( - child, - self.mapper, - associationrow, - self.prop.secondary_synchronize_pairs, - ) - - return True - - def _pks_changed(self, uowcommit, state): - return sync.source_modified( - uowcommit, state, self.parent, self.prop.synchronize_pairs - ) - - -_direction_to_processor = { - ONETOMANY: OneToManyDP, - MANYTOONE: ManyToOneDP, - MANYTOMANY: ManyToManyDP, -} -- cgit v1.2.3