SQLAlchemy: campo único del modelo de volver a guardar después de tratar de ahorrar no único valor

Question

En mi aplicación SQLAlchemy tengo el siguiente modelo:

from sqlalchemy import Column, String 
from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy.orm import scoped_session, sessionmaker 
from zope.sqlalchemy import ZopeTransactionExtension 

DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension())) 

class MyModel(declarative_base()): 
    # ... 
    label = Column(String(20), unique=True) 

    def save(self, force=False): 
     DBSession.add(self) 
     if force: 
      DBSession.flush() 

Más adelante en el código para cada nuevo MyModel objetos que desea generar label al azar , y solo regenere si el valor generado ya existe en DB.
estoy tratando de hacer lo siguiente:

# my_model is an object of MyModel 
while True: 
    my_model.label = generate_label() 
    try: 
     my_model.save(force=True) 
    except IntegrityError: 
     # label is not unique - will do one more iteration 
     # (*) 
     pass 
    else: 
     # my_model saved successfully - exit the loop 
     break 

pero este error en caso de que generó por primera vez label no es única y save() llamados en el segundo (o posterior) de iteración:

InvalidRequestError: This Session's transaction has been rolled back due to a previous exception during flush. To begin a new transaction with this Session, first issue Session.rollback(). Original exception was: (IntegrityError) column url_label is not unique... 

cuando agrego DBSession.rollback() en la posición (*) me sale esto:

ResourceClosedError: The transaction is closed 

¿Qué debo hacer para manejar esta situación correctamente?
Gracias

Answer 1

Si su objeto session retrocede esencialmente tiene que crear una nueva sesión y actualizar sus modelos antes de poder comenzar de nuevo. Y si usa zope.sqlalchemy, debe usar transaction.commit() y transaction.abort() para controlar cosas. Así que su bucle sería algo como esto:

# you'll also need this import after your zope.sqlalchemy import statement 
import transaction 

while True: 
    my_model.label = generate_label() 
    try: 
     transaction.commit() 
    except IntegrityError: 
     # need to use zope.sqlalchemy to clean things up 
     transaction.abort() 
     # recreate the session and re-add your object 
     session = DBSession() 
     session.add(my_model) 
    else: 
     break 

He tirado el uso del objeto de sesión de método del objeto save aquí. No estoy del todo seguro de cómo se actualiza el ScopedSession cuando se usa en el nivel de clase como lo ha hecho. Personalmente, creo que incrustar SqlAlchemy cosas dentro de sus modelos realmente no funciona bien con el enfoque de SqlAlchemy unit of work de ninguna manera.

Si su objeto de etiqueta es realmente un valor generado y único, entonces estaría de acuerdo con TokenMacGuy y simplemente use un valor de uuid.

Espero que ayude.

Answer 2

bases de datos no tienen una forma consistente de que le dice qué una transacción falló, en una forma que sea accesible para la automatización. En general, no puede intentar la transacción y luego volver a intentarlo porque falló por algún motivo en particular.

Si conoce una condición que quiere evitar (como una restricción única), lo que tiene que hacer es verificar la restricción usted mismo. En sqlalchemy, eso va a ser algo como esto:

# Find a unique label 
label = generate_label() 
while DBsession.query(
     sqlalchemy.exists(sqlalchemy.orm.Query(Model) 
        .filter(Model.lable == label) 
        .statement)).scalar(): 
    label = generate_label() 

# add that label to the model 
my_model.label = label 
DBSession.add(my_model) 
DBSession.flush() 

---

edición: Otra manera de responder a esto es que usted no debe intentar automáticamente la transacción; En su lugar, puede devolver un código de estado HTTP de 307 Temporary Redirect (con un poco de sal en la URL redirigida) para que la transacción se inicie realmente.

Answer 3

Me enfrenté a un problema similar en mi aplicación web escrita en Pyramid framework. Encontré una solución un poco diferente para ese problema.

while True: 
    try: 
     my_model.label = generate_label() 
     DBSession.flush() 
     break 
    except IntegrityError: 
     # Rollback will recreate session: 
     DBSession.rollback() 
     # if my_model was in db it must be merged: 
     my_model = DBSession.merge(my_model) 

La parte de fusión es crucial si el my_model se almacenó anteriormente. Sin fusión, la sesión estaría vacía, por lo que Flush no tomaría ninguna medida.