"com.mysql.jdbc.PacketTooBigException": Help needed urgently

Question

hi,
I am using mm.mysql j/connector ver 3.0.6 and MYSQL server version 4.0.
Max_allowed packet= 8MB at the server side
I am getting PacketTooBigException when i am trying to update a particular column.
What should i do.
Any help will be greatly appreciated!!!

Answer 1

the driver uses a 64 k max packet size by default. it is supposed to change this as neccessary upon connection but perhaps that is failing?
below is the 3.0.7 connection code that i have slightly modified for you so that it prints out the connection properties after they have been initialized so that you can see what they are.
try it out and i hope you find this helpful.
   Copyright (C) 2002 MySQL AB
      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; either version 2 of the License, or
      (at your option) any later version.
      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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
/*Slight Modification by Max Stocker April 29, 2003 to trace what the connection values get initialized to. */
package com.mysql.jdbc;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ParameterMetaData;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.Savepoint;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.TimeZone;
* A Connection represents a session with a specific database.  Within the
* context of a Connection, SQL statements are executed and results are
* returned.
* <P>A Connection's database is able to provide information describing
* its tables, its supported SQL grammar, its stored procedures, the
* capabilities of this connection, etc.  This information is obtained
* with the getMetaData method.
* @see java.sql.Connection
* @author Mark Matthews
* @version $Id: Connection.java,v 1.31.2.19 2003/03/28 22:42:24 mmatthew Exp $
public class Connection implements java.sql.Connection {
    // The command used to "ping" the database.
    // Newer versions of MySQL server have a ping() command,
    // but this works for everything
    private static final String PING_COMMAND = "SELECT 1";
     * Map mysql transaction isolation level name to
     * java.sql.Connection.TRANSACTION_XXX
    private static Map mapTransIsolationName2Value = null;
     * The mapping between MySQL charset names
     * and Java charset names.
     * Initialized by loadCharacterSetMapping()
    private static Map charsetMap;
     * Table of multi-byte charsets.
     * Initialized by loadCharacterSetMapping()
    private static Map multibyteCharsetsMap;
     * Default socket factory classname
    private static final String DEFAULT_SOCKET_FACTORY = StandardSocketFactory.class
        .getName();
    static {
        loadCharacterSetMapping();
        mapTransIsolationName2Value = new HashMap(8);
        mapTransIsolationName2Value.put("READ-UNCOMMITED",
            new Integer(TRANSACTION_READ_UNCOMMITTED));
          mapTransIsolationName2Value.put("READ-UNCOMMITTED",
               new Integer(TRANSACTION_READ_UNCOMMITTED));
        mapTransIsolationName2Value.put("READ-COMMITTED",
            new Integer(TRANSACTION_READ_COMMITTED));
        mapTransIsolationName2Value.put("REPEATABLE-READ",
            new Integer(TRANSACTION_REPEATABLE_READ));
        mapTransIsolationName2Value.put("SERIALIZABLE",
            new Integer(TRANSACTION_SERIALIZABLE));
     * Internal DBMD to use for various database-version
     * specific features
    private DatabaseMetaData dbmd = null;
     * The list of host(s) to try and connect to
    private List hostList = null;
      * A map of statements that have had setMaxRows() called on them
     private Map statementsUsingMaxRows;
     * The I/O abstraction interface (network conn to
     * MySQL server
    private MysqlIO io = null;
     * Mutex
    private final Object mutex = new Object();
     * The driver instance that created us
    private NonRegisteringDriver myDriver;
     * The map of server variables that we retrieve
     * at connection init.
    private Map serverVariables = null;
     * Properties for this connection specified by user
    private Properties props = null;
     * The database we're currently using
     * (called Catalog in JDBC terms).
    private String database = null;
     * If we're doing unicode character conversions,
     * what encoding do we use?
    private String encoding = null;
     * The hostname we're connected to
    private String host = null;
     * The JDBC URL we're using
    private String myURL = null;
     * The password we used
    private String password = null;
     * Classname for socket factory
    private String socketFactoryClassName = null;
     * The user we're connected as
    private String user = null;
     * The timezone of the server
    private TimeZone serverTimezone = null;
     * Allow LOAD LOCAL INFILE (defaults to true)
    private boolean allowLoadLocalInfile = true;
     * Are we in autoCommit mode?
    private boolean autoCommit = true;
     * Should we capitalize mysql types
    private boolean capitalizeDBMDTypes = false;
     * Should we continue processing batch commands if
     * one fails. The JDBC spec allows either way, so
     * we let the user choose
    private boolean continueBatchOnError = true;
     * Should we do unicode character conversions?
    private boolean doUnicode = false;
     * Are we failed-over to a non-master host
    private boolean failedOver = false;
    /** Does the server suuport isolation levels? */
    private boolean hasIsolationLevels = false;
     * Does this version of MySQL support quoted identifiers?
    private boolean hasQuotedIdentifiers = false;
    // This is for the high availability :) routines
    private boolean highAvailability = false;
     * Has this connection been closed?
    private boolean isClosed = true;
     * Should we tell MySQL that we're an interactive client?
    private boolean isInteractiveClient = false;
     * Is the server configured to use lower-case
     * table names only?
    private boolean lowerCaseTableNames = false;
     * Has the max-rows setting been changed from
     * the default?
    private boolean maxRowsChanged = false;
     * Do we expose sensitive information in exception
     * and error messages?
    private boolean paranoid = false;
     * Should we do 'extra' sanity checks?
    private boolean pedantic = false;
     * Are we in read-only mode?
    private boolean readOnly = false;
    /** Do we relax the autoCommit semantics? (For enhydra, for example) */
    private boolean relaxAutoCommit = false;
     * Do we need to correct endpoint rounding errors
    private boolean strictFloatingPoint = false;
     * Do we check all keys for updatable result sets?
    private boolean strictUpdates = true;
    /** Are transactions supported by the MySQL server we are connected to? */
    private boolean transactionsSupported = false;
     * Has ANSI_QUOTES been enabled on the server?
    private boolean useAnsiQuotes = false;
     * Should we use compression?
    private boolean useCompression = false;
     * Can we use the "ping" command rather than a
     * query?
    private boolean useFastPing = false;
     * Should we tack on @hostname in DBMD.getTable/ColumnPrivileges()?
    private boolean useHostsInPrivileges = true;
     * Should we use SSL?
    private boolean useSSL = false;
     * Should we use stream lengths in prepared statements?
     * (true by default == JDBC compliant)
    private boolean useStreamLengthsInPrepStmts = true;
     * Should we use timezone information?
    private boolean useTimezone = false;
    /** Should we return PreparedStatements for UltraDev's stupid bug? */
    private boolean useUltraDevWorkAround = false;
    private double initialTimeout = 2.0D;
     * How many hosts are in the host list?
    private int hostListSize = 0;
     * isolation level
    private int isolationLevel = java.sql.Connection.TRANSACTION_READ_COMMITTED;
     * The largest packet we can send (changed
     * once we know what the server supports, we
     * get this at connection init).
    private int maxAllowedPacket = 65536;
    private int maxReconnects = 3;
     * The max rows that a result set can contain.
     * Defaults to -1, which according to the JDBC
     * spec means "all".
    private int maxRows = -1;
    private int netBufferLength = 16384;
     * The port number we're connected to
     * (defaults to 3306)
    private int port = 3306;
     * How many queries should we wait before we try to re-connect
     * to the master, when we are failing over to replicated hosts
     * Defaults to 50
    private int queriesBeforeRetryMaster = 50;
     * What should we set the socket timeout to?
    private int socketTimeout = 0; // infinite
     * When did the last query finish?
    private long lastQueryFinishedTime = 0;
     * When did the master fail?
    private long masterFailTimeMillis = 0L;
     * Number of queries we've issued since the master
     * failed
    private long queriesIssuedFailedOver = 0;
     * How many seconds should we wait before retrying to connect
     * to the master if failed over? We fall back when either
     * queriesBeforeRetryMaster or secondsBeforeRetryMaster is
     * reached.
    private long secondsBeforeRetryMaster = 30L;
     * The type map for UDTs (not implemented, but used by
     * some third-party vendors, most notably IBM WebSphere)
    private Map typeMap;
     * Ignore non-transactional table warning for rollback?
    private boolean ignoreNonTxTables = false;
     * Creates a connection to a MySQL Server.
     * @param host the hostname of the database server
     * @param port the port number the server is listening on
     * @param info a Properties[] list holding the user and password
     * @param database the database to connect to
     * @param url the URL of the connection
     * @param d the Driver instantation of the connection
     * @exception java.sql.SQLException if a database access error occurs
    Connection(String host, int port, Properties info, String database,
        String url, NonRegisteringDriver d) throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = { host, new Integer(port), info, database, url, d };
            Debug.methodCall(this, "constructor", args);
        this.serverVariables = new HashMap();
        hostList = new ArrayList();
        if (host == null) {
            this.host = "localhost";
            hostList.add(this.host);
        } else if (host.indexOf(",") != -1) {
            // multiple hosts separated by commas (failover)
            StringTokenizer hostTokenizer = new StringTokenizer(host, ",", false);
            while (hostTokenizer.hasMoreTokens()) {
                hostList.add(hostTokenizer.nextToken().trim());
        } else {
            this.host = host;
            hostList.add(this.host);
        hostListSize = hostList.size();
        this.port = port;
        if (database == null) {
            throw new SQLException("Malformed URL '" + url + "'.", "S1000");
        this.database = database;
        this.myURL = url;
        this.myDriver = d;
        this.user = info.getProperty("user");
        this.password = info.getProperty("password");
        if ((this.user == null) || this.user.equals("")) {
            this.user = "nobody";
        if (this.password == null) {
            this.password = "";
        this.props = info;
        initializeDriverProperties(info);
        if (Driver.DEBUG) {
            System.out.println("Connect: " + this.user + " to " + this.database);
        try {
            createNewIO(false);
            this.dbmd = new DatabaseMetaData(this, this.database);
        } catch (java.sql.SQLException ex) {
            cleanup();
            // don't clobber SQL exceptions
            throw ex;
        } catch (Exception ex) {
            cleanup();
            StringBuffer mesg = new StringBuffer();
            if (!useParanoidErrorMessages()) {
                mesg.append("Cannot connect to MySQL server on ");
                mesg.append(this.host);
                mesg.append(":");
                mesg.append(this.port);
                mesg.append(".\n\n");
                mesg.append("Make sure that there is a MySQL server ");
                mesg.append("running on the machine/port you are trying ");
                mesg.append(
                    "to connect to and that the machine this software is "
                    + "running on ");
                mesg.append("is able to connect to this host/port "
                    + "(i.e. not firewalled). ");
                mesg.append(
                    "Also make sure that the server has not been started "
                    + "with the --skip-networking ");
                mesg.append("flag.\n\n");
            } else {
                mesg.append("Unable to connect to database.");
            mesg.append("Underlying exception: \n\n");
            mesg.append(ex.getClass().getName());
            throw new java.sql.SQLException(mesg.toString(), "08S01");
     * If a connection is in auto-commit mode, than all its SQL
     * statements will be executed and committed as individual
     * transactions.  Otherwise, its SQL statements are grouped
     * into transactions that are terminated by either commit()
     * or rollback().  By default, new connections are in auto-
     * commit mode.  The commit occurs when the statement completes
     * or the next execute occurs, whichever comes first.  In the
     * case of statements returning a ResultSet, the statement
     * completes when the last row of the ResultSet has been retrieved
     * or the ResultSet has been closed.  In advanced cases, a single
     * statement may return multiple results as well as output parameter
     * values.  Here the commit occurs when all results and output param
     * values have been retrieved.
     * <p><b>Note:</b> MySQL does not support transactions, so this
     *                 method is a no-op.
     * @param autoCommit - true enables auto-commit; false disables it
     * @exception java.sql.SQLException if a database access error occurs
    public void setAutoCommit(boolean autoCommit) throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = { new Boolean(autoCommit) };
            Debug.methodCall(this, "setAutoCommit", args);
        checkClosed();
        if (this.transactionsSupported) {
            // this internal value must be set first as failover depends on it
            // being set to true to fail over (which is done by most
            // app servers and connection pools at the end of
            // a transaction), and the driver issues an implicit set
            // based on this value when it (re)-connects to a server
            // so the value holds across connections
            this.autoCommit = autoCommit;
            String sql = "SET autocommit=" + (autoCommit ? "1" : "0");
            execSQL(sql, -1, this.database);
        } else {
            if ((autoCommit == false) && (this.relaxAutoCommit == false)) {
                throw new SQLException("MySQL Versions Older than 3.23.15 "
                    + "do not support transactions", "08003");
            } else {
                this.autoCommit = autoCommit;
        return;
     * gets the current auto-commit state
     * @return Current state of the auto-commit mode
     * @exception java.sql.SQLException (why?)
     * @see setAutoCommit
    public boolean getAutoCommit() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "getAutoCommit", args);
            Debug.returnValue(this, "getAutoCommit",
                new Boolean(this.autoCommit));
        return this.autoCommit;
     * A sub-space of this Connection's database may be selected by
     * setting a catalog name.  If the driver does not support catalogs,
     * it will silently ignore this request
     * <p><b>Note:</b> MySQL's notion of catalogs are individual databases.
     * @param catalog the database for this connection to use
     * @throws java.sql.SQLException if a database access error occurs
    public void setCatalog(String catalog) throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = { catalog };
            Debug.methodCall(this, "setCatalog", args);
        checkClosed();
        String quotedId = this.dbmd.getIdentifierQuoteString();
        if ((quotedId == null) || quotedId.equals(" ")) {
            quotedId = "";
        StringBuffer query = new StringBuffer("USE ");
        query.append(quotedId);
        query.append(catalog);
        query.append(quotedId);
        execSQL(query.toString(), -1, catalog);
        this.database = catalog;
     * Return the connections current catalog name, or null if no
     * catalog name is set, or we dont support catalogs.
     * <p><b>Note:</b> MySQL's notion of catalogs are individual databases.
     * @return the current catalog name or null
     * @exception java.sql.SQLException if a database access error occurs
    public String getCatalog() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "getCatalog", args);
            Debug.returnValue(this, "getCatalog", this.database);
        return this.database;
     * DOCUMENT ME!
     * @return DOCUMENT ME!
    public boolean isClosed() {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "isClosed", args);
            Debug.returnValue(this, "isClosed", new Boolean(this.isClosed));
        return this.isClosed;
     * Returns the character encoding for this Connection
     * @return the character encoding for this connection.
    public String getEncoding() {
        return this.encoding;
     * @see Connection#setHoldability(int)
    public void setHoldability(int arg0) throws SQLException {
        // do nothing
     * @see Connection#getHoldability()
    public int getHoldability() throws SQLException {
        return ResultSet.CLOSE_CURSORS_AT_COMMIT;
     * NOT JDBC-Compliant, but clients can use this method
     * to determine how long this connection has been idle.
     * This time (reported in milliseconds) is updated once
     * a query has completed.
     * @return number of ms that this connection has
     * been idle, 0 if the driver is busy retrieving results.
    public long getIdleFor() {
        if (this.lastQueryFinishedTime == 0) {
            return 0;
        } else {
            long now = System.currentTimeMillis();
            long idleTime = now - this.lastQueryFinishedTime;
            return idleTime;
     * Should we tell MySQL that we're an interactive client
     * @return true if isInteractiveClient was set to true.
    public boolean isInteractiveClient() {
        return isInteractiveClient;
     * A connection's database is able to provide information describing
     * its tables, its supported SQL grammar, its stored procedures, the
     * capabilities of this connection, etc.  This information is made
     * available through a DatabaseMetaData object.
     * @return a DatabaseMetaData object for this connection
     * @exception java.sql.SQLException if a database access error occurs
    public java.sql.DatabaseMetaData getMetaData() throws java.sql.SQLException {
        checkClosed();
        return new DatabaseMetaData(this, this.database);
     * You can put a connection in read-only mode as a hint to enable
     * database optimizations
     * <B>Note:</B> setReadOnly cannot be called while in the middle
     * of a transaction
     * @param readOnly - true enables read-only mode; false disables it
     * @exception java.sql.SQLException if a database access error occurs
    public void setReadOnly(boolean readOnly) throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = { new Boolean(readOnly) };
            Debug.methodCall(this, "setReadOnly", args);
            Debug.returnValue(this, "setReadOnly", new Boolean(readOnly));
        checkClosed();
        this.readOnly = readOnly;
     * Tests to see if the connection is in Read Only Mode.  Note that
     * we cannot really put the database in read only mode, but we pretend
     * we can by returning the value of the readOnly flag
     * @return true if the connection is read only
     * @exception java.sql.SQLException if a database access error occurs
    public boolean isReadOnly() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "isReadOnly", args);
            Debug.returnValue(this, "isReadOnly", new Boolean(this.readOnly));
        return this.readOnly;
     * @see Connection#setSavepoint()
    public java.sql.Savepoint setSavepoint() throws SQLException {
        throw new NotImplemented();
     * @see Connection#setSavepoint(String)
    public java.sql.Savepoint setSavepoint(String arg0)
        throws SQLException {
        throw new NotImplemented();
     * DOCUMENT ME!
     * @return DOCUMENT ME!
    public TimeZone getServerTimezone() {
        return this.serverTimezone;
     * DOCUMENT ME!
     * @param level DOCUMENT ME!
     * @throws java.sql.SQLException DOCUMENT ME!
    public void setTransactionIsolation(int level) throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = { new Integer(level) };
            Debug.methodCall(this, "setTransactionIsolation", args);
        checkClosed();
        if (this.hasIsolationLevels) {
            StringBuffer sql = new StringBuffer(
                    "SET SESSION TRANSACTION ISOLATION LEVEL ");
            switch (level) {
            case java.sql.Connection.TRANSACTION_NONE:
                throw new SQLException("Transaction isolation level "
                    + "NONE not supported by MySQL");
            case java.sql.Connection.TRANSACTION_READ_COMMITTED:
                sql.append("READ COMMITTED");
                break;
            case java.sql.Connection.TRANSACTION_READ_UNCOMMITTED:
                sql.append("READ UNCOMMITTED");
                break;
            case java.sql.Connection.TRANSACTION_REPEATABLE_READ:
                sql.append("REPEATABLE READ");
                break;
            case java.sql.Connection.TRANSACTION_SERIALIZABLE:
                sql.append("SERIALIZABLE");
                break;
            default:
                throw new SQLException("Unsupported transaction "
                    + "isolation level '" + level + "'", "S1C00");
            execSQL(sql.toString(), -1, this.database);
            isolationLevel = level;
        } else {
            throw new java.sql.SQLException("Transaction Isolation Levels are "
                + "not supported on MySQL versions older than 3.23.36.", "S1C00");
     * Get this Connection's current transaction isolation mode.
     * @return the current TRANSACTION_* mode value
     * @exception java.sql.SQLException if a database access error occurs
    public int getTransactionIsolation() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "getTransactionIsolation", args);
            Debug.returnValue(this, "getTransactionIsolation",
                new Integer(isolationLevel));
        if (this.hasIsolationLevels) {
             java.sql.Statement stmt = null;
             java.sql.ResultSet rs = null;
             try {
                  stmt = this.createStatement();
                  String query = null;
                  if (this.io.versionMeetsMinimum(4, 0, 3)) {
                       query = "SHOW VARIABLES LIKE 'tx_isolation'";
                  } else {
                       query = "SHOW VARIABLES LIKE 'transaction_isolation'";
                  rs = stmt.executeQuery(query);
                  if (rs.next()) {
                       String s = rs.getString(2);
                       if (s != null) {
                              Integer intTI = (Integer) mapTransIsolationName2Value.get(s);
                              if (intTI != null) {
                                   return intTI.intValue();
                       throw new SQLException("Could not map transaction isolation '" + s + " to a valid JDBC level.", "S1000");
                  } else {
                       throw new SQLException("Could not retrieve transaction isolation level from server", "S1000");
             } finally {
                  if (rs != null) {
                       try {
                            rs.close();
                       } catch (Exception ex) {
                            // ignore
                       rs = null;
                  if (stmt != null) {
                       try {
                            stmt.close();
                       } catch (Exception ex) {
                            // ignore
                       stmt = null;
        return isolationLevel;
     * JDBC 2.0
     * Install a type-map object as the default type-map for
     * this connection
     * @param map the type mapping
     * @throws SQLException if a database error occurs.
    public void setTypeMap(java.util.Map map) throws SQLException {
        this.typeMap = map;
     * JDBC 2.0
     * Get the type-map object associated with this connection.
     * By default, the map returned is empty.
     * @return the type map
     * @throws SQLException if a database error occurs
    public synchronized java.util.Map getTypeMap() throws SQLException {
        if (this.typeMap == null) {
            this.typeMap = new HashMap();
        return this.typeMap;
     * The first warning reported by calls on this Connection is
     * returned.
     * <B>Note:</B> Sebsequent warnings will be changed to this
     * java.sql.SQLWarning
     * @return the first java.sql.SQLWarning or null
     * @exception java.sql.SQLException if a database access error occurs
    public java.sql.SQLWarning getWarnings() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "getWarnings", args);
            Debug.returnValue(this, "getWarnings", null);
        return null;
     * Allow use of LOAD LOCAL INFILE?
     * @return true if allowLoadLocalInfile was set to true.
    public boolean allowLoadLocalInfile() {
        return this.allowLoadLocalInfile;
     * DOCUMENT ME!
     * @return DOCUMENT ME!
    public boolean capitalizeDBMDTypes() {
        return this.capitalizeDBMDTypes;
     * After this call, getWarnings returns null until a new warning
     * is reported for this connection.
     * @exception java.sql.SQLException if a database access error occurs
    public void clearWarnings() throws java.sql.SQLException {
        if (Driver.TRACE) {
            Object[] args = new Object[0];
            Debug.methodCall(this, "clearWarnings", args);
        // firstWarning = null;
     * In some cases, it is desirable to immediately release a Connection's
     * database and JDBC resources instead of waiting for them to be
     * automatically released (