Support a Statement.getMoreResults feature

Add support for two methods getMoreResults and its synonym
getMoreResults(CLOSE_CURRENT_RESULT). Tarantool does not support
multiple results per one query. It leads both KEEP_CURRENT_RESULT and
CLOSE_ALL_RESULTS modes are not supported by the driver.

Closes: #182

Author: nicktorwald

src/main/java/org/tarantool/jdbc/SQLStatement.java

@@ -218,13 +218,21 @@ public int getUpdateCount() throws SQLException {
 
     @Override
     public boolean getMoreResults() throws SQLException {
-        checkNotClosed();
-        return false;
+        return getMoreResults(Statement.CLOSE_CURRENT_RESULT);
     }
 
     @Override
     public boolean getMoreResults(int current) throws SQLException {
         checkNotClosed();
+        JdbcConstants.checkCurrentResultConstant(current);
+        if (resultSet != null &&
+            (current == KEEP_CURRENT_RESULT || current == CLOSE_ALL_RESULTS)) {
+            throw new SQLFeatureNotSupportedException();
+        }
+
+        // the driver doesn't support multiple results
+        // close current result and return no-more-results flag
+        discardLastResults();
         return false;
     }
 

src/main/java/org/tarantool/util/JdbcConstants.java

@@ -21,4 +21,12 @@ public static void checkHoldabilityConstant(int holdability) throws SQLException
         }
     }
 
+    public static void checkCurrentResultConstant(int currentResult) throws SQLException {
+        if (currentResult != Statement.CLOSE_CURRENT_RESULT &&
+            currentResult != Statement.CLOSE_ALL_RESULTS &&
+            currentResult != Statement.KEEP_CURRENT_RESULT) {
+            throw new SQLNonTransientException("", SQLStates.INVALID_PARAMETER_VALUE.getSqlState());
+        }
+    }
+
 }

src/test/java/org/tarantool/jdbc/JdbcPreparedStatementIT.java

@@ -19,6 +19,7 @@
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
 import java.sql.Statement;
 
 public class JdbcPreparedStatementIT extends JdbcTypesIT {
@@ -228,6 +229,84 @@ void testStatementConnection() throws SQLException {
         assertEquals(conn, statement.getConnection());
     }
 
+    @Test
+    public void testMoreResultsWithResultSet() throws SQLException {
+        prep = conn.prepareStatement("SELECT val FROM test WHERE id = ?");
+        prep.setInt(1, 1);
+
+        prep.execute();
+        ResultSet resultSet = prep.getResultSet();
+
+        assertFalse(resultSet.isClosed());
+        assertFalse(prep.getMoreResults());
+        assertEquals(-1, prep.getUpdateCount());
+        assertTrue(resultSet.isClosed());
+    }
+
+    @Test
+    public void testMoreResultsWithUpdateCount() throws SQLException {
+        prep = conn.prepareStatement("INSERT INTO test VALUES (?, ?)");
+        prep.setInt(1, 9);
+        prep.setString(2, "nine");
+
+        prep.execute();
+        int updateCount = prep.getUpdateCount();
+
+        assertEquals(1, prep.getUpdateCount());
+        assertFalse(prep.getMoreResults());
+        assertEquals(-1, prep.getUpdateCount());
+    }
+
+    @Test
+    public void testMoreResultsButCloseCurrent() throws SQLException {
+        prep = conn.prepareStatement("SELECT val FROM test WHERE id = ?");
+        prep.setInt(1, 2);
+
+        prep.execute();
+        ResultSet resultSet = prep.getResultSet();
+
+        assertFalse(resultSet.isClosed());
+        assertFalse(prep.getMoreResults(Statement.CLOSE_CURRENT_RESULT));
+        assertEquals(-1, prep.getUpdateCount());
+        assertTrue(resultSet.isClosed());
+    }
+
+    @Test
+    public void testMoreResultsButCloseAll() throws SQLException {
+        prep = conn.prepareStatement("SELECT val FROM test WHERE id = ?");
+        prep.setInt(1, 2);
+        prep.execute();
+
+        assertThrows(SQLFeatureNotSupportedException.class, () -> prep.getMoreResults(Statement.CLOSE_ALL_RESULTS));
+
+        prep = conn.prepareStatement("INSERT INTO test VALUES (?, ?)");
+        prep.setInt(1, 21);
+        prep.setString(2, "twenty one");
+        prep.execute();
+
+        assertEquals(1, prep.getUpdateCount());
+        assertFalse(prep.getMoreResults(Statement.CLOSE_ALL_RESULTS));
+        assertEquals(-1, prep.getUpdateCount());
+    }
+
+    @Test
+    public void testMoreResultsButKeepCurrent() throws SQLException {
+        prep = conn.prepareStatement("SELECT val FROM test WHERE id = ?");
+        prep.setInt(1, 3);
+        prep.execute();
+
+        assertThrows(SQLFeatureNotSupportedException.class, () -> prep.getMoreResults(Statement.KEEP_CURRENT_RESULT));
+
+        prep = conn.prepareStatement("INSERT INTO test VALUES (?, ?)");
+        prep.setInt(1, 22);
+        prep.setString(2, "twenty two");
+        prep.execute();
+
+        assertEquals(1, prep.getUpdateCount());
+        assertFalse(prep.getMoreResults(Statement.KEEP_CURRENT_RESULT));
+        assertEquals(-1, prep.getUpdateCount());
+    }
+
     @Test
     public void testSetByte() throws SQLException {
         makeHelper(Byte.class)

src/test/java/org/tarantool/jdbc/JdbcStatementIT.java

@@ -6,6 +6,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
+import static org.tarantool.jdbc.SqlAssertions.assertSqlExceptionHasStatus;
 
 import org.tarantool.util.SQLStates;
 
@@ -16,6 +17,7 @@
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
 import java.sql.Statement;
 
 public class JdbcStatementIT extends AbstractJdbcIT {
@@ -49,7 +51,7 @@ public void testExecuteWrongQuery() throws SQLException {
         String wrongResultQuery = "INSERT INTO test(id, val) VALUES (40, 'forty')";
 
         SQLException exception = assertThrows(SQLException.class, () -> stmt.executeQuery(wrongResultQuery));
-        SqlAssertions.assertSqlExceptionHasStatus(exception, SQLStates.NO_DATA);
+        assertSqlExceptionHasStatus(exception, SQLStates.NO_DATA);
     }
 
     @Test
@@ -64,7 +66,7 @@ public void testExecuteWrongUpdate() throws SQLException {
         String wrongUpdateQuery = "SELECT val FROM test";
 
         SQLException exception = assertThrows(SQLException.class, () -> stmt.executeUpdate(wrongUpdateQuery));
-        SqlAssertions.assertSqlExceptionHasStatus(exception, SQLStates.TOO_MANY_RESULTS);
+        assertSqlExceptionHasStatus(exception, SQLStates.TOO_MANY_RESULTS);
     }
 
     @Test
@@ -348,4 +350,59 @@ void testCloseOnCompletionMixedQueries() throws SQLException {
         assertTrue(stmt.isClosed());
     }
 
+    @Test
+    public void testMoreResultsWithResultSet() throws SQLException {
+        stmt.execute("SELECT val FROM test WHERE id = 1");
+
+        ResultSet rs = stmt.getResultSet();
+
+        assertFalse(rs.isClosed());
+        assertFalse(stmt.getMoreResults());
+        assertEquals(-1, stmt.getUpdateCount());
+        assertTrue(rs.isClosed());
+    }
+
+    @Test
+    public void testMoreResultsWithUpdateCount() throws SQLException {
+        stmt.execute("INSERT INTO test(id, val) VALUES (9, 'nine')");
+
+        assertEquals(1, stmt.getUpdateCount());
+        assertFalse(stmt.getMoreResults());
+        assertEquals(-1, stmt.getUpdateCount());
+    }
+
+    @Test
+    public void testMoreResultsButCloseCurrent() throws SQLException {
+        stmt.execute("SELECT val FROM test WHERE id = 1");
+
+        ResultSet resultSet = stmt.getResultSet();
+
+        assertFalse(resultSet.isClosed());
+        assertFalse(stmt.getMoreResults(Statement.CLOSE_CURRENT_RESULT));
+        assertEquals(-1, stmt.getUpdateCount());
+        assertTrue(resultSet.isClosed());
+    }
+
+    @Test
+    public void testMoreResultsButCloseAll() throws SQLException {
+        stmt.execute("SELECT val FROM test WHERE id = 3");
+        assertThrows(SQLFeatureNotSupportedException.class, () -> stmt.getMoreResults(Statement.CLOSE_ALL_RESULTS));
+
+        stmt.execute("INSERT INTO test(id, val) VALUES (21, 'twenty one')");
+        assertEquals(1, stmt.getUpdateCount());
+        assertFalse(stmt.getMoreResults(Statement.CLOSE_ALL_RESULTS));
+        assertEquals(-1, stmt.getUpdateCount());
+    }
+
+    @Test
+    public void testMoreResultsButKeepCurrent() throws SQLException {
+        stmt.execute("SELECT val FROM test WHERE id = 2");
+        assertThrows(SQLFeatureNotSupportedException.class, () -> stmt.getMoreResults(Statement.KEEP_CURRENT_RESULT));
+
+        stmt.execute("INSERT INTO test(id, val) VALUES (22, 'twenty two')");
+        assertEquals(1, stmt.getUpdateCount());
+        assertFalse(stmt.getMoreResults(Statement.KEEP_CURRENT_RESULT));
+        assertEquals(-1, stmt.getUpdateCount());
+    }
+
 }