使用select max（）然后插入max（）+ 1来执行Hibernate并发问题

Question

I have a table that has a few columns and a sequence that increments for the value of those columns. For (a simplified) example:

A | B | SEQ
===========
x | x | 1
x | x | 2
x | x | 3
x | y | 1
x | x | 4
z | x | 1
x | y | 2

I have multiple processes that will be using a Spring application with Hibernate and will accept both A and B, select the max value for A and B, and then insert max + 1 .

So, for the example above, if someone provided A = z and B = x, we'd select, get 1 and insert z, x, 2.

If someone provided A = z and B = z (no existing rows match), the process would query and find no max (or a max of zero) and then insert z, z, 1.

Assume that a simple sequence will not work here because the column size for sequence isn't going to be large enough to allow one sequence across all values of A and B and because the actual problem is more complex than the example provided above.

I can think of four solutions to this issue that may work but I'm wondering if there's a more standard way to do this and I'm not sure how any of these methods can be implemented with Hibernate and without using custom Oracle features:

1. Perform the select max() , attempt to insert. If there's a concurrency issue, one of the threads will fail and the code will be written to retry as many times as needed until the insert works. With Hibernate, this may mean we'd have to manually flush in the middle of our transaction.
2. Perform a select for update or some other mechanism to lock the rows we care about (the ones that match A and B) when we're doing the initial select max() . This will block other processes that are also trying to find the max and we can then insert our row and when the txn commits, the selects that are waiting will then be allowed to select. I'm not sure how this would work if there are currently no rows in the table that match A and B, though.
3. Create a stored procedure that does the max select and insert atomically. I'd like to avoid stored procs if possible, though.
4. In Hibernate, is there a way to do an insert ( select max() + 1 ) and return the value from a column that was inserted in one statement?

Answer 1

Not sure if this will work for you. But that is how I would do it, because trying to keep concurrency can be complicated.

First I save the time of insert.

INSERT INTO yourTable (`A`, `B`, `insertTime`) VALUES(x, x, NOW() );

Then your query become

SELECT `A`, `B`,
       ROW_NUMER() OVER (PARTITION BY `A`, `B` ORDER BY `insertTime`) as SEQ
FROM yourTable
//optional to get the exact result you show
ORDER BY `insertTime`

EDIT: This may not work if you want delete and keep growing after the last seq.

Answer 2

What about having aggregation table:

A | B | LAST_SEQ
===========
x | x | 4
z | x | 1
x | y | 2

Then you can easily use row-level lock to safely generate records in 1st table.

Answer 3

You want your transactions doing this read-increment-update/insert to be serializable (as in "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE"), that isolation level makes the DB try to find an order in which transactions would be run sequentially and get the same results; if it can't, it doesn't allow some of them to pass. I tried your scenario in Postgres CLI, and it won't allow both inserts (error on commit) or conflicting updates (error on second update finished, transaction aborted); I think Oracle behaves similarly although details may vary. That works even if the criterion for select is different in different transactions: for example first transaction selects by A, second by B, both do changes and those changes would affect any of the previous selects anyhow — you get an error. And then, I guess, retry. Watch out for possible deadlocks associated with SERIALIZABLE isolation which will result in errors (but you will already have retries so that's fine).

By the way, for this sort of update correctness REPEATABLE READ isolation level is enough, but not for inserts.

As for how to have different transaction isolation levels in Hibernate (you probably don't want all transactions to be serializable as it affects performance), I can only think about having two session factories configured from two config files (or manually in the code, or configured from one file and having isolation level updated in the code for one of them). One of them will have "serializable" isolation level and you would work with your table through it exclusively. The property for isolation level is "hibernate.connection.isolation".

In Spring it's enough to annotate a method with @Transactional(isolation=Isolation.SERIALIZABLE) .

Answer 4

Here is a SQL solution for you, you can use Hibernate's native SQL interface for simplicity.

insert into myTable (A, B, LAST_SEQ) 
select 'T', 'Y', 
(
  case 
    when (select max(LAST_SEQ) from myTable where A = 'T' and B = 'Y') is null then 1
    else (select 1 + max(LAST_SEQ) from myTable where A = 'T' and B = 'Y')
  end
);

Hope it helps.