Est possible de créer une Colonne dans SQLAlchemy qui va être rempli automatiquement avec le temps, quand il insérée/mis à jour la dernière fois?

Est possible de créer une Colonne dans SQLAlchemy qui va être rempli automatiquement avec le temps, quand il insérée/mis à jour la dernière fois ?
J'ai créé des modèles, hérité de la classe de Base

class Base(object):
    def __tablename__(self):
        return self.__name__.lower()
    id = Column(Integer, primary_key=True)
    last_time = Column(TIMESTAMP, server_default=func.now())

Base = declarative_base(cls=Base)

class EntityModel(Base):
    __tablename__ = 'entities'
    settlement_id = Column(Integer, ForeignKey('settlements.id'), nullable=False)
    type = Column(String(20), nullable=False)
    level = Column(Integer, nullable=False, default=0)
    energy = Column(Float, nullable=False, default=0)
    position_x = Column(Integer, default=0)
    position_y = Column(Integer, default=0)

    def __repr__(self):
        return "<Entity('%s')>" % (self.type)

À chaque fois quand je l'ai mise à jour EntityModel je veux last_time être uodated sur le fonctionnement du système.maintenant(). Je peux le faire sur databse niveau avec des déclencheurs, mais je préfère le faire sur demande si c'est possible.

InformationsquelleAutor PaolaJ. | 2012-12-20
  1. 41

    Dans la classe de Base ajouter onupdate dans la dernière phrase comme suit:

    last_time = Column(TIMESTAMP, server_default=func.now(), onupdate=func.current_timestamp())
    • Vous ne voulez pas appeler la fonction dans la définition de la colonne, mais plutôt de passer une référence à la fonction elle-même.
    • la touche func.maintenant() n'est pas un appel de fonction. Cela permet seulement de SQLAlchemy générer de l'expression SQL pour obtenir le timestamp.
    • Gotcha, j'ai mal compris ce que l'OP a dit avec "au lieu de le faire sur le niveau d'application" comme voulant appeler une fonction Python pour le faire dans ses modèles (i.e. de type datetime.maintenant)
    • Toute personne intrigué par la présence de deux func.now et func.current_timestamp dans le code ci-dessus, notez qu'ils sont des alias de l'autre (voir docs.sqlalchemy.org/en/latest/core/...).
    InformationsquelleAutor tigeronk2
  2. 12

    Si vous utilisez MySQL, je crois que vous ne pouvez avoir qu'un auto-mise à jour de colonne datetime, nous utilisons donc des SQLAlchemy de l'événement déclenche la place.

    Vous suffit de connecter un écouteur à l' 'before_insert" et " before_update de crochets et de mise à jour que nécessaire:

    from sqlalchemy import event

@event.listen(YourModel, 'before_insert')
def update_created_modified_on_create_listener(mapper, connection, target):
  """ Event listener that runs before a record is updated, and sets the create/modified field accordingly."""
  target.created = datetime.utcnow()
  target.modified = datetime.utcnow()

@event.listen(YourModel, 'before_update')
def update_modified_on_update_listener(mapper, connection, target):
  """ Event listener that runs before a record is updated, and sets the modified field accordingly."""
  # it's okay if this field doesn't exist - SQLAlchemy will silently ignore it.
  target.modified = datetime.utcnow()

    Je savais que personne ne serait jamais n'oubliez pas de l'ajouter à de nouveaux modèles, donc j'ai essayé de faire le malin et de l'ajouter pour eux.

    Tous nos modèles héritent d'un objet de base nous habilement appelé "DatabaseModel". Nous vérifions qui hérite de cet objet et ajouter dynamiquement des éléments déclencheurs pour tous.

    C'est OK si un modèle n'ont pas créé ou modifié champ - SQLAlchemy semble ignorer en silence il.

    class DatabaseModel(db.Model):
  __abstract__ = True

  #...other stuff...

  @classmethod
  def _all_subclasses(cls):
    """ Get all subclasses of cls, descending. So, if A is a subclass of B is a subclass of cls, this
    will include A and B.
    (Does not include cls) """
    children = cls.__subclasses__()
    result = []
    while children:
      next = children.pop()
      subclasses = next.__subclasses__()
      result.append(next)
      for subclass in subclasses:
        children.append(subclass)
    return result

def update_created_modified_on_create_listener(mapper, connection, target):
  """ Event listener that runs before a record is updated, and sets the create/modified field accordingly."""
  # it's okay if one of these fields doesn't exist - SQLAlchemy will silently ignore it.
  target.created = datetime.utcnow()
  target.modified = datetime.utcnow()

def update_modified_on_update_listener(mapper, connection, target):
  """ Event listener that runs before a record is updated, and sets the modified field accordingly."""
  # it's okay if this field doesn't exist - SQLAlchemy will silently ignore it.
  target.modified = datetime.utcnow()


for cls in DatabaseModel._all_subclasses():
  event.listen(cls, 'before_insert',  update_created_modified_on_create_listener)
  event.listen(cls, 'before_update',  update_modified_on_update_listener)
    InformationsquelleAutor Rachel Sanders
  3. 3

    Il est intéressant de noter que, si vous suivez Rachel Sanders' recommandation, vous devriez certainement faire:

    if object_session(target).is_modified(target, include_collections=False):
    target.modified = datetime.utcnow()

    dans le cadre de la update_modified_on_update_listener() de l'écouteur d'événement, sinon, vous allez faire des tonnes de base de données redondante mises à jour. La caisse http://docs.sqlalchemy.org/en/latest/orm/events.html#mapper-events dans la section "before_update" pour plus d'informations.

    InformationsquelleAutor advance512