~maria-captains/mariadb-java-client/trunk

    private boolean isRewriteable = true;

    private String firstRewrite = null;

        isInsertRewriteable(sql);

    }

    

    /**

     * Parses the sql string to understand whether it is compatible with rewritten batches.

     * @param sql the sql string

     */

    private void isInsertRewriteable(String sql) {

        if (!isRewriteable) {

                return;

        }

        int index = getInsertIncipit(sql);

        if (index == -1) {

                isRewriteable = false;

                return;

        }

        if (firstRewrite == null) {

                firstRewrite = sql.substring(0, index);

        }

        boolean isRewrite = sql.startsWith(firstRewrite);

        if (isRewrite) {

                isRewriteable = isRewriteable && true;

        }

    }

    

    /**

     * Parses the input string to understand if it is an INSERT statement.

     * Returns the position of the round bracket after the VALUE(S) SQL keyword,

     * or -1 if it cannot understand it is an INSERT statement.

     * Multiple statements cannot be parsed.

     * @param sql the input SQL statement

     * @return the position of the round bracket after the VALUE(S) SQL keyword,

     * or -1 if it cannot be parsed as an INSERT statement

     */

    protected int getInsertIncipit(String sql) {

        String sqlUpper = sql.toUpperCase();

        if (! sqlUpper.startsWith("INSERT")

                        || sqlUpper.indexOf(";") != -1) {

                return -1;

        }

        int idx = sqlUpper.indexOf(" VALUE");

        int index = sqlUpper.indexOf("(", idx);

        return index;

    }

    

    /**

     * If the batch array contains only rewriteable sql strings, returns the rewritten statement.

     * @return the rewritten statement

     */

    private String rewrittenBatch() {

        StringBuilder result = null;

        if(isRewriteable) {

                result = new StringBuilder("");

                result.append(firstRewrite);

                for (String query : batchQueries) {

                        result.append(query.substring(getInsertIncipit(query)));

                        result.append(",");

                }

                result.deleteCharAt(result.length() - 1);

        }

        return (result == null ? null : result.toString());

        firstRewrite = null;

        isRewriteable = true;

                synchronized (this.protocol) {

                        if (getProtocol().getInfo().getProperty("rewriteBatchedStatements") != null

                                        && "true".equalsIgnoreCase(getProtocol().getInfo().getProperty("rewriteBatchedStatements"))) {

                                ret = executeBatchAsMultiQueries();

                        } else {

                                for(; i < batchQueries.size(); i++)  {

                                        execute(batchQueries.get(i));

                                        int updateCount = getUpdateCount();

                                        if (updateCount == -1) {

                                                ret[i] = SUCCESS_NO_INFO;

                                        } else {

                                                ret[i] = updateCount;

                                        }

                                }

                        }

                }

    

    /**

         * Builds a new statement which contains the batched Statements and executes it.

         * @return an array of update counts containing one element for each command in the batch.

         *  The elements of the array are ordered according to the order in which commands were added to the batch.

         * @throws SQLException

         */

        private int[] executeBatchAsMultiQueries() throws SQLException {

                int i = 0;

                StringBuilder stringBuilder = new StringBuilder();

                String rewrite = rewrittenBatch();

                if (rewrite != null) {

                        stringBuilder.append(rewrite);

                        i++;

                } else {

                        for (; i < batchQueries.size(); i++) {

                                stringBuilder.append(batchQueries.get(i) + ";");

                        }

                }

                Statement ps = connection.createStatement();

                ps.execute(stringBuilder.toString());

                return getUpdateCounts(ps, i);

        }

        /**

         * Retrieves the update counts for the batched statements rewritten as

         * a multi query. The rewritten statement must have been executed already.

         * @param statement the rewritten statement

         * @return an array of update counts containing one element for each command in the batch.

         *  The elements of the array are ordered according to the order in which commands were added to the batch.

         * @throws SQLException

         */

        protected int[] getUpdateCounts(Statement statement, int size) throws SQLException {

                int[] result = new int[size];

                int updateCount;

                for (int count=0; count<size; count++) {

                        updateCount = statement.getUpdateCount();

            if (updateCount == -1) {

                result[count] = SUCCESS_NO_INFO;

            } else {

                result[count] = updateCount;

            }

            statement.getMoreResults();

                }

                return result;

        }