SQLServer Isolation Level Problem?

Question

Since the MSSQLServer driver has trouble when returning explicit cursors, and since the complexitites of one of our procedures requires the use of cursors we have been forced to split a DBMS procedure into two. Ie. we have one method that updates the database and one that retrieves the "return value", ie. a setXXX and then a getXXX method.
The problem is that we sometimes get an empty resultset from the getXXX method. Note that this behaviour is not due to the server code as this error is not present if run directly on the SQLServer (ie, not through the JDBC driver). Now testing to and fro suggests that the error is caused by some sort of parallell behaviour or isolation level trouble in the driver, but what exactly? The thing is, if I insert a pause of a few milliseconds between the two calls it works correctly (of course I cannot place a "random" pause there in production code since the pause will probably vary depending on the underlying hardware). I have tried setting to different TransactionIsolation levels, but get the same result all the time. There is only one linear execution of the code as shown below (no multithreading in the java application).
What I'm wondering is: are there any "switches" to turn in relation to waiting for a a stored procedure to finish execution before the next is called? I would expect this to be implicit, but perhaps the SQLServer runs them in parallell and therefore the second method is called before the first is finished, but then, shouldn't the TransactionIsolationLevel of Serializable hinder this? I would appreciate any help on this one, sample code below, the problem being that wereas the while loop should always print the line it sometimes doesn't since the result is empty (not null, empty). It isn't the parameter to the execute_task either, we get the "missing result" problem with different paramaters that all always work when run directly on the SQLServer (via SQL Query Analyzer).
//Execute the update to the server
CallableStatement execute_task = connection.prepareCall("{call setXXX(?)}");
execute_task.setInt(1, 1);
execute_task.execute();
//Retrieve the task execution results:
CallableStatement show_execute_task = connection.prepareCall("{call getXXX}");
show_execute_task.execute();
ResultSet show_execute_resultset = show_execute_task.getResultSet();
while(show_execute_resultset.next()){
System.out.println("Result received");
}

Answer 1

Since the MSSQLServer driver has trouble when
returning explicit cursors, and since the
complexitites of one of our procedures requires the
use of cursors we have been forced to split a DBMS
procedure into two. Ie. we have one method that
updates the database and one that retrieves the
"return value", ie. a setXXX and then a getXXX method.
The problem is that we sometimes get an empty
resultset from the getXXX method. Note that this
behaviour is not due to the server code as this error
is not present if run directly on the SQLServer (ie,
not through the JDBC driver). Now testing to and fro
suggests that the error is caused by some sort of
parallell behaviour or isolation level trouble in the
driver, but what exactly? The thing is, if I insert a
pause of a few milliseconds between the two calls it
works correctly (of course I cannot place a "random"
pause there in production code since the pause will
probably vary depending on the underlying hardware).
I have tried setting to different
TransactionIsolation levels, but get the same result
all the time. There is only one linear execution of
the code as shown below (no multithreading in the
java application).
What I'm wondering is: are there any "switches" to
turn in relation to waiting for a a stored procedure
to finish execution before the next is called? I would
expect this to be implicit, but perhaps the SQLServer
runs them in parallell and therefore the second methodthis is what i would expect. parallel execution i mean... othewise you might as well use Access...
is called before the first is finished, but then,
shouldn't the TransactionIsolationLevel of
Serializable hinder this? I would appreciate any helpi'm not sure...
t be perfectly honest while i understand the different transaction levels on their face level as described in java.sql.Connection I am not entirely sure WHAT the expected behaviour actually is for each level.
not to get too OT here but for example TRANSACTION_REPEATABLE_READ
if the first transaction reads row 1 from tableA
then a second transaction changes row 1 in table A and commits the changes
the first transaction reads row 1 from table A again... what the heck is supposed to happen. i think it is supposed to read the same values as the first pass even though commited changes have been made but i'm not entirely sure.
on this one, sample code below, the problem being that
wereas the while loop should always print the line it
sometimes doesn't since the result is empty (not null,
empty). It isn't the parameter to the execute_task
either, we get the "missing result" problem with
different paramaters that all always work when run
directly on the SQLServer (via SQL Query Analyzer).
//Execute the update to the server
CallableStatement execute_task =
connection.prepareCall("{call setXXX(?)}");
execute_task.setInt(1, 1);
execute_task.execute();
//Retrieve the task execution results:
CallableStatement show_execute_task =
connection.prepareCall("{call getXXX}");
show_execute_task.execute();
ResultSet show_execute_resultset =
show_execute_task.getResultSet();
while(show_execute_resultset.next()){
System.out.println("Result received");
}i don't really follow your code too well here but here is what i would suggest...
fetch whatever the first procedure returns FIRST.
this should force your app to wait on this before you execute the second one.
does that make sense? it seems simple to me but maybe i'm missing something.