[CONJ-296] adding additional tests

src/test/java/org/mariadb/jdbc/CheckDataTest.java

@@ -0,0 +1,150 @@
+package org.mariadb.jdbc;
+
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.sql.*;
+
+import static org.junit.Assert.*;
+
+
+public class CheckDataTest extends BaseTest {
+
+    @Test
+    public void testStatementExecuteAutoincrement() throws SQLException {
+        createTable("CheckDataTest1", "id int not null primary key auto_increment, test varchar(10)");
+        Statement stmt = sharedConnection.createStatement();
+        int insert = stmt.executeUpdate("INSERT INTO CheckDataTest1 (test) VALUES ('test1')", Statement.RETURN_GENERATED_KEYS);
+        Assert.assertEquals(1, insert);
+
+        ResultSet rs = stmt.getGeneratedKeys();
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        assertFalse(rs.next());
+
+        rs = stmt.executeQuery("SELECT * FROM CheckDataTest1");
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        Assert.assertEquals("test1", rs.getString(2));
+        assertFalse(rs.next());
+    }
+
+    @Test
+    public void testStatementBatch() throws SQLException {
+        createTable("CheckDataTest2", "id int not null primary key auto_increment, test varchar(10)");
+        Statement stmt = sharedConnection.createStatement();
+        stmt.addBatch("INSERT INTO CheckDataTest2 (id, test) VALUES (5, 'test1')");
+        stmt.addBatch("INSERT INTO CheckDataTest2 (test) VALUES ('test2')");
+        stmt.addBatch("UPDATE CheckDataTest2 set test = CONCAT(test, 'tt')");
+        stmt.addBatch("INSERT INTO CheckDataTest2 (id, test) VALUES (9, 'test3')");
+        int[] res = stmt.executeBatch();
+
+        Assert.assertEquals(4, res.length);
+        Assert.assertEquals(1, res[0]);
+        Assert.assertEquals(1, res[1]);
+        Assert.assertEquals(2, res[2]);
+        Assert.assertEquals(1, res[3]);
+
+        ResultSet rs = stmt.getGeneratedKeys();
+        assertTrue(rs.next());
+        Assert.assertEquals(5, rs.getInt(1));
+        assertTrue(rs.next());
+        Assert.assertEquals(6, rs.getInt(1));
+        assertTrue(rs.next());
+        Assert.assertEquals(9, rs.getInt(1));
+        assertFalse(rs.next());
+
+        rs = stmt.executeQuery("SELECT * FROM CheckDataTest2");
+        assertTrue(rs.next());
+        Assert.assertEquals(5, rs.getInt(1));
+        Assert.assertEquals("test1tt", rs.getString(2));
+        assertTrue(rs.next());
+        Assert.assertEquals(6, rs.getInt(1));
+        Assert.assertEquals("test2tt", rs.getString(2));
+        assertTrue(rs.next());
+        Assert.assertEquals(9, rs.getInt(1));
+        Assert.assertEquals("test3", rs.getString(2));
+        assertFalse(rs.next());
+    }
+
+    @Test
+    public void testPrepareStatementExecuteAutoincrement() throws SQLException {
+        createTable("CheckDataTest3", "id int not null primary key auto_increment, test varchar(10)");
+        PreparedStatement stmt = sharedConnection.prepareStatement("INSERT INTO CheckDataTest3 (test) VALUES (?)",
+                Statement.RETURN_GENERATED_KEYS);
+        stmt.setString(1, "test1");
+        int insert = stmt.executeUpdate();
+        Assert.assertEquals(1, insert);
+
+        ResultSet rs = stmt.getGeneratedKeys();
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        assertFalse(rs.next());
+
+        //without addBatch -> no execution
+        int[] noBatch = stmt.executeBatch();
+        Assert.assertEquals(0, noBatch.length);
+
+        //with addBatch
+        stmt.addBatch();
+        int[] nbBatch = stmt.executeBatch();
+        Assert.assertEquals(1, nbBatch.length);
+        Assert.assertEquals(1, nbBatch[0]);
+
+        rs = stmt.getGeneratedKeys();
+        assertTrue(rs.next());
+        Assert.assertEquals(2, rs.getInt(1));
+        assertFalse(rs.next());
+
+        rs = stmt.executeQuery("SELECT * FROM CheckDataTest3");
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        Assert.assertEquals("test1", rs.getString(2));
+        assertTrue(rs.next());
+        Assert.assertEquals(2, rs.getInt(1));
+        Assert.assertEquals("test1", rs.getString(2));
+        assertFalse(rs.next());
+    }
+
+    @Test
+    public void testPrepareStatementBatch() throws SQLException {
+        createTable("CheckDataTest4", "id int not null primary key auto_increment, test varchar(10)");
+        PreparedStatement stmt = sharedConnection.prepareStatement("INSERT INTO CheckDataTest4 (test) VALUES (?)",
+                Statement.RETURN_GENERATED_KEYS);
+        stmt.setString(1, "test1");
+        stmt.addBatch();
+        stmt.setString(1, "test2");
+        stmt.addBatch();
+        stmt.addBatch();
+
+        int[] res = stmt.executeBatch();
+
+        Assert.assertEquals(3, res.length);
+        Assert.assertEquals(1, res[0]);
+        Assert.assertEquals(1, res[1]);
+        Assert.assertEquals(1, res[2]);
+
+        ResultSet rs = stmt.getGeneratedKeys();
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        assertTrue(rs.next());
+        Assert.assertEquals(2, rs.getInt(1));
+        assertTrue(rs.next());
+        Assert.assertEquals(3, rs.getInt(1));
+        assertFalse(rs.next());
+
+        rs = stmt.executeQuery("SELECT * FROM CheckDataTest4");
+        assertTrue(rs.next());
+        Assert.assertEquals(1, rs.getInt(1));
+        Assert.assertEquals("test1", rs.getString(2));
+        assertTrue(rs.next());
+        Assert.assertEquals(2, rs.getInt(1));
+        Assert.assertEquals("test2", rs.getString(2));
+        assertTrue(rs.next());
+        Assert.assertEquals(3, rs.getInt(1));
+        Assert.assertEquals("test2", rs.getString(2));
+        assertFalse(rs.next());
+    }
+}

src/test/java/org/mariadb/jdbc/MultiTest.java

@@ -48,7 +48,6 @@ public static void initClass() throws SQLException {
             st.execute("insert into MultiTestt2 values(1,'a'),(2,'a')");
             st.execute("insert into MultiTestt5 values(1,'a'),(2,'a'),(2,'b')");
         }
-        createTable("MultiTestt9", "id int not null primary key");
 
     }
 
@@ -833,42 +832,102 @@ public void valuesWithoutSpacewithoutRewrite() throws Exception {
 
     @Test
     public void continueOnBatchError() throws SQLException {
-        createTable("MultiTestt9", "id int not null primary key");
-        continueOnBatchError(true, 9, 9, true, false);
-        continueOnBatchError(false, 9, 9, true, false);
-        continueOnBatchError(true, 9, 9, false, false);
-        continueOnBatchError(false, 5, 9, false, false);
-        continueOnBatchError(true, 0, 9, false, true);
-        continueOnBatchError(false, 0, 9, false, true);
+        for (int i = 0; i < 16; i++) {
+            continueOnBatchError(i % 16 < 8, i % 8 < 4, i % 4 < 2, i % 2 == 0);
+        }
     }
 
-    private void continueOnBatchError(boolean continueBatch, int waitedResult, int waitedResultComMulti, boolean server,
-                                      boolean rewrite) throws SQLException {
+    private void continueOnBatchError(boolean continueBatch, boolean serverPrepare,
+                                      boolean rewrite, boolean batchMulti) throws SQLException {
+        System.out.println("continueBatch:" + continueBatch
+                + " serverPrepare:" + serverPrepare
+                + " rewrite:" + rewrite
+                + " batchMulti:" + batchMulti);
+        createTable("MultiTestt9", "id int not null primary key, test varchar(10)");
         try (Connection connection = setBlankConnection(
-                "&useServerPrepStmts=" + server
-                        + "&useBatchMultiSend=" + server
+                "&useServerPrepStmts=" + serverPrepare
+                        + "&useBatchMultiSend=" + batchMulti
                         + "&continueBatchOnError=" + continueBatch
                         + "&rewriteBatchedStatements=" + rewrite)) {
-            connection.createStatement().execute("TRUNCATE TABLE MultiTestt9");
-            PreparedStatement pstmt = connection.prepareStatement("INSERT INTO MultiTestt9 (id) VALUES (?)");
+            PreparedStatement pstmt = connection.prepareStatement("INSERT INTO MultiTestt9 (id, test) VALUES (?, ?)");
             for (int i = 0; i < 10; i++) {
                 pstmt.setInt(1, (i == 5) ? 0 : i);
+                pstmt.setString(2, String.valueOf(i));
                 pstmt.addBatch();
             }
             try {
                 pstmt.executeBatch();
                 fail("Must have thrown SQLException");
-            } catch (SQLException e) {
-                ResultSet rs = connection.createStatement().executeQuery("SELECT COUNT(*) FROM MultiTestt9");
-                if (rs.next()) {
-                    int waited = minVersion(10, 2) ? ((!rewrite && server) ? waitedResultComMulti : waitedResult) : waitedResult;
-                    assertEquals(waited, rs.getInt(1));
+            } catch (BatchUpdateException e) {
+
+
+                int[] updateCount = e.getUpdateCounts();
+                Assert.assertEquals(10, updateCount.length);
+                if (rewrite) {
+                    //rewrite exception is all or nothing
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[0]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[1]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[2]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[3]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[4]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[5]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[6]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[7]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[8]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[9]);
                 } else {
-                    fail("Must have one result");
+                    Assert.assertEquals(1, updateCount[0]);
+                    Assert.assertEquals(1, updateCount[1]);
+                    Assert.assertEquals(1, updateCount[2]);
+                    Assert.assertEquals(1, updateCount[3]);
+                    Assert.assertEquals(1, updateCount[4]);
+                    Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[5]);
+                    if (continueBatch) {
+                        Assert.assertEquals(1, updateCount[6]);
+                        Assert.assertEquals(1, updateCount[7]);
+                        Assert.assertEquals(1, updateCount[8]);
+                        Assert.assertEquals(1, updateCount[9]);
+                    } else {
+                        if (batchMulti) {
+                            //send in batch, so continue will be handle, but send packet is executed.
+                            Assert.assertEquals(1, updateCount[6]);
+                            Assert.assertEquals(1, updateCount[7]);
+                            Assert.assertEquals(1, updateCount[8]);
+                            Assert.assertEquals(1, updateCount[9]);
+                        } else {
+                            Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[6]);
+                            Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[7]);
+                            Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[8]);
+                            Assert.assertEquals(Statement.EXECUTE_FAILED, updateCount[9]);
+                        }
+                    }
+                }
+
+                ResultSet rs = connection.createStatement().executeQuery("SELECT * FROM MultiTestt9");
+                //check result
+                if (!rewrite) {
+                    checkNextData(0, rs);
+                    checkNextData(1, rs);
+                    checkNextData(2, rs);
+                    checkNextData(3, rs);
+                    checkNextData(4, rs);
+
+                    if (continueBatch || batchMulti) {
+                        checkNextData(6, rs);
+                        checkNextData(7, rs);
+                        checkNextData(8, rs);
+                        checkNextData(9, rs);
+                    }
                 }
+                Assert.assertFalse(rs.next());
             }
         }
     }
+    private void checkNextData(int value, ResultSet rs) throws SQLException {
+        Assert.assertTrue(rs.next());
+        Assert.assertEquals(value, rs.getInt(1));
+        Assert.assertEquals(String.valueOf(value), rs.getString(2));
+    }
 
     @Test
     public void testCloseStatementWithoutQuery() throws SQLException {

src/test/java/org/mariadb/jdbc/PreparedStatementTest.java

@@ -54,9 +54,12 @@ public void testClosingError() throws Exception {
     public void insertSelect() throws Exception {
         try {
             PreparedStatement stmt = sharedConnection.prepareStatement(
-                    "insert into test_insert_select ( field1) (select  TMP.field1 from (select ? `field1` from dual) TMP)");
+                    "insert into test_insert_select ( field1) (select  TMP.field1 from (select ? `field1` from dual) TMP)", Statement.RETURN_GENERATED_KEYS);
             stmt.setString(1, "test");
-            stmt.executeUpdate();
+            stmt.execute();
+            ResultSet rs = sharedConnection.createStatement().executeQuery("select count(*) from test_insert_select");
+            rs.next();
+            System.out.println(rs.getInt(1));
         } catch (SQLException e) {
             assertTrue(e.getMessage().contains("If column exists but type cannot be identified (example 'select ? `field1` from dual'). "
                     + "Use CAST function to solve this problem (example 'select CAST(? as integer) `field1` from dual')"));