Hibernate: la actualización por lotes devolvió un recuento de filas inesperado de la actualización: 0 recuento de filas real: 0 esperado: 1

Me aparece el siguiente error de hibernación. Puedo identificar la función que causa el problema. Lamentablemente, hay varias llamadas de DB en la función. No puedo encontrar la línea que causa el problema ya que hibernate limpia la sesión al final de la transacción. El error de hibernación mencionado a continuación parece un error general. Ni siquiera mencionó qué Bean causa el problema. ¿Alguien familiarizado con este error de hibernación?

org.hibernate.StaleStateException: Batch update returned unexpected row count from update: 0 actual row count: 0 expected: 1
        at org.hibernate.jdbc.BatchingBatcher.checkRowCount(BatchingBatcher.java:93)
        at org.hibernate.jdbc.BatchingBatcher.checkRowCounts(BatchingBatcher.java:79)
        at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:58)
        at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:195)
        at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:235)
        at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:142)
        at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:297)
        at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:27)
        at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:985)
        at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:333)
        at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:106)
        at org.springframework.orm.hibernate3.HibernateTransactionManager.doCommit(HibernateTransactionManager.java:584)
        at org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransacti
onManager.java:500)
        at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManag
er.java:473)
        at org.springframework.transaction.interceptor.TransactionAspectSupport.doCommitTransactionAfterReturning(Transaction
AspectSupport.java:267)
        at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:106)
        at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:170)
        at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:176)

Sin el código y las asignaciones para sus transacciones, será casi imposible investigar el problema.

Sin embargo, para comprender mejor qué causa el problema, intente lo siguiente:

• En su configuración de hibernación, establezca hibernate.show_sql en verdadero. Esto debería mostrar el SQL que se ejecuta y causa el problema.
• Establezca los niveles de registro para Spring e Hibernate en DEBUG, nuevamente, esto le dará una mejor idea de qué línea causa el problema.
• Cree una prueba unitaria que reproduzca el problema sin configurar un administrador de transacciones en Spring. Esto debería darle una mejor idea de la línea de código ofensiva.

Espero que ayude.

Obtuve la misma excepción al eliminar un registro por Id que no existe en absoluto. Así que verifique que el registro que está actualizando / eliminando realmente exista en DB

Solución: en el archivo de mapeo Hibernate para la propiedad id, si usa cualquier clase de generador, para esa propiedad no debe establecer el valor explícitamente utilizando un método setter.

Si establece el valor de la propiedad Id explícitamente, generará el error anterior. Marque esto para evitar este error. o Se muestra un error cuando menciona en el archivo de mapeo el campo generador = "nativo" o "incremental" y en su BASE DE DATOS la tabla asignada no está auto_incrementada Solución: vaya a su BASE DE DATOS y actualice su tabla para configurar auto_increment

Esto me sucedió una vez por accidente cuando estaba asignando ID específicos a algunos objetos (pruebas) y luego intentaba guardarlos en la base de datos. El problema era que en la base de datos había una política específica para configurar las ID de los objetos. Simplemente no asigne una identificación si tiene una política a nivel de Hibernate.

En mi caso, llegué a esta excepción en dos casos similares:

• En un método anotado con @Transactional, tuve una llamada a otro servicio (con largos tiempos de respuesta). El método actualiza algunas propiedades de la entidad (después del método, la entidad todavía existe en la base de datos). Si el usuario solicita dos veces el método (ya que piensa que no funciona la primera vez) al salir del método transaccional la segunda vez, Hibernate intenta actualizar una entidad que ya cambió su estado desde el comienzo de la transacción. A medida que Hibernate busca una entidad en un estado y encuentra la misma entidad pero que ya cambió con la primera solicitud, arroja una excepción ya que no puede actualizar la entidad. Es como un conflicto en GIT.
• Tuve solicitudes automáticas (para monitorear la plataforma) que actualizan una entidad (y la reversión manual unos segundos después). Pero esta plataforma ya la utiliza un equipo de prueba. Cuando un probador realiza una prueba en la misma entidad que las solicitudes automáticas (dentro de la misma centésima de milisegundo), obtengo la excepción. Como en el caso anterior, al salir de la segunda transacción, la entidad obtenida previamente ya cambió.

Conclusión: en mi caso, no fue un problema que se puede encontrar en el código. Esta excepción se produce cuando Hibernate descubre que la entidad obtenida por primera vez de la base de datos cambió durante la transacción actual , por lo que no puede vaciarla a la base de datos ya que Hibernate no sabe cuál es la versión correcta de la entidad: la actual búsqueda de transacciones al principio; o el que ya está almacenado en la base de datos.

Solución: para resolver el problema, tendrá que jugar con Hibernate LockMode para encontrar el que mejor se adapte a sus necesidades.

Acabo de encontrar este problema y descubrí que estaba eliminando un registro e intentando actualizarlo luego en una transacción de Hibernate.

Esto puede suceder cuando los desencadenantes ejecutan consultas DML (modificación de datos) adicionales que afectan los recuentos de filas. Mi solución fue agregar lo siguiente en la parte superior de mi disparador:

SET NOCOUNT ON;

Estaba enfrentando el mismo problema. El código funcionaba en el entorno de prueba. Pero no estaba funcionando en un entorno de ensayo.

org.hibernate.jdbc.BatchedTooManyRowsAffectedException: Batch update returned unexpected row count from update [0]; actual row count: 3; expected: 1

El problema era que la tabla tenía una sola entrada para cada clave primaria en la prueba de la tabla DB. Pero en la puesta en escena DB había múltiples entradas para la misma clave primaria. (El problema está en la puesta en escena de la base de datos, la tabla no tenía restricciones de clave principal y también había entradas múltiples).

Entonces, cada vez que se realiza una operación de actualización, falla. Intenta actualizar un solo registro y espera obtener el recuento de actualizaciones como 1. Pero como había 3 registros en la tabla para la misma clave primaria, el recuento de actualizaciones de resultados encuentra 3. Dado que el recuento de actualizaciones esperado y el recuento de actualizaciones de resultados reales no coinciden , Lanza excepción y retrocede.

Después de que eliminé todos los registros que tienen clave principal duplicada y agregué restricciones de clave principal. Esta funcionando bien

Hibernate - Batch update returned unexpected row count from update: 0 actual row count: 0 expected: 1

recuento de filas real: 0 // significa que no se encontró ningún registro para actualizar la
actualización: 0 // significa que no se encontró ningún registro, por lo que no se
espera ninguna actualización : 1 // significa que se espera al menos 1 registro con clave en la tabla db.

Aquí el problema es que la consulta intenta actualizar un registro para alguna clave, pero hibernate no encontró ningún registro con la clave.

Como dice Julius , esto sucede cuando ocurre una actualización en un objeto que tiene sus hijos eliminados. (Probablemente porque se necesitaba una actualización para todo el objeto Padre y, a veces, preferimos eliminar los hijos y volver a insertarlos en el Padre (lo nuevo, lo viejo no importa) junto con cualquier otra actualización que el padre pueda tener en cualquiera de sus otros campos simples) Entonces ... para que esto funcione, elimine los elementos secundarios (dentro de una transacción) llamando al lado del objeto padre. Luego actualice el padre (fatherDAO.update (father)). (Repita para cada objeto padre) El resultado es que los niños tienen su vínculo con su padre despojado y luego el marco los elimina como huérfanos.childrenList.clear() (No recorra los elementos secundarios y elimine cada uno con algunos childDAO.delete(childrenList.get(i).delete()))y establezca @OneToMany(cascade = CascadeType.XXX ,orphanRemoval=true)

Encontré este problema donde teníamos una relación de muchos.

En el archivo de mapeo hbnate hbm para master, para objeto con arreglo de tipo de conjunto, se agregó cascade="save-update"y funcionó bien.

Sin esto, por defecto hibernate intenta actualizar para un registro inexistente y al hacerlo se inserta en su lugar.

También puede suceder cuando intentas UPDATEuna CLAVE PRIMARIA .

Tengo el mismo problema y verifiqué que esto puede ocurrir debido a la clave primaria de incremento automático. Para resolver este problema, no inserte el valor de incremento automático con el conjunto de datos. Insertar datos sin la clave primaria.

Otra forma de obtener este error es si tiene un elemento nulo en una colección.

sucede cuando intentas eliminar el mismo objeto y luego vuelves a actualizar el mismo objeto, usa esto después de eliminar

session.clear ();

Esto también me sucedió a mí, porque tenía mi ID como Long, y estaba recibiendo de la vista el valor 0, y cuando intenté guardar en la base de datos recibí este error, luego lo arreglé estableciendo el ID en nulo.

Me encontré con este problema cuando comenzaba manualmente y confirmaba transacciones dentro del método anotado como @Transactional. Solucioné el problema al detectar si ya existía una transacción activa.

//Detect underlying transaction
if (session.getTransaction() != null && session.getTransaction().isActive()) {
    myTransaction = session.getTransaction();
    preExistingTransaction = true;
} else {
    myTransaction = session.beginTransaction();
}

Luego permití que Spring manejara la confirmación de la transacción.

private void finishTransaction() {
    if (!preExistingTransaction) {
        try {
            tx.commit();
        } catch (HibernateException he) {
            if (tx != null) {
                tx.rollback();
            }
            log.error(he);
        } finally {
            if (newSessionOpened) {
                SessionFactoryUtils.closeSession(session);
                newSessionOpened = false;
                maxResults = 0;
            }
        }
    }
}

Esto sucede cuando declaraste el JSF Managed Bean como

@RequestScoped;

cuando deberías declarar como

@SessionScoped;

Saludos;

Recibí este error cuando intenté actualizar un objeto con una identificación que no existía en la base de datos. La razón de mi error fue que había asignado manualmente una propiedad con el nombre 'id' a la representación JSON del lado del cliente del objeto y luego, al deserializar el objeto en el lado del servidor, esta propiedad 'id' sobrescribiría la variable de instancia ( también llamado 'id') que se suponía que Hibernate debía generar. Por lo tanto, tenga cuidado al nombrar colisiones si está utilizando Hibernate para generar identificadores.

También me encontré con el mismo desafío. En mi caso, estaba actualizando un objeto que ni siquiera existía, usandohibernateTemplate .

En realidad, en mi aplicación estaba obteniendo un objeto DB para actualizar. Y mientras actualizaba sus valores, también actualicé su ID por error, y seguí actualizándolo y encontré dicho error.

Estoy usando hibernateTemplatepara operaciones CRUD.

Después de leer todas las respuestas, no encontré a nadie para hablar sobre el atributo inverso de hibernación.

En mi opinión, también debe verificar en su mapeo de relaciones si la palabra clave inversa está configurada adecuadamente. Inverso palabra clave se crea para definir de qué lado es el propietario para mantener la relación. El procedimiento para actualizar e insertar varía según este atributo.

Supongamos que tenemos dos tablas:

principal_table , middle_table

con una relación de uno a muchos . Las clases de mapeo de hibernación son Principal y Medio, respectivamente.

Entonces, la clase Principal tiene un SET de objetos intermedios . El archivo de mapeo xml debería ser como sigue:

<hibernate-mapping>
    <class name="path.to.class.Principal" table="principal_table" ...>
    ...
    <set name="middleObjects" table="middle_table" inverse="true" fetch="select">
        <key>
            <column name="PRINCIPAL_ID" not-null="true" />
        </key>
        <one-to-many class="path.to.class.Middel" />
    </set>
    ...

Como inverso se establece en "verdadero", significa que la clase "Media" es el propietario de la relación, por lo que la clase Principal NO ACTUALIZARÁ la relación.

Entonces, el procedimiento de actualización podría implementarse así:

session.beginTransaction();

Principal principal = new Principal();
principal.setSomething("1");
principal.setSomethingElse("2");


Middle middleObject = new Middle();
middleObject.setSomething("1");

middleObject.setPrincipal(principal);
principal.getMiddleObjects().add(middleObject);

session.saveOrUpdate(principal);
session.saveOrUpdate(middleObject); // NOTICE: you will need to save it manually

session.getTransaction().commit();

Esto funcionó para mí, pero puede sugerir algunas ediciones para mejorar la solución. De esa manera todos estaremos aprendiendo.

En nuestro caso, finalmente descubrimos la causa raíz de StaleStateException.

De hecho, estábamos eliminando la fila dos veces en una sola sesión de hibernación. Anteriormente estábamos usando ojdbc6 lib, y esto estaba bien en esta versión.

Pero cuando actualizamos a odjc7 u ojdbc8, eliminar registros dos veces arrojaba una excepción. Hubo un error en nuestro código donde estábamos borrando dos veces, pero eso no era evidente en ojdbc6.

Pudimos reproducir con este código:

Detail detail = getDetail(Long.valueOf(1396451));
session.delete(detail);
session.flush();
session.delete(detail);
session.flush();

En la primera descarga hibernate va y realiza cambios en la base de datos. Durante la segunda descarga, hibernate compara el objeto de la sesión con el registro de la tabla real, pero no pudo encontrar uno, de ahí la excepción.

Este problema se produce principalmente cuando estamos tratando de guardar o actualizar el objeto que ya está siendo recuperado en la memoria por una sesión en ejecución. Si ha obtenido un objeto de la sesión y está intentando actualizar en la base de datos, se puede generar esta excepción.

Usé session.evict (); para eliminar primero el caché almacenado en hibernación o si no quiere arriesgarse a perder datos, mejor haga otro objeto para almacenar la temperatura de datos.

     try
    {
        if(!session.isOpen())
        {
            session=EmployeyDao.getSessionFactory().openSession();
        }
            tx=session.beginTransaction();

        session.evict(e);
        session.saveOrUpdate(e);
        tx.commit();;
        EmployeyDao.shutDown(session);
    }
    catch(HibernateException exc)
    {
        exc.printStackTrace();
        tx.rollback();
    }

Problema de Hibernate 5.4.1 y HHH-12878

Antes de Hibernate 5.4.1, las excepciones optimistas de falla de bloqueo (por ejemplo, StaleStateExceptiono OptimisticLockException) no incluían la declaración de falla.

El problema HHH-12878 se creó para mejorar Hibernate de modo que cuando se lanza una excepción de bloqueo optimista, la PreparedStatementimplementación de JDBC también se registra:

if ( expectedRowCount > rowCount ) {
    throw new StaleStateException(
            "Batch update returned unexpected row count from update ["
                    + batchPosition + "]; actual row count: " + rowCount
                    + "; expected: " + expectedRowCount + "; statement executed: "
                    + statement
    );
}

Tiempo de prueba

Creé BatchingOptimisticLockingTesten mi repositorio GitHub Java Persistence de alto rendimiento para demostrar cómo funciona el nuevo comportamiento.

Primero, definiremos una Postentidad que defina una @Versionpropiedad, permitiendo así el mecanismo de bloqueo optimista implícito :

@Entity(name = "Post")
@Table(name = "post")
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    private String title;

    @Version
    private short version;

    public Long getId() {
        return id;
    }

    public Post setId(Long id) {
        this.id = id;
        return this;
    }

    public String getTitle() {
        return title;
    }

    public Post setTitle(String title) {
        this.title = title;
        return this;
    }

    public short getVersion() {
        return version;
    }
}

Habilitaremos el procesamiento por lotes JDBC utilizando las siguientes 3 propiedades de configuración:

properties.put("hibernate.jdbc.batch_size", "5");
properties.put("hibernate.order_inserts", "true");
properties.put("hibernate.order_updates", "true");

Vamos a crear 3 Postentidades:

doInJPA(entityManager -> {
    for (int i = 1; i <= 3; i++) {
        entityManager.persist(
            new Post()
                .setTitle(String.format("Post no. %d", i))
        );
    }
});

E Hibernate ejecutará una inserción por lotes JDBC:

SELECT nextval ('hibernate_sequence')
SELECT nextval ('hibernate_sequence')
SELECT nextval ('hibernate_sequence')

Query: [
    INSERT INTO post (title, version, id) 
    VALUES (?, ?, ?)
], 
Params:[
    (Post no. 1, 0, 1), 
    (Post no. 2, 0, 2), 
    (Post no. 3, 0, 3)
]

Entonces, sabemos que el procesamiento por lotes JDBC funciona bien.

Ahora, repliquemos el problema optimista de bloqueo:

doInJPA(entityManager -> {
    List<Post> posts = entityManager.createQuery("""
        select p 
        from Post p
        """, Post.class)
    .getResultList();

    posts.forEach(
        post -> post.setTitle(
            post.getTitle() + " - 2nd edition"
        )
    );

    executeSync(
        () -> doInJPA(_entityManager -> {
            Post post = _entityManager.createQuery("""
                select p 
                from Post p
                order by p.id
                """, Post.class)
            .setMaxResults(1)
            .getSingleResult();

            post.setTitle(post.getTitle() + " - corrected");
        })
    );
});

La primera transacción selecciona todas las Postentidades y modifica las titlepropiedades.

Sin embargo, antes de que EntityManagerse vacíe el primero , vamos a ejecutar una segunda transición utilizando el executeSyncmétodo.

La segunda transacción modifica la primera Post, por versionlo que se incrementará:

Query:[
    UPDATE 
        post 
    SET 
        title = ?, 
        version = ? 
    WHERE 
        id = ? AND 
        version = ?
], 
Params:[
    ('Post no. 1 - corrected', 1, 1, 0)
]

Ahora, cuando la primera transacción intente vaciar el EntityManager, obtendremos el OptimisticLockException:

Query:[
    UPDATE 
        post 
    SET 
        title = ?, 
        version = ? 
    WHERE 
        id = ? AND 
        version = ?
], 
Params:[
    ('Post no. 1 - 2nd edition', 1, 1, 0), 
    ('Post no. 2 - 2nd edition', 1, 2, 0), 
    ('Post no. 3 - 2nd edition', 1, 3, 0)
]

o.h.e.j.b.i.AbstractBatchImpl - HHH000010: On release of batch it still contained JDBC statements

o.h.e.j.b.i.BatchingBatch - HHH000315: Exception executing batch [
    org.hibernate.StaleStateException: 
    Batch update returned unexpected row count from update [0]; 
    actual row count: 0; 
    expected: 1; 
    statement executed: 
        PgPreparedStatement [
            update post set title='Post no. 3 - 2nd edition', version=1 where id=3 and version=0
        ]
], 
SQL: update post set title=?, version=? where id=? and version=?

Por lo tanto, debe actualizar a Hibernate 5.4.1 o posterior para beneficiarse de esta mejora.

Esto sucedió si cambia algo en el conjunto de datos utilizando una consulta SQL nativa pero el objeto persistente para el mismo conjunto de datos está presente en la caché de la sesión. Use session.evict (yourObject);

Hibernate almacena en caché los objetos de la sesión. Si el objeto es accedido y modificado por más de 1 usuario, org.hibernate.StaleStateExceptionpuede ser arrojado. Se puede resolver con el método de fusión / actualización de entidad antes de guardar o usar el bloqueo. Más información: http://java-fp.blogspot.lt/2011/09/orghibernatestalestateexception-batch.html

Uno de los casos

SessionFactory sf=new Configuration().configure().buildSessionFactory();
Session session=sf.openSession();

UserDetails user=new UserDetails();

session.beginTransaction();
user.setUserName("update user agian");
user.setUserId(12);
session.saveOrUpdate(user);
session.getTransaction().commit();
System.out.println("user::"+user.getUserName());

sf.close();

Estaba enfrentando esta excepción, e hibernate estaba funcionando bien. Traté de insertar manualmente un registro usando pgAdmin, aquí el problema quedó claro. La consulta de inserción SQL devuelve 0 inserción. y hay una función desencadenante que causa este problema porque devuelve nulo. así que solo tengo que configurarlo para que regrese nuevo. Y finalmente resolví el problema.

Espero que ayude a cualquier cuerpo.

Recibí este error porque mapeé la IDcolumna por error usandoId(x => x.Id, "id").GeneratedBy.**Assigned**();

Problema resuelto usando Id(x => x.Id, "id").GeneratedBy.**Identity**();

Esto me sucede porque me falta la declaración de ID en la clase de bean.

En mi caso, hubo un problema con la base de datos, ya que uno de los Procs almacenados estaba consumiendo toda la CPU causando tiempos de respuesta DB altos. Una vez que esto fue asesinado, el problema se resolvió.