Dépôt officiel du code source de l'ERP OpenConcerto

import org.openconcerto.sql.utils.SQLUtils;

import org.openconcerto.utils.Tuple2;

import java.util.concurrent.atomic.AtomicLong;

import java.util.concurrent.atomic.AtomicReference;

    private static final Tuple2<Long, int[]> NO_QUERIES_RES = Tuple2.create(0l, new int[0]);

    /**

     * Execute multiple queries in batch.

     * 

     * @param queries what to execute.

     * @param atomic <code>true</code> if all queries should be executed in a transaction.

     * @return the total update count (< 0 if unknown), followed by the individual update counts.

     * @throws SQLException if an error occurs.

     * @see Statement#executeBatch()

     */

    public final Tuple2<Long, int[]> executeBatch(final List<String> queries, final boolean atomic) throws SQLException {

        if (queries.isEmpty())

            return NO_QUERIES_RES;

        final long timeMs = System.currentTimeMillis();

        final long time = System.nanoTime();

        final long afterCache = time;

        final AtomicLong afterQueryInfo = new AtomicLong();

        final AtomicLong afterExecute = new AtomicLong();

        final AtomicReference<Connection> conn = new AtomicReference<>();

        final ConnectionHandlerNoSetup<int[], SQLException> handler = new ConnectionHandlerNoSetup<int[], SQLException>() {

            @Override

            public int[] handle(SQLDataSource ds) throws SQLException {

                afterQueryInfo.set(System.nanoTime());

                conn.set(ds.getConnection());

                final int[] res;

                try (final Statement stmt = conn.get().createStatement()) {

                    for (final String s : queries) {

                        stmt.addBatch(s);

                    }

                    if (Thread.currentThread().isInterrupted())

                        throw new RTInterruptedException("Interrupted before executing : " + queries);

                    res = stmt.executeBatch();

                }

                afterExecute.set(System.nanoTime());

                return res;

            }

        };

        final int[] res = atomic ? SQLUtils.executeAtomic(this, handler) : this.useConnection(handler);

        long totalCount = 0;

        int i = 0;

        for (final int count : res) {

            if (count == Statement.SUCCESS_NO_INFO) {

                totalCount = -1;

                break;

            } else {

                if (count < 0)

                    throw new SQLException("Invalid count (" + count + ") for query " + i + " : " + queries.get(i));

                totalCount += count;

            }

            i++;

        }

        if (SQLRequestLog.isEnabled()) {

            final long afterHandle = System.nanoTime();

            SQLRequestLog.log(queries.toString(), "executeBatch", conn.get(), timeMs, time, afterCache, afterQueryInfo.get(), afterExecute.get(), afterHandle, afterHandle, (int) totalCount);

        }

        return Tuple2.create(totalCount, res);

    }