• Home
• mysql
• mysql-connector-java
• 5.1.46
• source code
• PreparedStatement.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.mysql.jdbc.PreparedStatement Maven / Gradle / Ivy

/*
  Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.

  The MySQL Connector/J is licensed under the terms of the GPLv2
  , like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FOSS License Exception
  .

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA

 */

package com.mysql.jdbc;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.sql.Array;
import java.sql.Clob;
import java.sql.DatabaseMetaData;
import java.sql.Date;
import java.sql.ParameterMetaData;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;

import com.mysql.jdbc.exceptions.MySQLStatementCancelledException;
import com.mysql.jdbc.exceptions.MySQLTimeoutException;
import com.mysql.jdbc.profiler.ProfilerEvent;

/**
 * A SQL Statement is pre-compiled and stored in a PreparedStatement object. This object can then be used to efficiently execute this statement multiple times.
 * 
 * 

 * Note: The setXXX methods for setting IN parameter values must specify types that are compatible with the defined SQL type of the input parameter. For
 * instance, if the IN parameter has SQL type Integer, then setInt should be used.
 * 
 * 
 * 

 * If arbitrary parameter type conversions are required, then the setObject method should be used with a target SQL type.
 * 
 */
public class PreparedStatement extends com.mysql.jdbc.StatementImpl implements java.sql.PreparedStatement {
    private static final Constructor JDBC_4_PSTMT_2_ARG_CTOR;
    private static final Constructor JDBC_4_PSTMT_3_ARG_CTOR;
    private static final Constructor JDBC_4_PSTMT_4_ARG_CTOR;

    static {
        if (Util.isJdbc4()) {
            try {
                String jdbc4ClassName = Util.isJdbc42() ? "com.mysql.jdbc.JDBC42PreparedStatement" : "com.mysql.jdbc.JDBC4PreparedStatement";
                JDBC_4_PSTMT_2_ARG_CTOR = Class.forName(jdbc4ClassName).getConstructor(new Class[] { MySQLConnection.class, String.class });
                JDBC_4_PSTMT_3_ARG_CTOR = Class.forName(jdbc4ClassName).getConstructor(new Class[] { MySQLConnection.class, String.class, String.class });
                JDBC_4_PSTMT_4_ARG_CTOR = Class.forName(jdbc4ClassName)
                        .getConstructor(new Class[] { MySQLConnection.class, String.class, String.class, ParseInfo.class });
            } catch (SecurityException e) {
                throw new RuntimeException(e);
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        } else {
            JDBC_4_PSTMT_2_ARG_CTOR = null;
            JDBC_4_PSTMT_3_ARG_CTOR = null;
            JDBC_4_PSTMT_4_ARG_CTOR = null;
        }
    }

    public class BatchParams {
        public boolean[] isNull = null;

        public boolean[] isStream = null;

        public InputStream[] parameterStreams = null;

        public byte[][] parameterStrings = null;

        public int[] streamLengths = null;

        BatchParams(byte[][] strings, InputStream[] streams, boolean[] isStreamFlags, int[] lengths, boolean[] isNullFlags) {
            //
            // Make copies
            //
            this.parameterStrings = new byte[strings.length][];
            this.parameterStreams = new InputStream[streams.length];
            this.isStream = new boolean[isStreamFlags.length];
            this.streamLengths = new int[lengths.length];
            this.isNull = new boolean[isNullFlags.length];
            System.arraycopy(strings, 0, this.parameterStrings, 0, strings.length);
            System.arraycopy(streams, 0, this.parameterStreams, 0, streams.length);
            System.arraycopy(isStreamFlags, 0, this.isStream, 0, isStreamFlags.length);
            System.arraycopy(lengths, 0, this.streamLengths, 0, lengths.length);
            System.arraycopy(isNullFlags, 0, this.isNull, 0, isNullFlags.length);
        }
    }

    class EndPoint {
        int begin;

        int end;

        EndPoint(int b, int e) {
            this.begin = b;
            this.end = e;
        }
    }

    public static final class ParseInfo {
        char firstStmtChar = 0;

        boolean foundLoadData = false;

        long lastUsed = 0;

        int statementLength = 0;

        int statementStartPos = 0;

        boolean canRewriteAsMultiValueInsert = false;

        byte[][] staticSql = null;

        boolean isOnDuplicateKeyUpdate = false;

        int locationOfOnDuplicateKeyUpdate = -1;

        String valuesClause;

        boolean parametersInDuplicateKeyClause = false;

        String charEncoding;

        /**
         * Represents the "parsed" state of a client-side prepared statement, with the statement broken up into it's static and dynamic (where parameters are
         * bound) parts.
         */
        ParseInfo(String sql, MySQLConnection conn, java.sql.DatabaseMetaData dbmd, String encoding, SingleByteCharsetConverter converter) throws SQLException {
            this(sql, conn, dbmd, encoding, converter, true);
        }

        public ParseInfo(String sql, MySQLConnection conn, java.sql.DatabaseMetaData dbmd, String encoding, SingleByteCharsetConverter converter,
                boolean buildRewriteInfo) throws SQLException {
            try {
                if (sql == null) {
                    throw SQLError.createSQLException(Messages.getString("PreparedStatement.61"), SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
                            conn.getExceptionInterceptor());
                }

                this.charEncoding = encoding;
                this.lastUsed = System.currentTimeMillis();

                String quotedIdentifierString = dbmd.getIdentifierQuoteString();

                char quotedIdentifierChar = 0;

                if ((quotedIdentifierString != null) && !quotedIdentifierString.equals(" ") && (quotedIdentifierString.length() > 0)) {
                    quotedIdentifierChar = quotedIdentifierString.charAt(0);
                }

                this.statementLength = sql.length();

                ArrayList endpointList = new ArrayList();
                boolean inQuotes = false;
                char quoteChar = 0;
                boolean inQuotedId = false;
                int lastParmEnd = 0;
                int i;

                boolean noBackslashEscapes = conn.isNoBackslashEscapesSet();

                // we're not trying to be real pedantic here, but we'd like to  skip comments at the beginning of statements, as frameworks such as Hibernate
                // use them to aid in debugging

                this.statementStartPos = findStartOfStatement(sql);

                for (i = this.statementStartPos; i < this.statementLength; ++i) {
                    char c = sql.charAt(i);

                    if ((this.firstStmtChar == 0) && Character.isLetter(c)) {
                        // Determine what kind of statement we're doing (_S_elect, _I_nsert, etc.)
                        this.firstStmtChar = Character.toUpperCase(c);

                        // no need to search for "ON DUPLICATE KEY UPDATE" if not an INSERT statement
                        if (this.firstStmtChar == 'I') {
                            this.locationOfOnDuplicateKeyUpdate = getOnDuplicateKeyLocation(sql, conn.getDontCheckOnDuplicateKeyUpdateInSQL(),
                                    conn.getRewriteBatchedStatements(), conn.isNoBackslashEscapesSet());
                            this.isOnDuplicateKeyUpdate = this.locationOfOnDuplicateKeyUpdate != -1;
                        }
                    }

                    if (!noBackslashEscapes && c == '\\' && i < (this.statementLength - 1)) {
                        i++;
                        continue; // next character is escaped
                    }

                    // are we in a quoted identifier? (only valid when the id is not inside a 'string')
                    if (!inQuotes && (quotedIdentifierChar != 0) && (c == quotedIdentifierChar)) {
                        inQuotedId = !inQuotedId;
                    } else if (!inQuotedId) {
                        //	only respect quotes when not in a quoted identifier

                        if (inQuotes) {
                            if (((c == '\'') || (c == '"')) && c == quoteChar) {
                                if (i < (this.statementLength - 1) && sql.charAt(i + 1) == quoteChar) {
                                    i++;
                                    continue; // inline quote escape
                                }

                                inQuotes = !inQuotes;
                                quoteChar = 0;
                            } else if (((c == '\'') || (c == '"')) && c == quoteChar) {
                                inQuotes = !inQuotes;
                                quoteChar = 0;
                            }
                        } else {
                            if (c == '#' || (c == '-' && (i + 1) < this.statementLength && sql.charAt(i + 1) == '-')) {
                                // run out to end of statement, or newline, whichever comes first
                                int endOfStmt = this.statementLength - 1;

                                for (; i < endOfStmt; i++) {
                                    c = sql.charAt(i);

                                    if (c == '\r' || c == '\n') {
                                        break;
                                    }
                                }

                                continue;
                            } else if (c == '/' && (i + 1) < this.statementLength) {
                                // Comment?
                                char cNext = sql.charAt(i + 1);

                                if (cNext == '*') {
                                    i += 2;

                                    for (int j = i; j < this.statementLength; j++) {
                                        i++;
                                        cNext = sql.charAt(j);

                                        if (cNext == '*' && (j + 1) < this.statementLength) {
                                            if (sql.charAt(j + 1) == '/') {
                                                i++;

                                                if (i < this.statementLength) {
                                                    c = sql.charAt(i);
                                                }

                                                break; // comment done
                                            }
                                        }
                                    }
                                }
                            } else if ((c == '\'') || (c == '"')) {
                                inQuotes = true;
                                quoteChar = c;
                            }
                        }
                    }

                    if ((c == '?') && !inQuotes && !inQuotedId) {
                        endpointList.add(new int[] { lastParmEnd, i });
                        lastParmEnd = i + 1;

                        if (this.isOnDuplicateKeyUpdate && i > this.locationOfOnDuplicateKeyUpdate) {
                            this.parametersInDuplicateKeyClause = true;
                        }
                    }
                }

                if (this.firstStmtChar == 'L') {
                    if (StringUtils.startsWithIgnoreCaseAndWs(sql, "LOAD DATA")) {
                        this.foundLoadData = true;
                    } else {
                        this.foundLoadData = false;
                    }
                } else {
                    this.foundLoadData = false;
                }

                endpointList.add(new int[] { lastParmEnd, this.statementLength });
                this.staticSql = new byte[endpointList.size()][];

                for (i = 0; i < this.staticSql.length; i++) {
                    int[] ep = endpointList.get(i);
                    int end = ep[1];
                    int begin = ep[0];
                    int len = end - begin;

                    if (this.foundLoadData) {
                        this.staticSql[i] = StringUtils.getBytes(sql, begin, len);
                    } else if (encoding == null) {
                        byte[] buf = new byte[len];

                        for (int j = 0; j < len; j++) {
                            buf[j] = (byte) sql.charAt(begin + j);
                        }

                        this.staticSql[i] = buf;
                    } else {
                        if (converter != null) {
                            this.staticSql[i] = StringUtils.getBytes(sql, converter, encoding, conn.getServerCharset(), begin, len, conn.parserKnowsUnicode(),
                                    conn.getExceptionInterceptor());
                        } else {
                            this.staticSql[i] = StringUtils.getBytes(sql, encoding, conn.getServerCharset(), begin, len, conn.parserKnowsUnicode(), conn,
                                    conn.getExceptionInterceptor());
                        }
                    }
                }
            } catch (StringIndexOutOfBoundsException oobEx) {
                SQLException sqlEx = new SQLException("Parse error for " + sql);
                sqlEx.initCause(oobEx);

                throw sqlEx;
            }

            if (buildRewriteInfo) {
                this.canRewriteAsMultiValueInsert = PreparedStatement.canRewrite(sql, this.isOnDuplicateKeyUpdate, this.locationOfOnDuplicateKeyUpdate,
                        this.statementStartPos) && !this.parametersInDuplicateKeyClause;

                if (this.canRewriteAsMultiValueInsert && conn.getRewriteBatchedStatements()) {
                    buildRewriteBatchedParams(sql, conn, dbmd, encoding, converter);
                }
            }
        }

        private ParseInfo batchHead;

        private ParseInfo batchValues;

        private ParseInfo batchODKUClause;

        private void buildRewriteBatchedParams(String sql, MySQLConnection conn, DatabaseMetaData metadata, String encoding,
                SingleByteCharsetConverter converter) throws SQLException {
            this.valuesClause = extractValuesClause(sql, conn.getMetaData().getIdentifierQuoteString());
            String odkuClause = this.isOnDuplicateKeyUpdate ? sql.substring(this.locationOfOnDuplicateKeyUpdate) : null;

            String headSql = null;

            if (this.isOnDuplicateKeyUpdate) {
                headSql = sql.substring(0, this.locationOfOnDuplicateKeyUpdate);
            } else {
                headSql = sql;
            }

            this.batchHead = new ParseInfo(headSql, conn, metadata, encoding, converter, false);
            this.batchValues = new ParseInfo("," + this.valuesClause, conn, metadata, encoding, converter, false);
            this.batchODKUClause = null;

            if (odkuClause != null && odkuClause.length() > 0) {
                this.batchODKUClause = new ParseInfo("," + this.valuesClause + " " + odkuClause, conn, metadata, encoding, converter, false);
            }
        }

        private String extractValuesClause(String sql, String quoteCharStr) throws SQLException {
            int indexOfValues = -1;
            int valuesSearchStart = this.statementStartPos;

            while (indexOfValues == -1) {
                if (quoteCharStr.length() > 0) {
                    indexOfValues = StringUtils.indexOfIgnoreCase(valuesSearchStart, sql, "VALUES", quoteCharStr, quoteCharStr,
                            StringUtils.SEARCH_MODE__MRK_COM_WS);
                } else {
                    indexOfValues = StringUtils.indexOfIgnoreCase(valuesSearchStart, sql, "VALUES");
                }

                if (indexOfValues > 0) {
                    /* check if the char immediately preceding VALUES may be part of the table name */
                    char c = sql.charAt(indexOfValues - 1);
                    if (!(Character.isWhitespace(c) || c == ')' || c == '`')) {
                        valuesSearchStart = indexOfValues + 6;
                        indexOfValues = -1;
                    } else {
                        /* check if the char immediately following VALUES may be whitespace or open parenthesis */
                        c = sql.charAt(indexOfValues + 6);
                        if (!(Character.isWhitespace(c) || c == '(')) {
                            valuesSearchStart = indexOfValues + 6;
                            indexOfValues = -1;
                        }
                    }
                } else {
                    break;
                }
            }

            if (indexOfValues == -1) {
                return null;
            }

            int indexOfFirstParen = sql.indexOf('(', indexOfValues + 6);

            if (indexOfFirstParen == -1) {
                return null;
            }

            int endOfValuesClause = sql.lastIndexOf(')');

            if (endOfValuesClause == -1) {
                return null;
            }

            if (this.isOnDuplicateKeyUpdate) {
                endOfValuesClause = this.locationOfOnDuplicateKeyUpdate - 1;
            }

            return sql.substring(indexOfFirstParen, endOfValuesClause + 1);
        }

        /**
         * Returns a ParseInfo for a multi-value INSERT for a batch of size numBatch (without parsing!).
         */
        synchronized ParseInfo getParseInfoForBatch(int numBatch) {
            AppendingBatchVisitor apv = new AppendingBatchVisitor();
            buildInfoForBatch(numBatch, apv);

            ParseInfo batchParseInfo = new ParseInfo(apv.getStaticSqlStrings(), this.firstStmtChar, this.foundLoadData, this.isOnDuplicateKeyUpdate,
                    this.locationOfOnDuplicateKeyUpdate, this.statementLength, this.statementStartPos);

            return batchParseInfo;
        }

        /**
         * Returns a preparable SQL string for the number of batched parameters, used by server-side prepared statements
         * when re-writing batch INSERTs.
         */

        String getSqlForBatch(int numBatch) throws UnsupportedEncodingException {
            ParseInfo batchInfo = getParseInfoForBatch(numBatch);

            return getSqlForBatch(batchInfo);
        }

        /**
         * Used for filling in the SQL for getPreparedSql() - for debugging
         */
        String getSqlForBatch(ParseInfo batchInfo) throws UnsupportedEncodingException {
            int size = 0;
            final byte[][] sqlStrings = batchInfo.staticSql;
            final int sqlStringsLength = sqlStrings.length;

            for (int i = 0; i < sqlStringsLength; i++) {
                size += sqlStrings[i].length;
                size++; // for the '?'
            }

            StringBuilder buf = new StringBuilder(size);

            for (int i = 0; i < sqlStringsLength - 1; i++) {
                buf.append(StringUtils.toString(sqlStrings[i], this.charEncoding));
                buf.append("?");
            }

            buf.append(StringUtils.toString(sqlStrings[sqlStringsLength - 1]));

            return buf.toString();
        }

        /**
         * Builds a ParseInfo for the given batch size, without parsing. We use
         * a visitor pattern here, because the if {}s make computing a size for the
         * resultant byte[][] make this too complex, and we don't necessarily want to
         * use a List for this, because the size can be dynamic, and thus we'll not be
         * able to guess a good initial size for an array-based list, and it's not
         * efficient to convert a LinkedList to an array.
         */
        private void buildInfoForBatch(int numBatch, BatchVisitor visitor) {
            final byte[][] headStaticSql = this.batchHead.staticSql;
            final int headStaticSqlLength = headStaticSql.length;

            if (headStaticSqlLength > 1) {
                for (int i = 0; i < headStaticSqlLength - 1; i++) {
                    visitor.append(headStaticSql[i]).increment();
                }
            }

            // merge end of head, with beginning of a value clause
            byte[] endOfHead = headStaticSql[headStaticSqlLength - 1];
            final byte[][] valuesStaticSql = this.batchValues.staticSql;
            byte[] beginOfValues = valuesStaticSql[0];

            visitor.merge(endOfHead, beginOfValues).increment();

            int numValueRepeats = numBatch - 1; // first one is in the "head"

            if (this.batchODKUClause != null) {
                numValueRepeats--; // Last one is in the ODKU clause
            }

            final int valuesStaticSqlLength = valuesStaticSql.length;
            byte[] endOfValues = valuesStaticSql[valuesStaticSqlLength - 1];

            for (int i = 0; i < numValueRepeats; i++) {
                for (int j = 1; j < valuesStaticSqlLength - 1; j++) {
                    visitor.append(valuesStaticSql[j]).increment();
                }
                visitor.merge(endOfValues, beginOfValues).increment();
            }

            if (this.batchODKUClause != null) {
                final byte[][] batchOdkuStaticSql = this.batchODKUClause.staticSql;
                byte[] beginOfOdku = batchOdkuStaticSql[0];
                visitor.decrement().merge(endOfValues, beginOfOdku).increment();

                final int batchOdkuStaticSqlLength = batchOdkuStaticSql.length;

                if (numBatch > 1) {
                    for (int i = 1; i < batchOdkuStaticSqlLength; i++) {
                        visitor.append(batchOdkuStaticSql[i]).increment();
                    }
                } else {
                    visitor.decrement().append(batchOdkuStaticSql[(batchOdkuStaticSqlLength - 1)]);
                }
            } else {
                // Everything after the values clause, but not ODKU, which today is nothing but a syntax error, but we should still not mangle the SQL!
                visitor.decrement().append(this.staticSql[this.staticSql.length - 1]);
            }
        }

        private ParseInfo(byte[][] staticSql, char firstStmtChar, boolean foundLoadData, boolean isOnDuplicateKeyUpdate, int locationOfOnDuplicateKeyUpdate,
                int statementLength, int statementStartPos) {
            this.firstStmtChar = firstStmtChar;
            this.foundLoadData = foundLoadData;
            this.isOnDuplicateKeyUpdate = isOnDuplicateKeyUpdate;
            this.locationOfOnDuplicateKeyUpdate = locationOfOnDuplicateKeyUpdate;
            this.statementLength = statementLength;
            this.statementStartPos = statementStartPos;
            this.staticSql = staticSql;
        }
    }

    interface BatchVisitor {
        abstract BatchVisitor increment();

        abstract BatchVisitor decrement();

        abstract BatchVisitor append(byte[] values);

        abstract BatchVisitor merge(byte[] begin, byte[] end);
    }

    static class AppendingBatchVisitor implements BatchVisitor {
        LinkedList statementComponents = new LinkedList();

        public BatchVisitor append(byte[] values) {
            this.statementComponents.addLast(values);

            return this;
        }

        public BatchVisitor increment() {
            // no-op
            return this;
        }

        public BatchVisitor decrement() {
            this.statementComponents.removeLast();

            return this;
        }

        public BatchVisitor merge(byte[] front, byte[] back) {
            int mergedLength = front.length + back.length;
            byte[] merged = new byte[mergedLength];
            System.arraycopy(front, 0, merged, 0, front.length);
            System.arraycopy(back, 0, merged, front.length, back.length);
            this.statementComponents.addLast(merged);
            return this;
        }

        public byte[][] getStaticSqlStrings() {
            byte[][] asBytes = new byte[this.statementComponents.size()][];
            this.statementComponents.toArray(asBytes);

            return asBytes;
        }

        @Override
        public String toString() {
            StringBuilder buf = new StringBuilder();
            Iterator iter = this.statementComponents.iterator();
            while (iter.hasNext()) {
                buf.append(StringUtils.toString(iter.next()));
            }

            return buf.toString();
        }

    }

    private final static byte[] HEX_DIGITS = new byte[] { (byte) '0', (byte) '1', (byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6', (byte) '7',
            (byte) '8', (byte) '9', (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F' };

    /**
     * Reads length bytes from reader into buf. Blocks until enough input is
     * available
     * 
     * @param reader
     * @param buf
     * @param length
     * 
     * @throws IOException
     */
    protected static int readFully(Reader reader, char[] buf, int length) throws IOException {
        int numCharsRead = 0;

        while (numCharsRead < length) {
            int count = reader.read(buf, numCharsRead, length - numCharsRead);

            if (count < 0) {
                break;
            }

            numCharsRead += count;
        }

        return numCharsRead;
    }

    /**
     * Does the batch (if any) contain "plain" statements added by
     * Statement.addBatch(String)?
     * 
     * If so, we can't re-write it to use multi-value or multi-queries.
     */
    protected boolean batchHasPlainStatements = false;

    private java.sql.DatabaseMetaData dbmd = null;

    /**
     * What is the first character of the prepared statement (used to check for
     * SELECT vs. INSERT/UPDATE/DELETE)
     */
    protected char firstCharOfStmt = 0;

    /** Is this query a LOAD DATA query? */
    protected boolean isLoadDataQuery = false;

    protected boolean[] isNull = null;

    private boolean[] isStream = null;

    protected int numberOfExecutions = 0;

    /** The SQL that was passed in to 'prepare' */
    protected String originalSql = null;

    /** The number of parameters in this PreparedStatement */
    protected int parameterCount;

    protected MysqlParameterMetadata parameterMetaData;

    private InputStream[] parameterStreams = null;

    private byte[][] parameterValues = null;

    /**
     * Only used by statement interceptors at the moment to
     * provide introspection of bound values
     */
    protected int[] parameterTypes = null;

    protected ParseInfo parseInfo;

    private java.sql.ResultSetMetaData pstmtResultMetaData;

    private byte[][] staticSqlStrings = null;

    private byte[] streamConvertBuf = null;

    private int[] streamLengths = null;

    private SimpleDateFormat tsdf = null;

    private SimpleDateFormat ddf;

    private SimpleDateFormat tdf;

    /**
     * Are we using a version of MySQL where we can use 'true' boolean values?
     */
    protected boolean useTrueBoolean = false;

    protected boolean usingAnsiMode;

    protected String batchedValuesClause;

    private boolean doPingInstead;

    private boolean compensateForOnDuplicateKeyUpdate = false;

    /** Charset encoder used to escape if needed, such as Yen sign in SJIS */
    private CharsetEncoder charsetEncoder;

    /** Command index of currently executing batch command. */
    protected int batchCommandIndex = -1;

    protected boolean serverSupportsFracSecs;

    /**
     * Creates a prepared statement instance -- We need to provide factory-style
     * methods so we can support both JDBC3 (and older) and JDBC4 runtimes,
     * otherwise the class verifier complains when it tries to load JDBC4-only
     * interface classes that are present in JDBC4 method signatures.
     */

    protected static PreparedStatement getInstance(MySQLConnection conn, String catalog) throws SQLException {
        if (!Util.isJdbc4()) {
            return new PreparedStatement(conn, catalog);
        }

        return (PreparedStatement) Util.handleNewInstance(JDBC_4_PSTMT_2_ARG_CTOR, new Object[] { conn, catalog }, conn.getExceptionInterceptor());
    }

    /**
     * Creates a prepared statement instance -- We need to provide factory-style
     * methods so we can support both JDBC3 (and older) and JDBC4 runtimes,
     * otherwise the class verifier complains when it tries to load JDBC4-only
     * interface classes that are present in JDBC4 method signatures.
     */

    protected static PreparedStatement getInstance(MySQLConnection conn, String sql, String catalog) throws SQLException {
        if (!Util.isJdbc4()) {
            return new PreparedStatement(conn, sql, catalog);
        }

        return (PreparedStatement) Util.handleNewInstance(JDBC_4_PSTMT_3_ARG_CTOR, new Object[] { conn, sql, catalog }, conn.getExceptionInterceptor());
    }

    /**
     * Creates a prepared statement instance -- We need to provide factory-style
     * methods so we can support both JDBC3 (and older) and JDBC4 runtimes,
     * otherwise the class verifier complains when it tries to load JDBC4-only
     * interface classes that are present in JDBC4 method signatures.
     */

    protected static PreparedStatement getInstance(MySQLConnection conn, String sql, String catalog, ParseInfo cachedParseInfo) throws SQLException {
        if (!Util.isJdbc4()) {
            return new PreparedStatement(conn, sql, catalog, cachedParseInfo);
        }

        return (PreparedStatement) Util.handleNewInstance(JDBC_4_PSTMT_4_ARG_CTOR, new Object[] { conn, sql, catalog, cachedParseInfo },
                conn.getExceptionInterceptor());
    }

    /**
     * Constructor used by server-side prepared statements
     * 
     * @param conn
     *            the connection that created us
     * @param catalog
     *            the catalog in use when we were created
     * 
     * @throws SQLException
     *             if an error occurs
     */
    public PreparedStatement(MySQLConnection conn, String catalog) throws SQLException {
        super(conn, catalog);

        detectFractionalSecondsSupport();
        this.compensateForOnDuplicateKeyUpdate = this.connection.getCompensateOnDuplicateKeyUpdateCounts();
    }

    protected void detectFractionalSecondsSupport() throws SQLException {
        this.serverSupportsFracSecs = this.connection != null && this.connection.versionMeetsMinimum(5, 6, 4);
    }

    /**
     * Constructor for the PreparedStatement class.
     * 
     * @param conn
     *            the connection creating this statement
     * @param sql
     *            the SQL for this statement
     * @param catalog
     *            the catalog/database this statement should be issued against
     * 
     * @throws SQLException
     *             if a database error occurs.
     */
    public PreparedStatement(MySQLConnection conn, String sql, String catalog) throws SQLException {
        super(conn, catalog);

        if (sql == null) {
            throw SQLError.createSQLException(Messages.getString("PreparedStatement.0"), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
        }

        detectFractionalSecondsSupport();
        this.originalSql = sql;

        this.doPingInstead = this.originalSql.startsWith(PING_MARKER);

        this.dbmd = this.connection.getMetaData();

        this.useTrueBoolean = this.connection.versionMeetsMinimum(3, 21, 23);

        this.parseInfo = new ParseInfo(sql, this.connection, this.dbmd, this.charEncoding, this.charConverter);

        initializeFromParseInfo();

        this.compensateForOnDuplicateKeyUpdate = this.connection.getCompensateOnDuplicateKeyUpdateCounts();

        if (conn.getRequiresEscapingEncoder()) {
            this.charsetEncoder = Charset.forName(conn.getEncoding()).newEncoder();
        }
    }

    /**
     * Creates a new PreparedStatement object.
     * 
     * @param conn
     *            the connection creating this statement
     * @param sql
     *            the SQL for this statement
     * @param catalog
     *            the catalog/database this statement should be issued against
     * @param cachedParseInfo
     *            already created parseInfo.
     * 
     * @throws SQLException
     */
    public PreparedStatement(MySQLConnection conn, String sql, String catalog, ParseInfo cachedParseInfo) throws SQLException {
        super(conn, catalog);

        if (sql == null) {
            throw SQLError.createSQLException(Messages.getString("PreparedStatement.1"), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
        }

        detectFractionalSecondsSupport();
        this.originalSql = sql;

        this.dbmd = this.connection.getMetaData();

        this.useTrueBoolean = this.connection.versionMeetsMinimum(3, 21, 23);

        this.parseInfo = cachedParseInfo;

        this.usingAnsiMode = !this.connection.useAnsiQuotedIdentifiers();

        initializeFromParseInfo();

        this.compensateForOnDuplicateKeyUpdate = this.connection.getCompensateOnDuplicateKeyUpdateCounts();

        if (conn.getRequiresEscapingEncoder()) {
            this.charsetEncoder = Charset.forName(conn.getEncoding()).newEncoder();
        }
    }

    /**
     * JDBC 2.0 Add a set of parameters to the batch.
     * 
     * @exception SQLException
     *                if a database-access error occurs.
     * 
     * @see StatementImpl#addBatch
     */
    public void addBatch() throws SQLException {
        synchronized (checkClosed().getConnectionMutex()) {
            if (this.batchedArgs == null) {
                this.batchedArgs = new ArrayList