Insertion de plusieurs lignes à l'aide de JdbcTemplate

Comment puis-je exécuter la requête SQL suivante dans une de manière évolutive à l'aide de JdbcTemplate en cours d'exécution sur mySQL. Dans ce cas, évolutive signifie:

  1. Une seule instruction SQL est exécutée sur le serveur
  2. cela fonctionne pour n'importe quel nombre de lignes.

Voici l'énoncé:

INSERT INTO myTable (foo, bar) VALUES ("asdf", "asdf"), ("qwer", "qwer")

Supposer que j'ai une liste de POJO avec foo et bar champs. Je me rends compte que je pourrais vous suffit d'itérer sur la liste et de l'exécuter:

jdbcTemplate.update("INSERT INTO myTable(foo, bar) VALUES (?, ?)", paramMap)

mais cela ne veut pas n'est pas accomplir le premier critère.

Je crois que je pourrais également exécuter:

jdbcTemplate.batchUpdate("INSERT INTO myTable(foo, bar) VALUES (?, ?)", paramMapArray)

mais de ce que je peux dire, qui va juste compiler le SQL une fois et d'exécuter plusieurs fois, à défaut, le premier critère de nouveau.

La dernière possibilité, qui semble passer deux critères, serait tout simplement de construire le SQL moi-même avec un StringBuffermais je voudrais éviter cela.

source d'informationauteur scompt.com

  1. 4

    Multirow inserts (à l'aide de la "ligne de la valeur des constructeurs") sont en fait une partie de la norme SQL-92. Voir
    http://en.wikipedia.org/wiki/Insert_(SQL)#Multirow_inserts.

    Certaines bases de données ne prennent pas en charge cette syntaxe, mais beaucoup le font. Dans mon expérience Derby/Cloudscape, DB2, Postgresql et la plus récente Hypersonic 2.*+ les rejets ne l'appui de cette.

    Votre préoccupation au sujet de l'obtention de ce travail comme un PreparedStatement est compréhensible, mais j'ai vu des cas similaires où le Printemps JDBC n'gérer automatiquement une Collection d'éléments pour certaines requêtes (comme dans (?)), mais je ne peux pas se porter garant pour ce cas.

    J'ai trouvé certains peut-être des informations utiles à l' (ne peut pas ajouter un deuxième lien de ce post)
    qui pourrait être de quelque secours.

    Je peux vous dire que c'est probablement pas possible pour votre deuxième exigence (fonctionne pour n'importe quel nombre d'arguments) à satisfaire dans le plus strict sens: chaque base de données que j'ai utilisées ne doit imposer la longueur des requêtes limitations qui entrerait en jeu.

  2. 28

    Vous pouvez utiliser BatchPreparedStatementSetter comme ci-dessous.

    public void insertListOfPojos(final List<MyPojo> myPojoList) {

    String sql = "INSERT INTO "
        + "MY_TABLE "
        + "(FIELD_1,FIELD_2,FIELD_3) "
        + "VALUES " + "(?,?,?)";

    getJdbcTemplate().batchUpdate(sql, new BatchPreparedStatementSetter() {

        @Override
        public void setValues(PreparedStatement ps, int i)
            throws SQLException {

            MyPojo myPojo = myPojoList.get(i);
            ps.setString(1, myPojo.getField1());
            ps.setString(2, myPojo.getField2());
            ps.setString(3, myPojo.getField3());

        }

        @Override
        public int getBatchSize() {
            return myPojoList.size();
        }
    });

}
  3. 0

    Il me semble que l'batchUpdate() la méthode de JdbcTemplate pourrait être utile dans ce cas (copié à partir d'ici http://www.mkyong.com/spring/spring-jdbctemplate-batchupdate-example/):

    //insert batch example
public void insertBatch(final List<Customer> customers){

  String sql = "INSERT INTO CUSTOMER " +
    "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";

  getJdbcTemplate().batchUpdate(sql, new BatchPreparedStatementSetter() {

@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
    Customer customer = customers.get(i);
    ps.setLong(1, customer.getCustId());
    ps.setString(2, customer.getName());
    ps.setInt(3, customer.getAge() );
}

@Override
public int getBatchSize() {
    return customers.size();
}

  });
 }
  4. -1

    vous pouvez aussi essayer avec jdbcInsert.executeBatch(sqlParamSourceArray)

       //define parameters
jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
jdbcInsert.withTableName("TABlE_NAME");
SqlParameterSource[] sqlParamSourceArray = new SqlParameterSource[apiConsumer
        .getApiRoleIds().size()];
for (int i = 0; i < myCollection.size(); i++) 
    {
  sqlParamSourceArray[i] = new MapSqlParameterSource().addValue("COL1");
      ......................
}
//execute insert
int[] keys = jdbcInsert.executeBatch(sqlParamSourceArray);
  5. -4

    Vous ne pouvez pas faire cela dans JDBC, période. MySQL c'est juste du sucre syntaxique, mais l'effet de la déclaration sera le même que l'émission de plusieurs états d'INSERTION. Ainsi, vous pouvez utiliser batchUpdate et il aura le même effet.