selectresult.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,222 行 · 第 1/2 页

   * Returns the blob value of the given index.
   */
  public Blob getBlob(int index)
    throws SQLException
  {
    _wasNull = false;

    setColumn(index);

    int type = read();
    switch (type) {
    case Column.NONE:
      _wasNull = true;
      return null;

    case Column.BLOB:
      return getBlob();

    default:
      throw new RuntimeException("column can't be retrieved as a blob:" + type + " column:" + index);
    }
  }

  /**
   * Returns the clob value of the given index.
   */
  public Clob getClob(int index)
    throws SQLException
  {
    _wasNull = false;

    setColumn(index);

    int type = read();
    switch (type) {
    case Column.NONE:
      _wasNull = true;
      return null;

    case Column.BLOB:
      return getClob();

    default:
      throw new RuntimeException("column can't be retrieved as a clob:" + type + " column:" + index);
    }
  }

  /**
   * Returns true if the last column read was null.
   */
  public boolean wasNull()
  {
    return _wasNull;
  }

  /**
   * Returns the string value for the result set.
   */
  private String readString()
    throws SQLException
  {
    int length = ((read() << 24) +
		  (read() << 16) +
		  (read() << 8) +
		  (read()));

    int len = length >> 1;

    CharBuffer cb = _cb;
    cb.ensureCapacity(len);
    char []cBuf = cb.getBuffer();
    int cLen = 0;

    for (; len > 0; len--) {
      int ch1 = read();
      int ch2 = read();

      cBuf[cLen++] = (char) (((ch1 & 0xff) << 8) + (ch2 & 0xff));
    }

    return new String(cBuf, 0, cLen);
  }

  /**
   * Returns the blob value for the result set.
   */
  private Blob getBlob()
    throws SQLException
  {
    BlobImpl blob = new BlobImpl();

    blob.setStore(_stores[_column]);

    byte []inode = blob.getInode();

    read(inode, 0, 128);

    return blob;
  }

  /**
   * Returns the clob value for the result set.
   */
  private Clob getClob()
    throws SQLException
  {
    ClobImpl clob = new ClobImpl();

    clob.setStore(_stores[_column]);

    byte []inode = clob.getInode();

    read(inode, 0, 128);

    return clob;
  }

  /**
   * Returns the string value for the result set.
   */
  private String readBlobString()
    throws SQLException
  {
    read(_blob, 0, 128);

    CharBuffer cb = _cb;
    cb.clear();

    BlobInputStream is = null;
    try {
      is = new BlobInputStream(_stores[_column], _blob, 0);

      int ch;
      while ((ch = is.read()) >= 0) {
	if (ch < 0x80)
	  cb.append((char) ch);
      }
    } catch (IOException e) {
      throw new SQLExceptionWrapper(e);
    }

    return cb.toString();
  }

  /**
   * Returns the string value for the result set.
   */
  private byte []readBlobBytes()
    throws SQLException
  {
    read(_blob, 0, 128);

    ByteArrayOutputStream bos = new ByteArrayOutputStream();

    BlobInputStream is = null;
    try {
      is = new BlobInputStream(_stores[_column], _blob, 0);

      int ch;
      while ((ch = is.read()) >= 0) {
	bos.write(ch);
      }
    } catch (IOException e) {
      throw new SQLExceptionWrapper(e);
    }

    return bos.toByteArray();
  }

  /**
   * Set the column in the current row.
   */
  private void setColumn(int column)
  {
    if (column < _column) {
      _offset = _rowOffset;
      skipColumns(column);
    }
    else {
      _offset = _columnOffset;
      skipColumns(column - _column);
    }

    _column = column;
    _columnOffset = _offset;
  }

  /**
   * Set the column in the current row.
   */
  void setRow(int rowOffset)
  {
    _rowOffset = rowOffset;
    _offset = rowOffset;
    _column = 0;
    _columnOffset = rowOffset;
  }

  /**
   * Skips the specified number of columns.
   */
  private void skipColumns(int count)
  {
    for (; count > 0; count--) {
      int type = read();
      int sublen;

      switch (type) {
      case Column.NONE:
	break;
	  
      case Column.VARCHAR:
	int l0 = read();
	int l1 = read();
	int l2 = read();
	int l3 = read();
	
	sublen = ((l0 << 24) +
		  (l1 << 16) +
		  (l2 << 8) +
		  (l3));

	_offset += sublen;
	break;
	  
      case Column.BINARY:
	sublen = read();

	_offset += sublen;
	break;

      case Column.SHORT:
	_offset += 2;
	break;
      case Column.INT:
	_offset += 4;
	break;
      case Column.LONG:
      case Column.DOUBLE:
      case Column.DATE:
	_offset += 8;
	break;
	  
      case Column.BLOB:
	_offset += 128;
	break;
	  
      default:
	throw new RuntimeException("Unknown column type: " + type);
      }
    }
  }

  /**
   * Starts a row
   */
  public void startRow()
  {
    if (_orderIndex != null)
      _orderIndex.add(_length);

    _rowCount++;
  }

  /**
   * Writes a null.
   */
  public void writeNull()
  {
    write(Column.NONE);
  }

  /**
   * Writes a string.
   */
  public void writeString(String s)
  {
    write(Column.VARCHAR);
    int stringLength = s.length();
    int length = 2 * stringLength;
    write(length >> 24);
    write(length >> 16);
    write(length >> 8);
    write(length);

    for (int i = 0; i < stringLength; i++) {
      char ch = s.charAt(i);

      write(ch << 8);
      write(ch);
    }
  }

  /**
   * Writes a string.
   */
  public void writeString(byte []buffer, int offset, int stringLength)
  {
    int rLength = _length;
    
    int rOffset = rLength % SIZE;
    int rBlockId = rLength / SIZE;
    
    if (_buffers[rBlockId] == null) {
      TempBuffer tempBuffer = TempBuffer.allocate();
      _tempBuffers[rBlockId] = tempBuffer;
      _buffers[rBlockId] = tempBuffer.getBuffer();
    }

    byte []rBuffer = _buffers[rBlockId];
    rBuffer[rOffset] = Column.VARCHAR;

    int length = 2 * stringLength;

    if (rOffset + 5 < rBuffer.length) {
      rBuffer[rOffset + 1] = (byte) (length >> 24);
      rBuffer[rOffset + 2] = (byte) (length >> 16);
      rBuffer[rOffset + 3] = (byte) (length >> 8);
      rBuffer[rOffset + 4] = (byte) length;

      if (rOffset + 5 + length < SIZE) {
	System.arraycopy(buffer, offset, rBuffer, rOffset + 5, length);

	_length = rLength + 5 + length;
      }
      else {
	_length = rLength + 5;
	write(buffer, offset, length);
      }
    }
    else {
      _length = rLength + 1;

      write(length >> 24);
      write(length >> 16);
      write(length >> 8);
      write(length);

      write(buffer, offset, length);
    }
  }

  /**
   * Writes a binary.
   */
  public void writeBinary(byte []buffer, int offset, int length)
  {
    write(Column.BINARY);
    write(length);
    write(buffer, offset, length);
  }

  /**
   * Writes a string.
   */
  public void writeBlock(int code, byte []buffer, int offset, int length)
  {
    write(code);
    write(buffer, offset, length);
  }

  /**
   * Writes a double.
   */
  public void writeDouble(double dValue)
  {
    write(Column.DOUBLE);

    long value = Double.doubleToLongBits(dValue);
    
    write((int) (value >> 56));
    write((int) (value >> 48));
    write((int) (value >> 40));
    write((int) (value >> 32));
    write((int) (value >> 24));
    write((int) (value >> 16));
    write((int) (value >> 8));
    write((int) value);
  }

  /**
   * Writes a long.
   */
  public void writeLong(long value)
  {
    write(Column.LONG);
    write((int) (value >> 56));
    write((int) (value >> 48));
    write((int) (value >> 40));
    write((int) (value >> 32));
    write((int) (value >> 24));
    write((int) (value >> 16));
    write((int) (value >> 8));
    write((int) value);
  }

  /**
   * Writes a date.
   */
  public void writeDate(long value)
  {
    write(Column.DATE);
    write((int) (value >> 56));
    write((int) (value >> 48));
    write((int) (value >> 40));
    write((int) (value >> 32));
    write((int) (value >> 24));
    write((int) (value >> 16));
    write((int) (value >> 8));
    write((int) value);
  }

  /**
   * Writes an long.
   */
  public void writeInt(int value)
  {
    write(Column.INT);
    write(value >> 24);
    write(value >> 16);
    write(value >> 8);
    write(value);
  }

  /**
   * Writes a short
   */
  public void writeShort(int value)
  {
    write(Column.SHORT);
    write(value >> 8);
    write(value);
  }

  /**
   * Writes a blob.
   */
  public void writeBlob(byte []buffer, int offset)
  {
    write(Column.BLOB);

    write(buffer, offset, 128);
  }

  /**
   * Seeks the specified offset.
   */
  private void seek(int offset)
  {
    _offset = offset;
  }

  /**
   * Reads the next byte.
   */
  private int read()
  {
    int offset = _offset;
    
    if (_length <= offset)
      return -1;

    _offset = offset + 1;
    
    byte []buf = _buffers[offset / SIZE];

    return buf[offset % SIZE] & 0xff;
  }

  /**
   * Reads the next byte.
   */
  private int read(byte []buffer, int bufOffset, int bufLength)
  {
    int offset = _offset;
    int length = _length;
    byte [][]buffers = _buffers;

    for (int i = bufLength; i > 0; i--) {
      if (length <= offset) {
	_offset = offset;
	return -1;
      }

      byte []buf = buffers[offset / SIZE];

      buffer[bufOffset] = buf[offset % SIZE];
      
      offset++;
      bufOffset++;
    }

    _offset = offset;

    return bufLength;
  }

  /**
   * Writes the next byte.
   */
  public void write(int value)
  {
    int length = _length;
    int rOffset = length % SIZE;
    int blockId = length / SIZE;
    
    byte []buffer = _buffers[blockId];
    
    if (buffer == null) {
      TempBuffer tempBuffer = TempBuffer.allocate();
      _tempBuffers[blockId] = tempBuffer;
      _buffers[blockId] = tempBuffer.getBuffer();

      buffer = _buffers[blockId];
    }

    buffer[rOffset] = (byte) value;

    _length = length + 1;
  }

  /**
   * Writes a buffer
   */
  public void write(byte []buffer, int offset, int length)
  {
    int rLength = _length;
    
    while (length > 0) {
      int rOffset = rLength % SIZE;

      int rBufferId = rLength / SIZE;
      
      if (rOffset == 0) {
	TempBuffer tempBuffer = TempBuffer.allocate();
	if (_tempBuffers.length <= rBufferId) {
	  int len = _tempBuffers.length;
	  
	  TempBuffer []newTempBuffers = new TempBuffer[len + 32];
	  System.arraycopy(_tempBuffers, 0, newTempBuffers, 0, len);
	  _tempBuffers = newTempBuffers;
	  
	  byte [][]newBuffers = new byte[len + 32][];
	  System.arraycopy(_buffers, 0, newBuffers, 0, len);
	  _buffers = newBuffers;

	}
	
	_tempBuffers[rBufferId] = tempBuffer;
	_buffers[rBufferId] = tempBuffer.getBuffer();
      }

      byte []rBuffer = _buffers[rBufferId];

      int sublen = rBuffer.length - rOffset;

      if (length < sublen)
	sublen = length;

      System.arraycopy(buffer, offset, rBuffer, rOffset, sublen);

      length -= sublen;
      offset += sublen;
      rLength += sublen;
    }

    _length = rLength;
  }

  private String toHex(byte []bytes)
  {
    StringBuilder sb = new StringBuilder();
    
    int len = bytes.length;
    for (int i = 0; i < len; i++) {
      int d1 = (bytes[i] >> 4) & 0xf;
      int d2 = (bytes[i]) & 0xf;

      if (d1 < 10)
	sb.append((char) ('0' + d1));
      else
	sb.append((char) ('a' + d1 - 10));

      if (d2 < 10)
	sb.append((char) ('0' + d2));
      else
	sb.append((char) ('a' + d2 - 10));
    }

    return sb.toString();
  }
  
  public void close()
  {
    for (int i = 0; i < _buffers.length; i++) {
      TempBuffer buffer = _tempBuffers[i];

      if (buffer != null)
	TempBuffer.free(buffer);

      _tempBuffers[i] = null;
      _buffers[i] = null;
    }

    _order = null;
    _orderIndex = null;
    
    _freeList.free(this);
  }
}