Hibernate SQLServer/Batch仅插入新记录

Question

我正在尝试使用Hibernate 4.3和SQL Server 2014，仅对尚未存储的实体执行批量插入到表中。我创建了一个简单的表，其中定义了一个主键来忽略重复的键

create table items 
(
    itemid uniqueidentifier not null, 
    itemname nvarchar(30) not null, 
)
alter table items add constraint items_pk primary key ( itemid ) with ( ignore_dup_key = on );

尝试通过Stateless会话插入方法执行批处理插入，如果一个或多个实体已经存储到数据库表中，则批处理插入可能会失败：Hibernate抛出StaleStateException：

org.hibernate.StaleStateException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1
    at org.hibernate.jdbc.Expectations$BasicExpectation.checkBatched(Expectations.java:81)
    at org.hibernate.jdbc.Expectations$BasicExpectation.verifyOutcome(Expectations.java:73)
    at org.hibernate.engine.jdbc.batch.internal.NonBatchingBatch.addToBatch(NonBatchingBatch.java:63)
    at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:3124)
    at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:3581)
    at org.hibernate.internal.StatelessSessionImpl.insert(StatelessSessionImpl.java:144)
    at org.hibernate.internal.StatelessSessionImpl.insert(StatelessSessionImpl.java:123)
    at it.test.testingestion.HibernateStatelessSessionPersisterImpl.persistData(HibernateStatelessSessionPersisterImpl.java:18)
    at it.test.testingestion.App.main(App.java:76)

当批处理语句完成时，Hibernate会检查返回的行数，由于忽略重复键，返回的行数与预期的不同。

使用JDBC，使用准备好的语句执行批插入，将跳过已存储到目标表中的实体，但会正确保存新实体。

如何将Hibernate配置为忽略现有数据执行批插入，或不执行受影响行的检查？

谢谢

更新#1

作为解决方法，为了强制影响的行数，即使发生重复插入，我创建了以下Hibernate Interceptor：

public class CustomInterceptor extends EmptyInterceptor {

    private static final long serialVersionUID = -8022068618978801796L;

    private String getTemporaryTableName() {
        String currentThreadName = Thread.currentThread().getName();
        return "##" + currentThreadName.replaceAll("[^A-Za-z0-9\\_]", "");
    }

    private void createTemporaryTable(Connection connection) {
        String tempTableName = this.getTemporaryTableName();
        String commandText = String.format("if (object_id('tempdb.dbo.%s') is null) begin create table [%s] ( dummyfield int ); insert into %s ( dummyfield ) values ( 0 ) end ", tempTableName, tempTableName, tempTableName);
        try (PreparedStatement statement = connection.prepareStatement(commandText)) {
            statement.execute();
            connection.commit();
        } catch (SQLException e) {
            throw new RuntimeException(String.format("An error has been occurred trying to create the temporary table %s", tempTableName), e);
        }
    }

    public CustomInterceptor(Connection connection) {
        this.createTemporaryTable(connection);
    }

    @Override
    public String onPrepareStatement(String sql) {
        int ps = sql.toLowerCase().indexOf("insert into ");
        if (ps == 0) {
            String tableName = this.getTemporaryTableName();
            return sql + "; if (@@rowcount = 0) update [" + tableName + "] set dummyfield = 1"; 
        }
        return super.onPrepareStatement(sql);
    }

}

当创建新实例时，拦截器会创建一个新的临时表，插入一条新记录。截取insert语句时，如果insert语句未影响任何行，则会执行保存到实例化临时表中的记录的更新：如果插入了重复实体且未引发无状态SessionImpl异常，则这会使Hibernate对返回的行事件保持Hibernate。

显然，这一技巧的缺点是，对未插入表中的每一行执行额外更新的成本。

有没有人知道一种更好的方法，不影响插入性能，将实体插入到使用Hibernate忽略重复条目的表中？

谢谢

Answer 1

为了获得更好的性能，我更喜欢使用JDBCBatchUpdate

方法1：

当您过滤新记录时，记录的数量不会成为约束。因此，您可以在实体层中指定关联映射，并可以执行Hibernate批处理插入或JDBC批处理更新。

方法2：使用本机SQl查询

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
//get Connction from Session
session.doWork(new Work() {
       @Override
       public void execute(Connection conn) throws SQLException {
          PreparedStatement pstmt = null;
          try{
           String sqlInsert = "insert into tbl(name) values (?) ";
           pstmt = conn.prepareStatement(sqlInsert );
           int i=0;
           for(String name : list){
               pstmt .setString(1, name);
               pstmt .addBatch();

               //20 : JDBC batch size
             if ( i % 20 == 0 ) { 
                pstmt .executeBatch();
              }
              i++;
           }
           pstmt .executeBatch();
         }
         finally{
           pstmt .close();
         }                                
     }
});
tx.commit();
session.close();