You have to remember that Sql Server does not understand the concept of a
autoCommit(false) state, we have to fake this with "Begin transaction"
blocks. By default the Sql Server database is in the equivalent of
autoCommit(true) state, anything you do  will permanently update the
database.

When we set autoCommit to off the expectation is that no SQL statements will
be committed (that is, the database will not be permanently updated) until
you have explicitly told it to commit by invoking the commit() method. To do
this in Sql Server we issue the following command to the server:

IF @@TRANCOUNT = 0 BEGIN TRAN //if we are currently not in a transaction,
start one.

COMMIT TRAN; IF @@TRANCOUNT = 0 BEGIN TRAN  //Commit the existing
transaction, start a new transaction to fake the fact that we are still in
autoCommit(false) state.

Thanks to the BEGIN TRAN at the end of the commit it would be, but this
should be no consolation. When you receive the "no corresponding begin"
exception you probably have data corruption.

We recently  looked into this error for a large customer. They started
getting this error with our driver and filed it as a bug. When we
investigated it turned out that they were doing something as inoquous as

try{
//create table
}catch{
//ignore failure, this means that table already existed. }

This was sometimes running inside of a transaction, when the table was
already in the database the Sql Exception would roll back the transaction
but they would ignore it. With their previous driver they had no idea that
everything before the above code was being rolled back.

I really should put this in an easier to read format, maybe a blog with
source code you can try.

     conn.setAutoCommit(false);
     conn.commit();
     System.out.println("Commit 1 succeeded");
     conn.commit();
     System.out.println("Commit 2 succeeded");

returns

Commit 1 succeeded
Commit 2 succeeded

and no errors

Right. We can cobble up an exampel with two connections and provoke a
simple deadlock between them. One of them will get it's tx aborted,
and we should then see whether an immediate commit() and/or rollback()
gives a problem. Yes, the driver and DBMS should both still be in
chained/implicit transaction/autoCommit(false) mode.
Joe

I ran the program below, in two windows, the first like:

C:\> java two_cons start

when it said to run the second, I did, like:

and the other:

C:\> java two_cons

This set up a deadlock to happen. When the second program said to press return in the first's window,
I did, and it got the deadlock message. Then I checked the autoCommit() status, which was
still false as far as the driver was concerned at least, and a final commit() on the connection
got an exception:

trying commit...
com.microsoft.sqlserver.jdbc.SQLServerException: Server failed to resume the transaction, desc:
  3300000007.
        at com.microsoft.sqlserver.jdbc.SQLServerException.makeFromDatabaseError(Unknown Source
)
        at com.microsoft.sqlserver.jdbc.IOBuffer.processPackets(Unknown Source)
        at com.microsoft.sqlserver.jdbc.SQLServerConnection.connectionCommand(Unknown Source)
        at com.microsoft.sqlserver.jdbc.SQLServerConnection.sendCommit(Unknown Source)
        at com.microsoft.sqlserver.jdbc.SQLServerConnection.commit(Unknown Source)
        at two_cons.main(two_cons.java:66)

Program:
import java.sql.*;
import java.util.*;

public class two_cons
{
    public static void main(String args[])
        throws Exception
    {
        Connection c = null;
        try
        {
          Properties props = new Properties();
          Driver d = new com.microsoft.sqlserver.jdbc.SQLServerDriver();

          props.put("user",     "joe");
          props.put("password", "joe");
          props.put("DatabaseName", "joe");

          c = d.connect("jdbc:sqlserver://joe:1433", props );

          DatabaseMetaData dd = c.getMetaData();
          System.out.println("Driver version is " + dd.getDriverVersion() );

          Statement s = c.createStatement();

if (args.length != 0)
{
          try {s.executeUpdate("drop table joe");}catch (Exception ignore){}
          try {s.executeUpdate("drop table joe2");}catch (Exception ignore){}
          s.executeUpdate("create table joe(foo int)");
          s.executeUpdate("insert joe values(1)");
          s.executeUpdate("create table joe2(foo int)");
          s.executeUpdate("insert joe2 values(1)");

          c.setAutoCommit(false);
          s.executeUpdate("update joe set foo = 2");

System.out.println("Ok, now run the other and press return");
System.in.read();
          s.executeUpdate("update joe2 set foo = 2");
}
else
{
          c.setAutoCommit(false);
          s.executeUpdate("update joe2 set foo = 2");
System.out.println("Ok, now press return on the other");

          s.executeUpdate("update joe set foo = 2");
}
        }
        catch(Exception exception1)
        {
            exception1.printStackTrace();
        }
        finally
        {
            try {
              System.out.println("c.getAutoCommit() says " + c.getAutoCommit() );
            } catch (Exception ee) {
               ee.printStackTrace();
            }

            try {
              System.out.println("trying commit..." );
              c.commit();
            } catch (Exception ee) {
               ee.printStackTrace();
            }
            if (c != null) try {c.close();} catch (Exception ignore){}
        }
    }
}