def set_current_version( cls, fixture_class = None, fixture_version = 0 ): """Set the current version of the fixtures in the database for a certain fixture class. :param fixture_class: the fixture class for which to get the version :param fixture_version: the version number to which to set the fixture version """ from sqlalchemy.orm.session import Session obj = Session().query( cls ).filter_by( fixture_class = fixture_class ).first() if not obj: obj = FixtureVersion( fixture_class = fixture_class ) obj.fixture_version = fixture_version Session.object_session( obj ).flush()
def set_current_version(cls, fixture_class=None, fixture_version=0): """Set the current version of the fixtures in the database for a certain fixture class. :param fixture_class: the fixture class for which to get the version :param fixture_version: the version number to which to set the fixture version """ from sqlalchemy.orm.session import Session obj = Session().query(cls).filter_by( fixture_class=fixture_class).first() if not obj: obj = FixtureVersion(fixture_class=fixture_class) obj.fixture_version = fixture_version Session.object_session(obj).flush()
def flush(self, entity_instance): """Flush the pending changes of this entity instance to the backend""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: modifications = {} try: modifications = self.get_modifications( entity_instance ) except Exception, e: # todo : there seems to be a bug in sqlalchemy that causes the # get history to fail in some cases logger.error( 'could not get modifications from object', exc_info = e ) session.flush( [entity_instance] ) # # If needed, track the changes # primary_key = self.primary_key( entity_instance ) if modifications and (primary_key != None) and len(primary_key)==1: from camelot.model.memento import Memento # only register the update when the camelot model is active if hasattr(Memento, 'query'): from camelot.model.authentication import get_current_authentication history = Memento( model = unicode( self.entity.__name__ ), memento_type = 'before_update', primary_key = primary_key[0], previous_attributes = modifications, authentication = get_current_authentication() ) try: history.flush() except exc.DatabaseError, e: self.logger.error( 'Programming Error, could not flush history', exc_info = e )
def flush(self, entity_instance): """Flush the pending changes of this entity instance to the backend""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: modifications = {} try: modifications = self.get_modifications( entity_instance ) except Exception, e: # todo : there seems to be a bug in sqlalchemy that causes the # get history to fail in some cases logger.error( 'could not get modifications from object', exc_info = e ) session.flush( [entity_instance] ) # # If needed, track the changes # primary_key = self.primary_key( entity_instance ) if modifications and (None not in primary_key): memento = self.get_memento() if memento != None: change = memento_change( model = unicode( self.entity.__name__ ), memento_type = 'before_update', primary_key = primary_key, previous_attributes = modifications ) memento.register_changes( [change] )
def delete(self, entity_instance): """Delete an entity instance""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) # # new and deleted instances cannot be deleted # if session: if entity_instance in session.new: session.expunge(entity_instance) elif (entity_instance not in session.deleted) and \ (entity_instance in session): # if the object is not in the session, it might already be deleted # # only if we know the primary key, we can keep track of its history # primary_key = self.primary_key( entity_instance ) if not None in primary_key: # save the state before the update memento = self.get_memento() if memento != None: modifications = dict() change = memento_change( model = unicode( self.entity.__name__ ), memento_type = 'before_delete', primary_key = primary_key, previous_attributes = modifications ) memento.register_changes( [change] ) session.delete( entity_instance ) session.flush( [entity_instance] )
def delete(self, entity_instance): """Delete an entity instance""" session = Session.object_session( entity_instance ) # # new and deleted instances cannot be deleted # if session: if entity_instance in session.new: session.expunge(entity_instance) elif entity_instance not in session.deleted: # # only if we know the primary key, we can keep track of its history # primary_key = self.primary_key( entity_instance ) if not None in primary_key: # save the state before the update memento = self.get_memento() if memento != None: modifications = entity_to_dict( entity_instance ) change = memento_change( model = unicode( self.entity.__name__ ), memento_type = 'before_delete', primary_key = primary_key, previous_attributes = modifications ) memento.register_changes( [change] ) session.delete( entity_instance ) self.flush( entity_instance )
def delete(self, entity_instance): """Delete an entity instance""" session = Session.object_session(entity_instance) # # new and deleted instances cannot be deleted # if session: if entity_instance in session.new: session.expunge(entity_instance) elif entity_instance not in session.deleted: # # only if we know the primary key, we can keep track of its history # primary_key = self.primary_key(entity_instance) if not None in primary_key: # save the state before the update memento = self.get_memento() if memento != None: modifications = entity_to_dict(entity_instance) change = memento_change( model=six.text_type(self.entity.__name__), memento_type='before_delete', primary_key=primary_key, previous_attributes=modifications) memento.register_changes([change]) session.delete(entity_instance) session.flush()
def flush(self, entity_instance): """Flush the pending changes of this entity instance to the backend""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: objects_to_flush = set([entity_instance]) self._expand_compounding_objects( objects_to_flush ) # # Create a list of changes # changes = [] for obj_to_flush in objects_to_flush: if obj_to_flush in session.dirty: modifications = {} try: modifications = self.get_modifications( obj_to_flush ) except Exception, e: # todo : there seems to be a bug in sqlalchemy that causes the # get history to fail in some cases logger.error( 'could not get modifications from object', exc_info = e ) primary_key = self.primary_key( obj_to_flush ) if modifications and (None not in primary_key): change = memento_change( model = unicode( self.entity.__name__ ), memento_type = 'before_update', primary_key = primary_key, previous_attributes = modifications ) changes.append( change ) session.flush( objects_to_flush ) # # If needed, track the changes # memento = self.get_memento() if changes and memento != None: memento.register_changes( changes )
def add( self, obj ): """Adds the entity instance to the default session, if it is not yet attached to a session""" import elixir session = Session.object_session( obj ) if session == None: elixir.session.add( obj )
def refresh(self, entity_instance): """Undo the pending changes to the backend and restore the original state""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: if not self.is_deleted( entity_instance ): session.refresh( entity_instance )
def is_persistent(self, obj): """:return: True if the object has a persisted state, False otherwise""" from sqlalchemy.orm.session import Session session = Session.object_session(obj) if session: if obj in session.new: return False if obj in session.deleted: return False return True return False
def is_persistent(self, obj): """:return: True if the object has a persisted state, False otherwise""" from sqlalchemy.orm.session import Session session = Session.object_session( obj ) if session: if obj in session.new: return False if obj in session.deleted: return False return True return False
def remove_fixture(cls, entity, fixture_key, fixture_class): """ Remove data from the database, if it was stored through the fixture mechanism. :param entity: the class of the stored data :param fixture_key: a string used to refer to the stored data :param fixture_class: a string used to refer to a group of stored data """ # remove the object itself from sqlalchemy.orm.session import Session obj = cls.find_fixture(entity, fixture_key, fixture_class) obj.delete() Session.object_session(obj).flush() # if this succeeeds, remove the reference reference = cls.find_fixture_reference(entity, fixture_key, fixture_class) reference.delete() Session.object_session(reference).flush()
def remove_fixture( cls, entity, fixture_key, fixture_class ): """ Remove data from the database, if it was stored through the fixture mechanism. :param entity: the class of the stored data :param fixture_key: a string used to refer to the stored data :param fixture_class: a string used to refer to a group of stored data """ # remove the object itself from sqlalchemy.orm.session import Session obj = cls.find_fixture( entity, fixture_key, fixture_class) obj.delete() Session.object_session( obj ).flush() # if this succeeeds, remove the reference reference = cls.find_fixture_reference( entity, fixture_key, fixture_class ) reference.delete() Session.object_session( reference ).flush()
def insert_or_update_fixture( cls, entity, fixture_key, values, fixture_class = None ): """Store data in the database through the fixture mechanism, to be able to keep track of it later. :param entity: the class of the stored data :param fixture_key: a string used to refer to the stored data :param values: a dictionary with the data that should be insert or updated in the database :param fixture_class: a string used to refer to a group of stored data :return: an object of type entity, either created or modified """ from sqlalchemy.orm.session import Session obj = cls.find_fixture( entity, fixture_key, fixture_class ) store_fixture = False if not obj: obj = entity() store_fixture = True obj.from_dict( values ) Session.object_session( obj ).flush() if store_fixture: # # The fixture itself might have been deleted, but the reference # might be intact, so this should be updated # reference = cls.find_fixture_reference( entity, fixture_key, fixture_class ) if not reference: reference = cls( model = unicode( entity.__name__ ), primary_key = obj.id, fixture_key = fixture_key, fixture_class = fixture_class ) else: reference.primary_key = obj.id Session.object_session( reference ).flush() return obj
def insert_or_update_fixture(cls, entity, fixture_key, values, fixture_class=None): """Store data in the database through the fixture mechanism, to be able to keep track of it later. :param entity: the class of the stored data :param fixture_key: a string used to refer to the stored data :param values: a dictionary with the data that should be insert or updated in the database :param fixture_class: a string used to refer to a group of stored data :return: an object of type entity, either created or modified """ from sqlalchemy.orm.session import Session obj = cls.find_fixture(entity, fixture_key, fixture_class) store_fixture = False if not obj: obj = entity() store_fixture = True obj.from_dict(values) Session.object_session(obj).flush() if store_fixture: # # The fixture itself might have been deleted, but the reference # might be intact, so this should be updated # reference = cls.find_fixture_reference(entity, fixture_key, fixture_class) if not reference: reference = cls(model=six.text_type(entity.__name__), primary_key=obj.id, fixture_key=fixture_key, fixture_class=fixture_class) else: reference.primary_key = obj.id Session.object_session(reference).flush() return obj
def delete(self, entity_instance): """Delete an entity instance""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) # # new and deleted instances cannot be deleted # if session: if entity_instance in session.new: session.expunge(entity_instance) elif (entity_instance not in session.deleted) and \ (entity_instance in session): # if the object is not in the session, it might already be deleted history = None # # only if we know the primary key, we can keep track of its history # primary_key = self.mapper.primary_key_from_instance(entity_instance) # # we can only store history of objects where the primary key has only # 1 element # @todo: store history for compound primary keys # if not None in primary_key and len(primary_key)==1: pk = primary_key[0] # save the state before the update from camelot.model.memento import Memento # only register the delete when the camelot model is active if hasattr(Memento, 'query'): from camelot.model.authentication import get_current_authentication history = Memento( model = unicode( self.entity.__name__ ), memento_type = 'before_delete', primary_key = pk, previous_attributes = {}, authentication = get_current_authentication() ) entity_instance.delete() session.flush( [entity_instance] ) if history: Session.object_session( history ).flush( [history] )
def flush(self, entity_instance): """Flush the pending changes of this entity instance to the backend""" from sqlalchemy.orm.session import Session session = Session.object_session(entity_instance) if session: objects_to_flush = set([entity_instance]) self._expand_compounding_objects(objects_to_flush) # # Create a list of changes # changes = [] for obj_to_flush in objects_to_flush: if obj_to_flush in session.dirty: modifications = {} try: modifications = self.get_modifications(obj_to_flush) except Exception as e: # todo : there seems to be a bug in sqlalchemy that causes the # get history to fail in some cases logger.error('could not get modifications from object', exc_info=e) primary_key = self.primary_key(obj_to_flush) if modifications and (None not in primary_key): change = memento_change( model=six.text_type(type(obj_to_flush).__name__), memento_type='before_update', primary_key=primary_key, previous_attributes=modifications) changes.append(change) session.flush(objects_to_flush) # # If needed, track the changes # memento = self.get_memento() if changes and memento != None: memento.register_changes(changes)
def add(self, obj): """Adds the entity instance to the default session, if it is not yet attached to a session""" session = Session.object_session(obj) if session == None: Session().add(obj)
def expunge(self, entity_instance): """Expunge the entity from the session""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: session.expunge( entity_instance )