fix for MySql INSERTS with autoincrement

src/main/java/org/polyjdbc/core/key/AutoIncremented.java

@@ -25,12 +25,9 @@
  * @author Adam Dubiel
  */
 public class AutoIncremented implements KeyGenerator {
-
-    private static final long DEFAULT_VALUE = 0;
-
     @Override
     public long generateKey(String sequenceName, Transaction transaction) throws SQLException {
-        return DEFAULT_VALUE;
+        throw new RuntimeException("not implemented");
     }
 
     @Override

src/main/java/org/polyjdbc/core/query/InsertQuery.java

@@ -15,9 +15,13 @@
  */
 package org.polyjdbc.core.query;
 
+import org.polyjdbc.core.key.KeyGenerator;
+import org.polyjdbc.core.transaction.Transaction;
 import org.polyjdbc.core.type.ColumnTypeMapper;
 import org.polyjdbc.core.util.StringBuilderUtil;
 
+import java.sql.SQLException;
+
 /**
  * Builds insert query, use {@link QueryFactory#insert() } to create new instance.
  *
@@ -30,7 +34,7 @@
  *
  * @author Adam Dubiel
  */
-public class InsertQuery {
+public abstract class InsertQuery {
 
     private static final int VALUES_LENGTH = 50;
 
@@ -40,12 +44,6 @@ public class InsertQuery {
 
     private final StringBuilder values = new StringBuilder(VALUES_LENGTH);
 
-    private String sequenceField;
-
-    private String sequenceName;
-
-    private boolean sequenceValueSet;
-
     InsertQuery(ColumnTypeMapper typeMapper) {
         this.query = new Query(typeMapper);
     }
@@ -73,23 +71,11 @@ public InsertQuery into(String tableName) {
      * Insert next sequence value into column of given name. Only one sequenced
      * column per table is supported so far.
      */
-    public InsertQuery sequence(String sequenceField, String sequenceName) {
-        this.sequenceField = sequenceField;
-        this.sequenceName = sequenceName;
-        return value(sequenceField, sequenceField);
-    }
+    public abstract InsertQuery sequence(String sequenceField, String sequenceName);
 
-    boolean sequenceSet() {
-        return sequenceName != null;
-    }
-
-    String getSequenceName() {
-        return sequenceName;
-    }
+    abstract boolean isIdInserted();
 
-    String getSequenceField() {
-        return sequenceField;
-    }
+    abstract long generateSequenceValue(KeyGenerator keyGenerator, Transaction transaction) throws SQLException;
 
     /**
      * Insert value into column of given name. Object is automatically translated
@@ -100,24 +86,11 @@ String getSequenceField() {
     public InsertQuery value(String fieldName, Object value) {
         valueNames.append(fieldName).append(", ");
         values.append(":").append(fieldName).append(", ");
-        query.setArgument(fieldName, value);
+        setArgument(fieldName, value);
         return this;
     }
 
-    /**
-     * Manually set sequenced field value.
-     */
-    public InsertQuery sequenceValue(long value) {
-        query.setArgument(sequenceField, value);
-        sequenceValueSet = true;
-        return this;
-    }
-
-    /**
-     * Returns true if sequenced field value was set manually and there is no
-     * need to use sequence generator.
-     */
-    public boolean isSequenceValueSet() {
-        return sequenceValueSet;
+    void setArgument(String fieldName, Object value) {
+        query.setArgument(fieldName, value);
     }
 }

src/main/java/org/polyjdbc/core/query/InsertWithAutoincrement.java

@@ -0,0 +1,32 @@
+package org.polyjdbc.core.query;
+
+import org.polyjdbc.core.key.KeyGenerator;
+import org.polyjdbc.core.transaction.Transaction;
+import org.polyjdbc.core.type.ColumnTypeMapper;
+
+import java.sql.SQLException;
+
+public class InsertWithAutoincrement extends InsertQuery {
+
+    public InsertWithAutoincrement(ColumnTypeMapper typeMapper) {
+        super(typeMapper);
+    }
+    private boolean isIdInserted = false;
+
+    @Override
+    public InsertQuery sequence(String sequenceField, String sequenceName) {
+        //pretend that DB has sequences as we don't want to complicate clients' code
+        isIdInserted = true;
+        return this;
+    }
+
+    @Override
+    boolean isIdInserted() {
+        return isIdInserted;
+    }
+
+    @Override
+    long generateSequenceValue(KeyGenerator keyGenerator, Transaction transaction) throws SQLException {
+        throw new RuntimeException("not implemented");
+    }
+}

src/main/java/org/polyjdbc/core/query/InsertWithSequence.java

@@ -0,0 +1,35 @@
+package org.polyjdbc.core.query;
+
+import org.polyjdbc.core.key.KeyGenerator;
+import org.polyjdbc.core.transaction.Transaction;
+import org.polyjdbc.core.type.ColumnTypeMapper;
+
+import java.sql.SQLException;
+
+class InsertWithSequence extends InsertQuery {
+    private String sequenceField;
+    private String sequenceName;
+
+    InsertWithSequence(ColumnTypeMapper typeMapper) {
+        super(typeMapper);
+    }
+
+    @Override
+    public InsertQuery sequence(String sequenceField, String sequenceName) {
+        this.sequenceField = sequenceField;
+        this.sequenceName = sequenceName;
+        return value(sequenceField, sequenceField);
+    }
+
+    @Override
+    boolean isIdInserted() {
+        return sequenceName != null;
+    }
+
+    @Override
+    long generateSequenceValue(KeyGenerator keyGenerator, Transaction transaction) throws SQLException {
+        long key = keyGenerator.generateKey(sequenceName, transaction);
+        setArgument(sequenceField, key);
+        return key;
+    }
+}

src/main/java/org/polyjdbc/core/query/QueryFactory.java

@@ -33,7 +33,10 @@ public QueryFactory(Dialect dialect, ColumnTypeMapper typeMapper) {
      * Create insert query.
      */
     public InsertQuery insert() {
-        return new InsertQuery(typeMapper);
+        if (dialect.supportsSequences()) {
+            return new InsertWithSequence(typeMapper);
+        }
+        return new InsertWithAutoincrement(typeMapper);
     }
 
     /**

src/main/java/org/polyjdbc/core/query/TransactionalQueryRunner.java

@@ -102,19 +102,22 @@ public boolean queryExistence(SelectQuery query) {
     @Override
     public long insert(InsertQuery insertQuery) {
         try {
-            boolean useSequence = insertQuery.sequenceSet();
+            long key = 0;
 
-            if (useSequence) {
-                long key = keyGenerator.generateKey(insertQuery.getSequenceName(), transaction);
-                insertQuery.sequenceValue(key);
+            if (insertQuery.isIdInserted() && insertQuery instanceof InsertWithSequence) {
+                key = insertQuery.generateSequenceValue(keyGenerator, transaction);
             }
 
             Query rawQuery = insertQuery.build();
             try(PreparedStatement statement = rawQuery.createStatementWithValues(transaction)) {
                 transaction.executeUpdate(statement);
             }
 
-            return useSequence ? keyGenerator.getKeyFromLastInsert(transaction) : 0;
+            if (insertQuery.isIdInserted() && insertQuery instanceof InsertWithAutoincrement) {
+                key = keyGenerator.getKeyFromLastInsert(transaction);
+            }
+
+            return key;
         } catch (SQLException exception) {
             transaction.rollback();
             Query rawQuery = insertQuery.build();

src/test/groovy/org/polyjdbc/core/key/MySqlAutoincrementInsertTest.groovy

@@ -0,0 +1,38 @@
+package org.polyjdbc.core.key
+
+import org.polyjdbc.core.PolyJDBC
+import spock.lang.Shared
+import spock.lang.Specification
+
+import static org.polyjdbc.core.key.PolyFactory.insertAndSelectOneRecord
+
+class MySqlAutoincrementInsertTest extends Specification {
+    @Shared PolyJDBC polyJDBC
+
+    def setupSpec() {
+        this.polyJDBC = createPoly()
+
+        if (!polyJDBC.schemaInspector().relationExists('test')) {
+            PolyFactory.createSchema(polyJDBC)
+        }
+    }
+
+    private PolyJDBC createPoly() {
+        PolyFactory.newPolyForMySql()
+    }
+
+    def "should insert records with autoincremented id"(){
+        given:
+        def recordsToInsert = 100
+        def inserted = 0
+
+        when:
+        recordsToInsert.times {
+            def selected = insertAndSelectOneRecord(it, this.polyJDBC)
+            if (selected == it) inserted ++
+        }
+
+        then:
+        inserted == recordsToInsert
+    }
+}

src/test/groovy/org/polyjdbc/core/key/PolyFactory.groovy

@@ -0,0 +1,62 @@
+package org.polyjdbc.core.key
+
+import org.polyjdbc.core.PolyJDBC
+import org.polyjdbc.core.PolyJDBCBuilder
+import org.polyjdbc.core.dialect.DialectRegistry
+import org.polyjdbc.core.infrastructure.DataSourceFactory
+import org.polyjdbc.core.query.mapper.ObjectMapper
+import org.polyjdbc.core.schema.model.Schema
+
+import java.sql.ResultSet
+import java.sql.SQLException
+
+class PolyFactory {
+
+    static PolyJDBC newPolyForPostgres() {
+        def dialect = DialectRegistry.POSTGRES.dialect
+        def dataSource = DataSourceFactory.create(dialect, 'jdbc:postgresql://localhost:5432/polly', 'javers', 'javers')
+
+        PolyJDBCBuilder.polyJDBC(dialect, null).connectingToDataSource(dataSource).build()
+    }
+
+    static PolyJDBC newPolyForMySql() {
+        def dialect = DialectRegistry.MYSQL.dialect
+        def dataSource = DataSourceFactory.create(dialect, 'jdbc:mysql://localhost/polly', 'javers', '')
+
+        PolyJDBCBuilder.polyJDBC(dialect, null).connectingToDataSource(dataSource).build()
+    }
+
+    static void createSchema(PolyJDBC polyJDBC) {
+        def schema = new Schema(polyJDBC.dialect(), null);
+
+        schema.addRelation("test")
+                .withAttribute().longAttr("id").withAdditionalModifiers("AUTO_INCREMENT").and()
+                .withAttribute().integer("some_count").and()
+                .constrainedBy().primaryKey("pk_test").using("id").and()
+                .build()
+        schema.addSequence("seq_test").build()
+
+        def manager = polyJDBC.schemaManager()
+        manager.create(schema)
+        polyJDBC.close(manager)
+    }
+
+    static int insertAndSelectOneRecord(long value, PolyJDBC polly) {
+        def insertQuery = polly.query().insert().into("test").sequence("id", "seq_test")
+                .value("some_count", value)
+        def queryRunner = polly.queryRunner()
+
+        long insertedId = queryRunner.insert(insertQuery)
+
+        def selectQuery = polly.query().select("some_count").from("test").where("id = $insertedId");
+        def selected = queryRunner.queryUnique(selectQuery, new ObjectMapper() {
+            Object createObject(ResultSet resultSet) throws SQLException {
+                resultSet.getLong("some_count")
+            }
+        })
+        println "inserted $value at $insertedId, selected: $selected, thread: " + Thread.currentThread().name
+        queryRunner.commitAndClose()
+
+        selected
+    }
+}