expand synchronized scope in Command back to what it was

af159ebe · Andrei Tokar · 86e99ef0 · af159ebe
--- a/h2/src/main/org/h2/command/Command.java
+++ b/h2/src/main/org/h2/command/Command.java
@@ -194,50 +194,49 @@ public abstract class Command implements CommandInterface {
                // wait
            }
        }
-        session.startStatementWithinTransaction();
+        //noinspection SynchronizationOnLocalVariableOrMethodParameter
-        session.setCurrentCommand(this, false);
+        synchronized (sync) {
-        try {
+            session.startStatementWithinTransaction();
-            while (true) {
+            session.setCurrentCommand(this, false);
-                database.checkPowerOff();
+            try {
-                try {
+                while (true) {
-                    ResultInterface result;
+                    database.checkPowerOff();
-                    //noinspection SynchronizationOnLocalVariableOrMethodParameter
+                    try {
-                    synchronized (sync) {
+                        ResultInterface result = query(maxrows);
-                        result = query(maxrows);
+                        callStop = !result.isLazy();
+                        return result;
+                    } catch (DbException e) {
+                        start = filterConcurrentUpdate(e, start);
+                    } catch (OutOfMemoryError e) {
+                        callStop = false;
+                        // there is a serious problem:
+                        // the transaction may be applied partially
+                        // in this case we need to panic:
+                        // close the database
+                        database.shutdownImmediately();
+                        throw DbException.convert(e);
+                    } catch (Throwable e) {
+                        throw DbException.convert(e);
                    }
-                    callStop = !result.isLazy();
+                }
-                    return result;
+            } catch (DbException e) {
-                } catch (DbException e) {
+                e = e.addSQL(sql);
-                    start = filterConcurrentUpdate(e, start);
+                SQLException s = e.getSQLException();
-                } catch (OutOfMemoryError e) {
+                database.exceptionThrown(s, sql);
+                if (s.getErrorCode() == ErrorCode.OUT_OF_MEMORY) {
                    callStop = false;
-                    // there is a serious problem:
-                    // the transaction may be applied partially
-                    // in this case we need to panic:
-                    // close the database
                    database.shutdownImmediately();
-                    throw DbException.convert(e);
+                    throw e;
-                } catch (Throwable e) {
-                    throw DbException.convert(e);
                }
-            }
+                database.checkPowerOff();
-        } catch (DbException e) {
-            e = e.addSQL(sql);
-            SQLException s = e.getSQLException();
-            database.exceptionThrown(s, sql);
-            if (s.getErrorCode() == ErrorCode.OUT_OF_MEMORY) {
-                callStop = false;
-                database.shutdownImmediately();
                throw e;
-            }
+            } finally {
-            database.checkPowerOff();
+                if (callStop) {
-            throw e;
+                    stop();
-        } finally {
+                }
-            if (callStop) {
+                if (writing) {
-                stop();
+                    database.afterWriting();
-            }
+                }
-            if (writing) {
-                database.afterWriting();
            }
        }
    }
@@ -255,57 +254,56 @@ public abstract class Command implements CommandInterface {
                // wait
            }
        }
-        Session.Savepoint rollback = session.setSavepoint();
+        //noinspection SynchronizationOnLocalVariableOrMethodParameter
-        session.startStatementWithinTransaction();
+        synchronized (sync) {
-        session.setCurrentCommand(this, generatedKeysRequest);
+            Session.Savepoint rollback = session.setSavepoint();
-        try {
+            session.startStatementWithinTransaction();
-            while (true) {
+            session.setCurrentCommand(this, generatedKeysRequest);
-                database.checkPowerOff();
+            try {
-                try {
+                while (true) {
-                    int updateCount;
+                    database.checkPowerOff();
-                    //noinspection SynchronizationOnLocalVariableOrMethodParameter
+                    try {
-                    synchronized (sync) {
+                        int updateCount = update();
-                        updateCount = update();
+                        if (!Boolean.FALSE.equals(generatedKeysRequest)) {
-                    }
+                            return new ResultWithGeneratedKeys.WithKeys(updateCount,
-                    if (!Boolean.FALSE.equals(generatedKeysRequest)) {
+                                    session.getGeneratedKeys().getKeys(session));
-                        return new ResultWithGeneratedKeys.WithKeys(updateCount,
+                        }
-                                session.getGeneratedKeys().getKeys(session));
+                        return ResultWithGeneratedKeys.of(updateCount);
+                    } catch (DbException e) {
+                        start = filterConcurrentUpdate(e, start);
+                    } catch (OutOfMemoryError e) {
+                        callStop = false;
+                        database.shutdownImmediately();
+                        throw DbException.convert(e);
+                    } catch (Throwable e) {
+                        throw DbException.convert(e);
                    }
-                    return ResultWithGeneratedKeys.of(updateCount);
+                }
-                } catch (DbException e) {
+            } catch (DbException e) {
-                    start = filterConcurrentUpdate(e, start);
+                e = e.addSQL(sql);
-                } catch (OutOfMemoryError e) {
+                SQLException s = e.getSQLException();
+                database.exceptionThrown(s, sql);
+                if (s.getErrorCode() == ErrorCode.OUT_OF_MEMORY) {
                    callStop = false;
                    database.shutdownImmediately();
-                    throw DbException.convert(e);
+                    throw e;
-                } catch (Throwable e) {
-                    throw DbException.convert(e);
                }
-            }
+                database.checkPowerOff();
-        } catch (DbException e) {
+                if (s.getErrorCode() == ErrorCode.DEADLOCK_1) {
-            e = e.addSQL(sql);
+                    session.rollback();
-            SQLException s = e.getSQLException();
+                } else {
-            database.exceptionThrown(s, sql);
+                    session.rollbackTo(rollback, false);
-            if (s.getErrorCode() == ErrorCode.OUT_OF_MEMORY) {
-                callStop = false;
-                database.shutdownImmediately();
-                throw e;
-            }
-            database.checkPowerOff();
-            if (s.getErrorCode() == ErrorCode.DEADLOCK_1) {
-                session.rollback();
-            } else {
-                session.rollbackTo(rollback, false);
-            }
-            throw e;
-        } finally {
-            try {
-                if (callStop) {
-                    stop();
                }
+                throw e;
            } finally {
-                if (writing) {
+                try {
-                    database.afterWriting();
+                    if (callStop) {
+                        stop();
+                    }
+                } finally {
+                    if (writing) {
+                        database.afterWriting();
+                    }
                }
            }
        }