¿Cómo elimino y reemplazo una colección en una relación de uno a muchos en Grails/Groovy

Question

? Esta pregunta consta de dos partes, la primera parte se trata de borrar una lista y la segunda parte se trata de asignar un propietario a un objeto.

Tengo una relación uno a muchos entre dos objetos de dominio en mi modelo en Grails. La relación se ve así ...

class Person { 

    static hasMany = [authorities: Role, locations: Location] 
} 

class Location { 

    static belongsTo = Person 

} 

En mi aplicación en la lista locationsPerson queda completamente renovado y reemplazado con una nueva lista en una acción del usuario. Además, obtengo la lista de los objetos Location independientes del Person asociado. Resuelvo a qué persona aplicarlos recuperando el usuario actualmente conectado, al que llamo activePerson y está bien para mis propósitos.

Lo que quiero hacer es eliminar todas las ubicaciones existentes en activePerson e insertar todas las nuevas, asociándolas con el activePerson sobre la marcha. Tengo un montón de propiedades en Person que no quiero que persistan en este momento, así que quiero evitar guardar todo el objeto principal solo porque las ubicaciones de los elementos han cambiado.

Pensé en iterar a través de la lista activePerson.locations y eliminarlos uno por uno y confiar en GORM/Hibernate para agrupar las consultas en conjunto y vaciar al final. Esto parece una fuerza bruta, aunque podría funcionar. Esperaba que hubiera un método clearLocations o algo similar, pero no puedo encontrar uno.

Si solo reemplazo el activePerson.locations con una nueva lista y llame al activePerson.save(flush:true), ¿GORM manejará la eliminación de las filas existentes?

En segundo lugar, quiero poner los nuevos objetos Location en . Una vez más pude llenar el activePerson.locations y guardar todo, pero me gustaría evitar eso si puedo. Puedo guardarlos individualmente, pero ¿cómo configuro belongsTo en cada objeto Location mientras voy?

Así que para recapitular:

1. ¿Cómo se borra una lista en la que muchos terminan de una colección de uno a muchos?
2. ¿Cómo puedo asociar objetos independientes con un objeto primario y persistirlos individualmente?

Gracias

Answer 1

Para # 1 puede borrar la colección (que es un conjunto por defecto):

activePerson.locations.clear() 

Para # 2 addToLocations uso:

activePerson.addToLocations(location) 

y cuando salvar a la persona la ubicación < -> relación persona se actualizará.

Answer 2

Borrado Collection enfoque no funcionó para mí:

activePerson.locations.clear() 

Solo trata de iterar sobre la colección con evitar ConcurrentModificationException llamando collect():

activePerson.locations.collect().each { 
    item.removeFromLocations(it) 
} 

Y después de eso guardar la entidad para ejecutar SQL :

activePerson.save flush:true 

---

Enlace al artículo para leer más: http://spring.io/blog/2010/07/02/gorm-gotchas-part-2/

Answer 3

Si bien esto es una cuestión mayor, me encontré con una situación muy similar en el que quería actualizar un conjunto de registros secundarios. Así es como elegí resolverlo. Para simplificar, usaré los mismos nombres de objeto/relación que el asker de la pregunta.

1. En el bloque del dominio principal mapping, añadir:

   static mapping = { 
       locations(cascade: "all-delete-orphan") 
   } 
   

2. En el dominio secundario, añadir la anotación @EqualsAndHashCode (por si acaso hay otro al acecho, me refiero a groovy.transform.EqualsAndHashCode).

3. Agregue todos los elementos secundarios al dominio principal utilizando los métodos Grails addTo (por ejemplo, addToLocations) y luego guarde el dominio principal.

Si bien este enfoque requiere guardar el dominio principal (que el autor de la pregunta no quería hacer), que parece que es el enfoque más apropiado dada la belongsTo definición clara en el modelo. Por lo tanto, me gustaría responder a las preguntas numeradas del autor de la pregunta de esta manera:

1. En lugar de hacerlo manualmente, vamos Grails/Hibernate borrar los registros especificando el comportamiento all-delete-oprhan en cascada sobre la relación.

2. No intente guardar los registros secundarios directamente, sino que guarde el objeto primario para que coincida con lo que Grails parece esperar.