Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    *
    * Copyright (c) 2013-2014 sagyf Yang. The Four Group.
    */
   
   package com.jfinal.plugin.activerecord;
   
  
  import java.sql.*;
  import java.util.List;
  import java.util.Map;
  
  import static com.jfinal.plugin.activerecord.DbKit.NULL_PARA_ARRAY;

Db. Powerful database query and update tool box.
  
  @SuppressWarnings({"UnusedDeclaration""unchecked"})
  public class Db {
  
      public static final String PRIMARY_KEY = "id";
      public static final String COLUMNS = "*";
  
      static <T> List<T> query(Connection connString sqlObject... parasthrows SQLException {
          List result = new ArrayList();
          PreparedStatement pst = conn.prepareStatement(sql);
  
          ..fillStatement(pstparas);
          // for (int i=0; i<paras.length; i++) {
          // pst.setObject(i + 1, paras[i]);
          // }
  
          ResultSet rs = pst.executeQuery();
  
          int colAmount = rs.getMetaData().getColumnCount();
          if (colAmount > 1) {
              while (rs.next()) {
                  Object[] temp = new Object[colAmount];
                  for (int i = 0; i < colAmounti++) {
                      temp[i] = rs.getObject(i + 1);
                  }
                  result.add(temp);
              }
          } else if (colAmount == 1) {
              while (rs.next()) {
                  result.add(rs.getObject(1));
              }
          }
          DbKit.closeQuietly(rspst);
  
          return result;
      }

    
  
      public static <T> List<T> query(String sqlObject... paras) {
          Connection conn = null;
          try {
              conn = DbKit.getConnection();
              return query(connsqlparas);
          } catch (Exception e) {
              throw new ActiveRecordException(e);
          } finally {
              DbKit.close(conn);
          }
      }

    
Execute sql query. The result can not convert to Record.

Parameters:
dataSource the DataSource for this query
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
List<Object[]> if your sql has select more than one column, and it return List<Object> if your sql has select only one column.
  
      public static <T> List<T> query(DataSource dataSourceString sqlObject... paras) {
          Connection conn = null;
          try {
              conn = dataSource.getConnection();
              return query(connsqlparas);
          } catch (Exception e) {
              throw new ActiveRecordException(e);
          } finally {
              DbKit.closeIgnoreThreadLocal(conn);
          }
      }

    

Parameters:
sql an SQL statement
See also:
query(javax.sql.DataSource,java.lang.String,java.lang.Object[])
  
      public static <T> List<T> query(DataSource dataSourceString sql) {
         return query(dataSourcesql);
     }

    

Parameters:
sql an SQL statement
See also:
query(javax.sql.DataSource,java.lang.String,java.lang.Object[])
 
     public static <T> List<T> query(String sql) {        // return  List<object[]> or List<object>
         return query(sql);
     }

    
Execute sql query and return the first result. I recommend add "limit 1" in your sql.

Parameters:
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
Object[] if your sql has select more than one column, and it return Object if your sql has select only one column.
 
     public static <T> T queryFirst(String sqlObject... paras) {
         List<T> result = query(sqlparas);
         return (result.size() > 0 ? result.get(0) : null);
     }

    

Parameters:
sql an SQL statement
See also:
queryFirst(java.lang.String,java.lang.Object[])
 
     public static <T> T queryFirst(String sql) {
         // return queryFirst(sql, NULL_PARA_ARRAY);
         List<T> result = query(sql);
         return (result.size() > 0 ? result.get(0) : null);
     }
 
     // 26 queryXxx method below -----------------------------------------------
 
    
Execute sql query just return one column.

Parameters:
<T> the type of the column that in your sql's select statement
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
List<T>
 
     public static <T> T queryColumn(String sqlObject... paras) {
         List<T> result = query(sqlparas);
         if (result.size() > 0) {
             T temp = result.get(0);
             if (temp instanceof Object[])
                 throw new ActiveRecordException("Only ONE COLUMN can be queried.");
             return temp;
         }
         return null;
     }
 
     public static <T> T queryColumn(String sql) {
         return queryColumn(sql);
     }
 
     public static String queryStr(String sqlObject... paras) {
         return (StringqueryColumn(sqlparas);
     }
 
     public static String queryStr(String sql) {
         return (StringqueryColumn(sql);
     }
 
     public static Integer queryInt(String sqlObject... paras) {
         return (IntegerqueryColumn(sqlparas);
     }
 
     public static Integer queryInt(String sql) {
         return (IntegerqueryColumn(sql);
     }
 
     public static Long queryLong(String sqlObject... paras) {
         return (LongqueryColumn(sqlparas);
     }
 
     public static Long queryLong(String sql) {
         return (LongqueryColumn(sql);
     }
 
     public static Double queryDouble(String sqlObject... paras) {
         return (DoublequeryColumn(sqlparas);
     }
 
     public static Double queryDouble(String sql) {
         return (DoublequeryColumn(sql);
     }
 
     public static Float queryFloat(String sqlObject... paras) {
         return (FloatqueryColumn(sqlparas);
     }
 
     public static Float queryFloat(String sql) {
         return (FloatqueryColumn(sql);
     }
 
     public static java.math.BigDecimal queryBigDecimal(String sqlObject... paras) {
         return (java.math.BigDecimalqueryColumn(sqlparas);
     }
 
     public static java.math.BigDecimal queryBigDecimal(String sql) {
         return (java.math.BigDecimalqueryColumn(sql);
     }
 
     public static byte[] queryBytes(String sqlObject... paras) {
         return (byte[]) queryColumn(sqlparas);
     }
 
     public static byte[] queryBytes(String sql) {
         return (byte[]) queryColumn(sql);
     }
 
     public static java.sql.Date queryDate(String sqlObject... paras) {
         return (java.sql.DatequeryColumn(sqlparas);
     }
 
     public static java.sql.Date queryDate(String sql) {
         return (java.sql.DatequeryColumn(sql);
     }
 
     public static java.sql.Time queryTime(String sqlObject... paras) {
         return (java.sql.TimequeryColumn(sqlparas);
     }
 
     public static java.sql.Time queryTime(String sql) {
         return (java.sql.TimequeryColumn(sql);
     }
 
     public static java.sql.Timestamp queryTimestamp(String sqlObject... paras) {
         return (java.sql.TimestampqueryColumn(sqlparas);
     }
 
     public static java.sql.Timestamp queryTimestamp(String sql) {
         return (java.sql.TimestampqueryColumn(sql);
     }
 
     public static Boolean queryBoolean(String sqlObject... paras) {
         return (BooleanqueryColumn(sqlparas);
     }
 
     public static Boolean queryBoolean(String sql) {
         return (BooleanqueryColumn(sql);
     }
 
     public static Number queryNumber(String sqlObject... paras) {
         return (NumberqueryColumn(sqlparas);
     }
 
     public static Number queryNumber(String sql) {
         return (NumberqueryColumn(sql);
     }
     // 26 queryXxx method under -----------------------------------------------
 
    
Execute sql update
 
     static int update(Connection connString sqlObject... parasthrows SQLException {
         PreparedStatement pst = conn.prepareStatement(sql);
         ..fillStatement(pstparas);
         // for (int i=0; i<paras.length; i++) {
         // pst.setObject(i + 1, paras[i]);
         // }
         int result = pst.executeUpdate();
         DbKit.closeQuietly(pst);
 
         return result;
     }

    
Execute update, insert or delete sql statement.

Parameters:
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
either the row count for INSERT, UPDATE, or DELETE statements, or 0 for SQL statements that return nothing
 
     public static int update(String sqlObject... paras) {
         Connection conn = null;
         try {
             conn = DbKit.getConnection();
             return update(connsqlparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.close(conn);
         }
     }

    

Parameters:
dataSource the DataSource for this query
See also:
update(java.lang.String,java.lang.Object[])
 
     public static int update(DataSource dataSourceString sqlObject... paras) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return update(connsqlparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    
 
     public static int update(DataSource dataSourceString sql) {
         return update(dataSourcesql);
     }

    
 
     public static int update(String sql) {
         return update(sql);
     }

    
Get id after insert method getGeneratedKey().
 
     private static Object getGeneratedKey(PreparedStatement pstthrows SQLException {
         ResultSet rs = pst.getGeneratedKeys();
         Object id = null;
         if (rs.next())
             id = rs.getObject(1);
         rs.close();
         return id;
     }
 
     static List<Recordfind(Connection connString sqlObject... parasthrows SQLException {
         PreparedStatement pst = conn.prepareStatement(sql);
         ..fillStatement(pstparas);
         // for (int i=0; i<paras.length; i++) {
         // pst.setObject(i + 1, paras[i]);
         // }
         ResultSet rs = pst.executeQuery();
         List<Recordresult = RecordBuilder.build(rs);
         DbKit.closeQuietly(rspst);
         return result;
     }

    
 
     public static List<Recordfind(String sqlObject... paras) {
         Connection conn = null;
         try {
             conn = DbKit.getConnection();
             return find(connsqlparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.close(conn);
         }
     }

    

Parameters:
sql the sql statement
See also:
find(javax.sql.DataSource,java.lang.String,java.lang.Object[])
 
     public static List<Recordfind(String sql) {
         return find(sql);
     }

    
Find Record.

Parameters:
dataSource the DataSource for this query
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
the list of Record
 
     public static List<Recordfind(DataSource dataSourceString sqlObject... paras) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return find(connsqlparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    

Parameters:
sql the sql statement
See also:
find(javax.sql.DataSource,java.lang.String,java.lang.Object[])
 
     public static List<Recordfind(DataSource dataSourceString sql) {
         return find(dataSourcesql);
     }

    
Find first record. I recommend add "limit 1" in your sql.

Parameters:
sql an SQL statement that may contain one or more '?' IN parameter placeholders
paras the parameters of sql
Returns:
the Record object
 
     public static Record findFirst(String sqlObject... paras) {
         List<Recordresult = find(sqlparas);
         return result.size() > 0 ? result.get(0) : null;
     }

    

Parameters:
sql an SQL statement
See also:
findFirst(java.lang.String,java.lang.Object[])
 
     public static Record findFirst(String sql) {
         List<Recordresult = find(sql);
         return result.size() > 0 ? result.get(0) : null;
     }

    
Find record by id. Example: Record user = Db.findById("user", 15);

Parameters:
tableName the table name of the table
idValue the id value of the record
 
     public static Record findById(String tableNameObject idValue) {
         return findById(tableNameidValue);
     }

    
Find record by id. Fetch the specific columns only. Example: Record user = Db.findById("user", 15, "name, age");

Parameters:
tableName the table name of the table
idValue the id value of the record
columns the specific columns separate with comma character ==> ","
 
     public static Record findById(String tableNameNumber idValueString columns) {
         return findById(tableNameidValuecolumns);
     }

    
Find record by id. Example: Record user = Db.findById("user", "user_id", 15);

Parameters:
tableName the table name of the table
primaryKey the primary key of the table
idValue the id value of the record
 
     public static Record findById(String tableNameString primaryKeyNumber idValue) {
         return findById(tableNameprimaryKeyidValue);
     }

    
Find record by id. Fetch the specific columns only. Example: Record user = Db.findById("user", "user_id", 15, "name, age");

Parameters:
tableName the table name of the table
primaryKey the primary key of the table
idValue the id value of the record
columns the specific columns separate with comma character ==> ","
 
     public static Record findById(String tableNameString primaryKeyObject idValueString columns) {
         String sql = ..forDbFindById(tableNameprimaryKeycolumns);
         List<Recordresult = find(sqlidValue);
         return result.size() > 0 ? result.get(0) : null;
     }

    
Delete record by id. Example: boolean succeed = Db.deleteById("user", 15);

Parameters:
tableName the table name of the table
id the id value of the record
Returns:
true if delete succeed otherwise false
 
     public static boolean deleteById(String tableNameObject id) {
         return deleteById(tableNameid);
     }

    
Delete record by id. Example: boolean succeed = Db.deleteById("user", "user_id", 15);

Parameters:
tableName the table name of the table
primaryKey the primary key of the table
id the id value of the record
Returns:
true if delete succeed otherwise false
 
     public static boolean deleteById(String tableNameString primaryKeyObject id) {
         if (id == null)
             throw new IllegalArgumentException("id can not be null");
 
         String sql = ..forDbDeleteById(tableNameprimaryKey);
         return update(sqlid) >= 1;
     }

    
Delete record. Example: boolean succeed = Db.delete("user", "id", user);

Parameters:
tableName the table name of the table
primaryKey the primary key of the table
record the record
Returns:
true if delete succeed otherwise false
 
     public static boolean delete(String tableNameString primaryKeyRecord record) {
         return deleteById(tableNameprimaryKeyrecord.get(primaryKey));
     }

    
Example: boolean succeed = Db.delete("user", user);

 
     public static boolean delete(String tableNameRecord record) {
         return deleteById(tableNamerecord.get());
     }
 
     static Page<Recordpaginate(Connection connint pageNumberint pageSizeString selectString sqlExceptSelectObject... parasthrows SQLException {
         if (pageNumber < 1 || pageSize < 1)
             throw new ActiveRecordException("pageNumber and pageSize must be more than 0");
 
         if (..isTakeOverDbPaginate())
             return ..takeOverDbPaginate(connpageNumberpageSizeselectsqlExceptSelectparas);
 
         long totalRow;
         int totalPage;
         List result = query(conn"select count(1) " + DbKit.replaceFormatSqlOrderBy(sqlExceptSelect), paras);
         int size = result.size();
         if (size == 1)
             totalRow = ((Numberresult.get(0)).longValue();
         else if (size > 1)
             totalRow = result.size();
         else
             return new Page<Record>(new ArrayList<Record>(0), pageNumberpageSize, 0, 0);
 
         totalPage = (int) (totalRow / pageSize);
         if (totalRow % pageSize != 0) {
             totalPage++;
         }
 
         // --------
         StringBuilder sql = new StringBuilder();
         ..forPaginate(sqlpageNumberpageSizeselectsqlExceptSelect);
         List<Recordlist = find(connsql.toString(), paras);
         return new Page<Record>(listpageNumberpageSizetotalPage, (inttotalRow);
     }

    
 
     public static Page<Recordpaginate(int pageNumberint pageSizeString selectString sqlExceptSelectObject... paras) {
         Connection conn = null;
         try {
             conn = DbKit.getConnection();
             return paginate(connpageNumberpageSizeselectsqlExceptSelectparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.close(conn);
         }
     }

    
Paginate.

Parameters:
dataSource the DataSource for this query
pageNumber the page number
pageSize the page size
select the select part of the sql statement
sqlExceptSelect the sql statement excluded select part
paras the parameters of sql
Returns:
Page
 
     public static Page<Recordpaginate(DataSource dataSourceint pageNumberint pageSizeString selectString sqlExceptSelectObject... paras) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return paginate(connpageNumberpageSizeselectsqlExceptSelectparas);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    
 
     public static Page<Recordpaginate(DataSource dataSourceint pageNumberint pageSizeString selectString sqlExceptSelect) {
         return paginate(dataSourcepageNumberpageSizeselectsqlExceptSelect);
     }

    
 
     public static Page<Recordpaginate(int pageNumberint pageSizeString selectString sqlExceptSelect) {
         return paginate(pageNumberpageSizeselectsqlExceptSelect);
     }
 
     static boolean save(Connection connString tableNameString primaryKeyRecord recordthrows SQLException {
         List<Objectparas = new ArrayList<Object>();
         StringBuilder sql = new StringBuilder();
         ..forDbSave(sqlparastableNamerecord);
 
         PreparedStatement pst;
         if (..isOracle())
             pst = conn.prepareStatement(sql.toString(), new String[]{primaryKey});
         else
             pst = conn.prepareStatement(sql.toString(), .);
 
         ..fillStatement(pstparas);
         // for (int i=0, size=paras.size(); i<size; i++) {
         // pst.setObject(i + 1, paras.get(i));
         // }
         int result = pst.executeUpdate();
         // if (isSupportAutoIncrementKey)
         record.set(primaryKeygetGeneratedKey(pst));
         DbKit.closeQuietly(pst);
 
         return result >= 1;
     }

    
 
     public static boolean save(String tableNameString primaryKeyRecord record) {
         Connection conn = null;
         try {
             conn = DbKit.getConnection();
             return save(conntableNameprimaryKeyrecord);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.close(conn);
         }
     }

    
 
     public static boolean save(String tableNameRecord record) {
         return save(tableNamerecord);
     }

    
Save record.

Parameters:
dataSource the DataSource for this query
tableName the table name of the table
primaryKey the primary key of the table
record the record will be saved
Returns:
save success.
 
     public static boolean save(DataSource dataSourceString tableNameString primaryKeyRecord record) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return save(conntableNameprimaryKeyrecord);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    
 
     public static boolean save(DataSource dataSourceString tableNameRecord record) {
         return save(dataSourcetableNamerecord);
     }
 
     static boolean update(Connection connString tableNameString primaryKeyRecord recordthrows SQLException {
         Object id = record.get(primaryKey);
         if (id == null)
             throw new ActiveRecordException("You can't update model without Primary Key.");
 
         StringBuilder sql = new StringBuilder();
         List<Objectparas = new ArrayList<Object>();
         ..forDbUpdate(tableNameprimaryKeyidrecordsqlparas);
 
         return paras.size() > 1 && update(connsql.toString(), paras.toArray()) >= 1;
 
     }

    
 
     public static boolean update(String tableNameString primaryKeyRecord record) {
         Connection conn = null;
         try {
             conn = DbKit.getConnection();
             return update(conntableNameprimaryKeyrecord);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.close(conn);
         }
     }

    
 
     public static boolean update(String tableNameRecord record) {
         return update(tableNamerecord);
     }

    
Update Record.

Parameters:
dataSource the DataSource for this query
tableName the table name of the Record save to
primaryKey the primary key of the table
record the Record object
Returns:
update
 
     public static boolean update(DataSource dataSourceString tableNameString primaryKeyRecord record) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return update(conntableNameprimaryKeyrecord);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    
 
     public static boolean update(DataSource dataSourceString tableNameRecord record) {
         return update(dataSourcetableNamerecord);
     }

    
 
     public static Object execute(ICallback callback) {
         return execute(DbKit.getDataSource(), callback);
     }

    
Execute callback. It is useful when all the API can not satisfy your requirement.

Parameters:
dataSource the DataSource for this query
callback the ICallback interface
 
     public static Object execute(DataSource dataSourceICallback callback) {
         Connection conn = null;
         try {
             conn = dataSource.getConnection();
             return callback.run(conn);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }

    
Execute transaction.

Parameters:
transactionLevel the transaction level
atom the atom operation
Returns:
true if transaction executing succeed otherwise false
 
     public static boolean tx(int transactionLevelIAtom atom) {
         Connection conn = DbKit.getThreadLocalConnection();
         if (conn != null) {    // Nested transaction support
             try {
                 if (conn.getTransactionIsolation() < transactionLevel)
                     conn.setTransactionIsolation(transactionLevel);
                 boolean result = atom.run();
                 if (result)
                     return true;
                 throw new ActiveRecordException("Nested transaction is failure.");    // important:can not return false
             } catch (SQLException e) {
                 throw new ActiveRecordException(e);
             }
         }
 
         Boolean autoCommit = null;
         try {
             conn = DbKit.getDataSource().getConnection();
             autoCommit = conn.getAutoCommit();
             DbKit.setThreadLocalConnection(conn);
             conn.setTransactionIsolation(transactionLevel);
             conn.setAutoCommit(false);
             boolean result = atom.run();
             if (result)
                 conn.commit();
             else
                 conn.rollback();
             return result;
         } catch (Exception e) {
             if (conn != null)
                 try {
                     conn.rollback();
                 } catch (Exception e1) {
                     e1.printStackTrace();
                 }
             throw e instanceof RuntimeException ? (RuntimeExceptione : new ActiveRecordException(e);
         } finally {
             try {
                 if (conn != null) {
                     if (autoCommit != null)
                         conn.setAutoCommit(autoCommit);
                     conn.close();
                 }
             } catch (Exception e) {
                 e.printStackTrace();    // can not throw exception here, otherwise the more important exception in previous catch block can not be thrown
             } finally {
                 DbKit.removeThreadLocalConnection();    // prevent memory leak
             }
         }
     }

    
Execute transaction with default transaction level.

 
     public static boolean tx(IAtom atom) {
         return tx(DbKit.getTransactionLevel(), atom);
     }

    
Find Record by cache.

Parameters:
cacheName the cache name
key the key used to get date from cache
Returns:
the list of Record
See also:
find(java.lang.String,java.lang.Object[])
 
     public static List<RecordfindByCache(String cacheNameObject keyString sqlObject... paras) {
         ICache cache = DbKit.getCache();
         List<Recordresult = cache.get(cacheNamekey);
         if (result == null) {
             result = find(sqlparas);
             cache.put(cacheNamekeyresult);
         }
         return result;
     }

    
 
     public static List<RecordfindByCache(String cacheNameObject keyString sql) {
         return findByCache(cacheNamekeysql);
     }

    
 
     public static Page<RecordpaginateByCache(String cacheNameObject keyint pageNumberint pageSizeString selectString sqlExceptSelectObject... paras) {
         ICache cache = DbKit.getCache();
         Page<Recordresult = cache.get(cacheNamekey);
         if (result == null) {
             result = paginate(pageNumberpageSizeselectsqlExceptSelectparas);
             cache.put(cacheNamekeyresult);
         }
         return result;
     }

    
 
     public static Page<RecordpaginateByCache(String cacheNameObject keyint pageNumberint pageSizeString selectString sqlExceptSelect) {
         return paginateByCache(cacheNamekeypageNumberpageSizeselectsqlExceptSelect);
     }
 
     private static int[] batch(Connection connString sqlObject[][] parasint batchSizethrows SQLException {
         if (paras == null || paras.length == 0)
             throw new IllegalArgumentException("The paras array length must more than 0.");
         if (batchSize < 1)
             throw new IllegalArgumentException("The batchSize must more than 0.");
         int counter = 0;
         int pointer = 0;
         int[] result = new int[paras.length];
         PreparedStatement pst = conn.prepareStatement(sql);
         for (Object[] para : paras) {
             for (int j = 0; j < para.lengthj++) {
                 pst.setObject(j + 1, para[j]);    // TODO use Dialect.fillStatement(...)
             }
             pst.addBatch();
             if (++counter >= batchSize) {
                 counter = 0;
                 int[] r = pst.executeBatch();
                 conn.commit();
                 for (int aR : rresult[pointer++] = aR;
             }
         }
         int[] r = pst.executeBatch();
         conn.commit();
         for (int aR : rresult[pointer++] = aR;
         DbKit.closeQuietly(pst);
         return result;
     }

    
Execute a batch of SQL INSERT, UPDATE, or DELETE queries.

Example:

 String sql = "insert into user(name, cash) values(?, ?)";
 int[] result = Db.batch(sql, new Object[][]{{"James", 888}, {"zhanjin", 888}});
 

Parameters:
sql The SQL to execute.
paras An array of query replacement parameters. Each row in this array is one set of batch replacement values.
Returns:
The number of rows updated per statement
 
     public static int[] batch(String sqlObject[][] parasint batchSize) {
         Connection conn = null;
         Boolean autoCommit = null;
         try {
             conn = DbKit.getConnection();
             autoCommit = conn.getAutoCommit();
             conn.setAutoCommit(false);
             return batch(connsqlparasbatchSize);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             if (autoCommit != null)
                 try {
                     conn.setAutoCommit(autoCommit);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             DbKit.close(conn);
         }
     }

    

Parameters:
dataSource the DataSource for this query
See also:
batch(java.lang.String,java.lang.Object[][],int)
 
     public static int[] batch(DataSource dataSourceString sqlObject[][] parasint batchSize) {
         Connection conn = null;
         Boolean autoCommit = null;
         try {
             conn = dataSource.getConnection();
             autoCommit = conn.getAutoCommit();
             conn.setAutoCommit(false);
             return batch(connsqlparasbatchSize);
         } catch (Exception e) {
             throw new ActiveRecordException(e);
         } finally {
             if (autoCommit != null)
                 try {
                     conn.setAutoCommit(autoCommit);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             DbKit.closeIgnoreThreadLocal(conn);
         }
     }
 
     private static int[] batch(Connection connString sqlString columnsList listint batchSizethrows SQLException {
         if (list == null || list.size() == 0)
             return new int[0];
         Object element = list.get(0);
         if (!(element instanceof Record) && !(element instanceof Model))
             throw new IllegalArgumentException("The element in list must be Model or Record.");
         if (batchSize < 1)
             throw new IllegalArgumentException("The batchSize must more than 0.");
         boolean isModel = element instanceof Model;
 
         String[] columnArray = columns.split(.);
         for (int i = 0; i < columnArray.lengthi++)
             columnArray[i] = columnArray[i].trim();
 
         int counter = 0;
         int pointer = 0;
         int size = list.size();
         int[] result = new int[size];
         PreparedStatement pst = conn.prepareStatement(sql);
         for (Object aList : list) {
             Map map = isModel ? ((ModelaList).getAttrs() : ((RecordaList).getColumns();
             for (int j = 0; j < columnArray.lengthj++) {
                 pst.setObject(j + 1, map.get(columnArray[j]));        // TODO use Dialect.fillStatement(...)
             }
             pst.addBatch();
             if (++counter >= batchSize) {
                 counter = 0;
                 int[] r = pst.executeBatch();
                 conn.commit();
                 for (int aR : rresult[pointer++] = aR;
            }
        }
        int[] r = pst.executeBatch();
        conn.commit();
        for (int aR : rresult[pointer++] = aR;
        DbKit.closeQuietly(pst);
        return result;
    }

    
Execute a batch of SQL INSERT, UPDATE, or DELETE queries.

Example:

 String sql = "insert into user(name, cash) values(?, ?)";
 int[] result = Db.batch(sql, "name, cash", modelList, 500);
 

Parameters:
sql The SQL to execute.
columns the columns need be processed by sql.
modelOrRecordList model or record object list.
batchSize batch size.
Returns:
The number of rows updated per statement
    public static int[] batch(String sqlString columnsList modelOrRecordListint batchSize) {
        Connection conn = null;
        Boolean autoCommit = null;
        try {
            conn = DbKit.getConnection();
            autoCommit = conn.getAutoCommit();
            conn.setAutoCommit(false);
            return batch(connsqlcolumnsmodelOrRecordListbatchSize);
        } catch (Exception e) {
            throw new ActiveRecordException(e);
        } finally {
            if (autoCommit != null)
                try {
                    conn.setAutoCommit(autoCommit);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            DbKit.close(conn);
        }
    }

    

Parameters:
dataSource the DataSource for this query
See also:
batch(java.lang.String,java.lang.String,java.util.List,int)
    public static int[] batch(DataSource dataSourceString sqlString columnsList modelOrRecordListint batchSize) {
        Connection conn = null;
        Boolean autoCommit = null;
        try {
            conn = dataSource.getConnection();
            autoCommit = conn.getAutoCommit();
            conn.setAutoCommit(false);
            return batch(connsqlcolumnsmodelOrRecordListbatchSize);
        } catch (Exception e) {
            throw new ActiveRecordException(e);
        } finally {
            if (autoCommit != null)
                try {
                    conn.setAutoCommit(autoCommit);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            DbKit.closeIgnoreThreadLocal(conn);
        }
    }
    private static int[] batch(Connection connList<StringsqlListint batchSizethrows SQLException {
        if (sqlList == null || sqlList.size() == 0)
            throw new IllegalArgumentException("The sqlList length must more than 0.");
        if (batchSize < 1)
            throw new IllegalArgumentException("The batchSize must more than 0.");
        int counter = 0;
        int pointer = 0;
        int size = sqlList.size();
        int[] result = new int[size];
        Statement st = conn.createStatement();
        for (String aSqlList : sqlList) {
            st.addBatch(aSqlList);
            if (++counter >= batchSize) {
                counter = 0;
                int[] r = st.executeBatch();
                conn.commit();
                for (int aR : rresult[pointer++] = aR;
            }
        }
        int[] r = st.executeBatch();
        conn.commit();
        for (int aR : rresult[pointer++] = aR;
        DbKit.closeQuietly(st);
        return result;
    }

    
Execute a batch of SQL INSERT, UPDATE, or DELETE queries. Example:
 int[] result = Db.batch(sqlList, 500);
 

Parameters:
sqlList The SQL list to execute.
batchSize batch size.
Returns:
The number of rows updated per statement
    public static int[] batch(List<StringsqlListint batchSize) {
        Connection conn = null;
        Boolean autoCommit = null;
        try {
            conn = DbKit.getConnection();
            autoCommit = conn.getAutoCommit();
            conn.setAutoCommit(false);
            return batch(connsqlListbatchSize);
        } catch (Exception e) {
            throw new ActiveRecordException(e);
        } finally {
            if (autoCommit != null)
                try {
                    conn.setAutoCommit(autoCommit);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            DbKit.close(conn);
        }
    }

    

Parameters:
dataSource the DataSource for this query
See also:
batch(java.util.List,int)
    public static int[] batch(DataSource dataSourceList<StringsqlListint batchSize) {
        Connection conn = null;
        Boolean autoCommit = null;
        try {
            conn = dataSource.getConnection();
            autoCommit = conn.getAutoCommit();
            conn.setAutoCommit(false);
            return batch(connsqlListbatchSize);
        } catch (Exception e) {
            throw new ActiveRecordException(e);
        } finally {
            if (autoCommit != null)
                try {
                    conn.setAutoCommit(autoCommit);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            DbKit.closeIgnoreThreadLocal(conn);
        }
    }