Logo Search packages:      
Sourcecode: mysql-connector-java version File versions  Download package

BufferRow.java

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

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, 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 FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  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.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.sql.Date;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.TimeZone;

/**
 * A RowHolder implementation that holds one row packet (which is re-used by the
 * driver, and thus saves memory allocations), and tries when possible to avoid
 * allocations to break out the results as individual byte[]s.
 * 
 * (this isn't possible when doing things like reading floating point values).
 * 
 * @version $Id: $
 */
00052 public class BufferRow extends ResultSetRow {
      private Buffer rowFromServer;

      /**
       * The beginning of the row packet
       */
00058       private int homePosition = 0;
      
      /**
       * The home position before the is-null bitmask for server-side
       * prepared statement result sets
       */
00064       private int preNullBitmaskHomePosition = 0;

      /**
       * The last-requested index, used as an optimization, if you ask for the
       * same index, we won't seek to find it. If you ask for an index that is >
       * than the last one requested, we start seeking from the last requested
       * index.
       */
00072       private int lastRequestedIndex = -1;

      /**
       * The position of the last-requested index, optimization in concert with
       * lastRequestedIndex.
       */
00078       private int lastRequestedPos;

      /**
       * The metadata of the fields of this result set.
       */
00083       private Field[] metadata;

      /**
       * Is this a row from a server-side prepared statement? If so, they're
       * encoded differently, so we have different ways of finding where each
       * column is, and unpacking them.
       */
00090       private boolean isBinaryEncoded;

      /**
       * If binary-encoded, the NULL status of each column is at the beginning of
       * the row, so we
       */
00096       private boolean[] isNull;

      private List openStreams;

      public BufferRow(Buffer buf, Field[] fields, boolean isBinaryEncoded, ExceptionInterceptor exceptionInterceptor)
                  throws SQLException {
            super(exceptionInterceptor);
            
            this.rowFromServer = buf;
            this.metadata = fields;
            this.isBinaryEncoded = isBinaryEncoded;
            this.homePosition = this.rowFromServer.getPosition();
            this.preNullBitmaskHomePosition = this.homePosition;

            if (fields != null) {
                  setMetadata(fields);
            }
      }

00115       public synchronized void closeOpenStreams() {
            if (this.openStreams != null) {
                  // This would've looked slicker in a "for" loop
                  // but we want to skip over streams that fail to
                  // close (they probably won't ever)
                  // to be more robust and close everything we _can_

                  Iterator iter = this.openStreams.iterator();

                  while (iter.hasNext()) {

                        try {
                              ((InputStream) iter.next()).close();
                        } catch (IOException e) {
                              // ignore - it can't really happen in this case
                        }
                  }

                  this.openStreams.clear();
            }
      }

      private int findAndSeekToOffset(int index) throws SQLException {
            if (!this.isBinaryEncoded) {

                  if (index == 0) {
                        this.lastRequestedIndex = 0;
                        this.lastRequestedPos = this.homePosition;
                        this.rowFromServer.setPosition(this.homePosition);

                        return 0;
                  }

                  if (index == this.lastRequestedIndex) {
                        this.rowFromServer.setPosition(this.lastRequestedPos);

                        return this.lastRequestedPos;
                  }

                  int startingIndex = 0;

                  if (index > this.lastRequestedIndex) {
                        if (this.lastRequestedIndex >= 0) {
                              startingIndex = this.lastRequestedIndex;
                        } else {
                              startingIndex = 0;
                        }
                        
                        this.rowFromServer.setPosition(this.lastRequestedPos);
                  } else {
                        this.rowFromServer.setPosition(this.homePosition);
                  }

                  for (int i = startingIndex; i < index; i++) {
                        this.rowFromServer.fastSkipLenByteArray();
                  }

                  this.lastRequestedIndex = index;
                  this.lastRequestedPos = this.rowFromServer.getPosition();

                  return this.lastRequestedPos;
            }

            return findAndSeekToOffsetForBinaryEncoding(index);
      }

      private int findAndSeekToOffsetForBinaryEncoding(int index)
                  throws SQLException {
            if (index == 0) {
                  this.lastRequestedIndex = 0;
                  this.lastRequestedPos = this.homePosition;
                  this.rowFromServer.setPosition(this.homePosition);
                  
                  return 0;
            }

            if (index == this.lastRequestedIndex) {
                  this.rowFromServer.setPosition(this.lastRequestedPos);

                  return this.lastRequestedPos;
            }

            int startingIndex = 0;

            if (index > this.lastRequestedIndex) {
                  if (this.lastRequestedIndex >= 0) {
                        startingIndex = this.lastRequestedIndex;
                  } else {
                        // First-time "scan"
                        startingIndex = 0;
                        this.lastRequestedPos = this.homePosition;
                  }
                  
                  this.rowFromServer.setPosition(this.lastRequestedPos);
            } else {
                  this.rowFromServer.setPosition(this.homePosition);
            }

            for (int i = startingIndex; i < index; i++) {
                  if (this.isNull[i]) {
                        continue;
                  }

                  int curPosition = this.rowFromServer.getPosition();

                  switch (this.metadata[i].getMysqlType()) {
                  case MysqlDefs.FIELD_TYPE_NULL:
                        break; // for dummy binds

                  case MysqlDefs.FIELD_TYPE_TINY:

                        this.rowFromServer.setPosition(curPosition + 1);
                        break;

                  case MysqlDefs.FIELD_TYPE_SHORT:
                  case MysqlDefs.FIELD_TYPE_YEAR:
                        this.rowFromServer.setPosition(curPosition + 2);

                        break;
                  case MysqlDefs.FIELD_TYPE_LONG:
                  case MysqlDefs.FIELD_TYPE_INT24:
                        this.rowFromServer.setPosition(curPosition + 4);

                        break;
                  case MysqlDefs.FIELD_TYPE_LONGLONG:
                        this.rowFromServer.setPosition(curPosition + 8);

                        break;
                  case MysqlDefs.FIELD_TYPE_FLOAT:
                        this.rowFromServer.setPosition(curPosition + 4);

                        break;
                  case MysqlDefs.FIELD_TYPE_DOUBLE:
                        this.rowFromServer.setPosition(curPosition + 8);

                        break;
                  case MysqlDefs.FIELD_TYPE_TIME:
                        this.rowFromServer.fastSkipLenByteArray();

                        break;
                  case MysqlDefs.FIELD_TYPE_DATE:

                        this.rowFromServer.fastSkipLenByteArray();

                        break;
                  case MysqlDefs.FIELD_TYPE_DATETIME:
                  case MysqlDefs.FIELD_TYPE_TIMESTAMP:
                        this.rowFromServer.fastSkipLenByteArray();

                        break;
                  case MysqlDefs.FIELD_TYPE_TINY_BLOB:
                  case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:
                  case MysqlDefs.FIELD_TYPE_LONG_BLOB:
                  case MysqlDefs.FIELD_TYPE_BLOB:
                  case MysqlDefs.FIELD_TYPE_VAR_STRING:
                  case MysqlDefs.FIELD_TYPE_VARCHAR:
                  case MysqlDefs.FIELD_TYPE_STRING:
                  case MysqlDefs.FIELD_TYPE_DECIMAL:
                  case MysqlDefs.FIELD_TYPE_NEW_DECIMAL:
                  case MysqlDefs.FIELD_TYPE_GEOMETRY:
                  case MysqlDefs.FIELD_TYPE_BIT:
                        this.rowFromServer.fastSkipLenByteArray();

                        break;

                  default:
                        throw SQLError.createSQLException(Messages
                                    .getString("MysqlIO.97") //$NON-NLS-1$
                                    + this.metadata[i].getMysqlType()
                                    + Messages.getString("MysqlIO.98")
                                    + (i + 1)
                                    + Messages.getString("MysqlIO.99") //$NON-NLS-1$ //$NON-NLS-2$
                                    + this.metadata.length
                                    + Messages.getString("MysqlIO.100"), //$NON-NLS-1$
                                    SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
                  }
            }

            this.lastRequestedIndex = index;
            this.lastRequestedPos = this.rowFromServer.getPosition();

            return this.lastRequestedPos;
      }

00299       public synchronized InputStream getBinaryInputStream(int columnIndex)
                  throws SQLException {
            if (this.isBinaryEncoded) {
                  if (isNull(columnIndex)) {
                        return null;
                  }
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            if (length == Buffer.NULL_LENGTH) {
                  return null;
            }

            InputStream stream = new ByteArrayInputStream(this.rowFromServer
                        .getByteBuffer(), offset, (int) length);

            if (this.openStreams == null) {
                  this.openStreams = new LinkedList();
            }

            return stream;
      }

00327       public byte[] getColumnValue(int index) throws SQLException {
            findAndSeekToOffset(index);

            if (!this.isBinaryEncoded) {
                  return this.rowFromServer.readLenByteArray(0);
            }

            if (this.isNull[index]) {
                  return null;
            }

            switch (this.metadata[index].getMysqlType()) {
            case MysqlDefs.FIELD_TYPE_NULL:
                  return null;

            case MysqlDefs.FIELD_TYPE_TINY:
                  return new byte[] { this.rowFromServer.readByte() };

            case MysqlDefs.FIELD_TYPE_SHORT:
            case MysqlDefs.FIELD_TYPE_YEAR:
                  return this.rowFromServer.getBytes(2);

            case MysqlDefs.FIELD_TYPE_LONG:
            case MysqlDefs.FIELD_TYPE_INT24:
                  return this.rowFromServer.getBytes(4);

            case MysqlDefs.FIELD_TYPE_LONGLONG:
                  return this.rowFromServer.getBytes(8);

            case MysqlDefs.FIELD_TYPE_FLOAT:
                  return this.rowFromServer.getBytes(4);

            case MysqlDefs.FIELD_TYPE_DOUBLE:
                  return this.rowFromServer.getBytes(8);

            case MysqlDefs.FIELD_TYPE_TIME:
            case MysqlDefs.FIELD_TYPE_DATE:
            case MysqlDefs.FIELD_TYPE_DATETIME:
            case MysqlDefs.FIELD_TYPE_TIMESTAMP:
            case MysqlDefs.FIELD_TYPE_TINY_BLOB:
            case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:
            case MysqlDefs.FIELD_TYPE_LONG_BLOB:
            case MysqlDefs.FIELD_TYPE_BLOB:
            case MysqlDefs.FIELD_TYPE_VAR_STRING:
            case MysqlDefs.FIELD_TYPE_VARCHAR:
            case MysqlDefs.FIELD_TYPE_STRING:
            case MysqlDefs.FIELD_TYPE_DECIMAL:
            case MysqlDefs.FIELD_TYPE_NEW_DECIMAL:
            case MysqlDefs.FIELD_TYPE_GEOMETRY:
            case MysqlDefs.FIELD_TYPE_BIT:
                  return this.rowFromServer.readLenByteArray(0);

            default:
                  throw SQLError.createSQLException(Messages.getString("MysqlIO.97") //$NON-NLS-1$
                              + this.metadata[index].getMysqlType()
                              + Messages.getString("MysqlIO.98")
                              + (index + 1)
                              + Messages.getString("MysqlIO.99") //$NON-NLS-1$ //$NON-NLS-2$
                              + this.metadata.length + Messages.getString("MysqlIO.100"), //$NON-NLS-1$
                              SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
            }
      }

00390       public int getInt(int columnIndex) throws SQLException {

            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            if (length == Buffer.NULL_LENGTH) {
                  return 0;
            }

            return StringUtils.getInt(this.rowFromServer.getByteBuffer(), offset,
                        offset + (int) length);
      }

00406       public long getLong(int columnIndex) throws SQLException {
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();
            
            if (length == Buffer.NULL_LENGTH) {
                  return 0;
            }

            return StringUtils.getLong(this.rowFromServer.getByteBuffer(), offset,
                        offset + (int) length);
      }

      public double getNativeDouble(int columnIndex) throws SQLException {
            if (isNull(columnIndex)) {
                  return 0;
            }
            
            findAndSeekToOffset(columnIndex);
      
            int offset = this.rowFromServer.getPosition();

            return getNativeDouble(this.rowFromServer.getByteBuffer(), offset);
      }

      public float getNativeFloat(int columnIndex) throws SQLException {
            if (isNull(columnIndex)) {
                  return 0;
            }
            
            findAndSeekToOffset(columnIndex);

            int offset = this.rowFromServer.getPosition();

            return getNativeFloat(this.rowFromServer.getByteBuffer(), offset);
      }

      public int getNativeInt(int columnIndex) throws SQLException {
            if (isNull(columnIndex)) {
                  return 0;
            }
            
            findAndSeekToOffset(columnIndex);

            int offset = this.rowFromServer.getPosition();

            return getNativeInt(this.rowFromServer.getByteBuffer(), offset);
      }

      public long getNativeLong(int columnIndex) throws SQLException {
            if (isNull(columnIndex)) {
                  return 0;
            }
            
            findAndSeekToOffset(columnIndex);

            int offset = this.rowFromServer.getPosition();

            return getNativeLong(this.rowFromServer.getByteBuffer(), offset);
      }

      public short getNativeShort(int columnIndex) throws SQLException {
            if (isNull(columnIndex)) {
                  return 0;
            }
            
            findAndSeekToOffset(columnIndex);

            int offset = this.rowFromServer.getPosition();

            return getNativeShort(this.rowFromServer.getByteBuffer(), offset);
      }

      public Timestamp getNativeTimestamp(int columnIndex,
                  Calendar targetCalendar, TimeZone tz, boolean rollForward,
                  MySQLConnection conn, ResultSetImpl rs) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            return getNativeTimestamp(this.rowFromServer.getByteBuffer(), offset,
                        (int) length, targetCalendar, tz, rollForward, conn, rs);
      }

      public Reader getReader(int columnIndex) throws SQLException {
            InputStream stream = getBinaryInputStream(columnIndex);

            if (stream == null) {
                  return null;
            }

            try {
                  return new InputStreamReader(stream, this.metadata[columnIndex]
                              .getCharacterSet());
            } catch (UnsupportedEncodingException e) {
                  SQLException sqlEx = SQLError.createSQLException("", this.exceptionInterceptor);

                  sqlEx.initCause(e);

                  throw sqlEx;
            }
      }

00517       public String getString(int columnIndex, String encoding, MySQLConnection conn)
                  throws SQLException {
            if (this.isBinaryEncoded) {
                  if (isNull(columnIndex)) {
                        return null;
                  }
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();

            if (length == Buffer.NULL_LENGTH) {
                  return null;
            }

            if (length == 0) {
                  return "";
            }

            // TODO: I don't like this, would like to push functionality back
            // to the buffer class somehow

            int offset = this.rowFromServer.getPosition();

            return getString(encoding, conn, this.rowFromServer.getByteBuffer(),
                        offset, (int) length);
      }

      public Time getTimeFast(int columnIndex, Calendar targetCalendar,
                  TimeZone tz, boolean rollForward, MySQLConnection conn,
                  ResultSetImpl rs) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }

            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            return getTimeFast(columnIndex, this.rowFromServer.getByteBuffer(),
                        offset, (int)length, targetCalendar, tz, rollForward, conn, rs);
      }

      public Timestamp getTimestampFast(int columnIndex, Calendar targetCalendar,
                  TimeZone tz, boolean rollForward, MySQLConnection conn,
                  ResultSetImpl rs) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }

            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            return getTimestampFast(columnIndex,
                        this.rowFromServer.getByteBuffer(), offset, (int)length, targetCalendar, tz,
                        rollForward, conn, rs);
      }

00581       public boolean isFloatingPointNumber(int index) throws SQLException {
            if (this.isBinaryEncoded) {
                  switch (this.metadata[index].getSQLType()) {
                  case Types.FLOAT:
                  case Types.DOUBLE:
                  case Types.DECIMAL:
                  case Types.NUMERIC:
                        return true;
                  default:
                        return false;
                  }
            }

            findAndSeekToOffset(index);

            long length = this.rowFromServer.readFieldLength();

            if (length == Buffer.NULL_LENGTH) {
                  return false;
            }

            if (length == 0) {
                  return false;
            }

            int offset = this.rowFromServer.getPosition();
            byte[] buffer = this.rowFromServer.getByteBuffer();
            
            for (int i = 0; i < (int) length; i++) {
                  char c = (char) buffer[offset + i];

                  if ((c == 'e') || (c == 'E')) {
                        return true;
                  }
            }

            return false;
      }

00620       public boolean isNull(int index) throws SQLException {
            if (!this.isBinaryEncoded) {
                  findAndSeekToOffset(index);

                  return this.rowFromServer.readFieldLength() == Buffer.NULL_LENGTH;
            }

            return this.isNull[index];
      }

00630       public long length(int index) throws SQLException {
            findAndSeekToOffset(index);

            long length = this.rowFromServer.readFieldLength();

            if (length == Buffer.NULL_LENGTH) {
                  return 0;
            }

            return length;
      }

00642       public void setColumnValue(int index, byte[] value) throws SQLException {
            throw new OperationNotSupportedException();
      }

      public ResultSetRow setMetadata(Field[] f) throws SQLException {
            super.setMetadata(f);

            if (this.isBinaryEncoded) {
                  setupIsNullBitmask();
            }
            
            return this;
      }

      /**
       * Unpacks the bitmask at the head of the row packet that tells us what
       * columns hold null values, and sets the "home" position directly after the
       * bitmask.
       */
00661       private void setupIsNullBitmask() throws SQLException {
            if (this.isNull != null) {
                  return; // we've already done this
            }
            
            this.rowFromServer.setPosition(this.preNullBitmaskHomePosition);
            
            int nullCount = (this.metadata.length + 9) / 8;

            byte[] nullBitMask = new byte[nullCount];

            for (int i = 0; i < nullCount; i++) {
                  nullBitMask[i] = this.rowFromServer.readByte();
            }

            this.homePosition = this.rowFromServer.getPosition();

            this.isNull = new boolean[this.metadata.length];

            int nullMaskPos = 0;
            int bit = 4; // first two bits are reserved for future use

            for (int i = 0; i < this.metadata.length; i++) {

                  this.isNull[i] = ((nullBitMask[nullMaskPos] & bit) != 0);

                  if (((bit <<= 1) & 255) == 0) {
                        bit = 1; /* To next byte */

                        nullMaskPos++;
                  }
            }
      }

      public Date getDateFast(int columnIndex, MySQLConnection conn,
                  ResultSetImpl rs, Calendar targetCalendar) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }

            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            return getDateFast(columnIndex, this.rowFromServer.getByteBuffer(),
                        offset, (int)length, conn, rs, targetCalendar);
      }

      public java.sql.Date getNativeDate(int columnIndex, MySQLConnection conn,
                  ResultSetImpl rs, Calendar cal) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();
            
            return getNativeDate(columnIndex, this.rowFromServer.getByteBuffer(),
                        offset, (int) length, conn, rs, cal);
      }

      public Object getNativeDateTimeValue(int columnIndex, Calendar targetCalendar,
                  int jdbcType, int mysqlType, TimeZone tz,
                  boolean rollForward, MySQLConnection conn, ResultSetImpl rs)
                  throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();

            return getNativeDateTimeValue(columnIndex, this.rowFromServer
                        .getByteBuffer(), offset, (int) length, targetCalendar, jdbcType,
                        mysqlType, tz, rollForward, conn, rs);
      }

      public Time getNativeTime(int columnIndex, Calendar targetCalendar,
                  TimeZone tz, boolean rollForward, MySQLConnection conn,
                  ResultSetImpl rs) throws SQLException {
            if (isNull(columnIndex)) {
                  return null;
            }
            
            findAndSeekToOffset(columnIndex);

            long length = this.rowFromServer.readFieldLength();
            
            int offset = this.rowFromServer.getPosition();
            
            return getNativeTime(columnIndex, this.rowFromServer.getByteBuffer(),
                        offset, (int) length, targetCalendar, tz, rollForward, conn, rs);
      }

      public int getBytesSize() {
            return this.rowFromServer.getBufLength();
      }
}

Generated by  Doxygen 1.6.0   Back to index