Blob.java
上传用户:tanyanyong
上传日期:2013-06-23
资源大小:1355k
文件大小:7k
源码类别:

电子政务应用

开发平台:

MultiPlatform

  1. /*
  2.    Copyright (C) 2002 MySQL AB
  3.       This program is free software; you can redistribute it and/or modify
  4.       it under the terms of the GNU General Public License as published by
  5.       the Free Software Foundation; either version 2 of the License, or
  6.       (at your option) any later version.
  7.       This program is distributed in the hope that it will be useful,
  8.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.       GNU General Public License for more details.
  11.       You should have received a copy of the GNU General Public License
  12.       along with this program; if not, write to the Free Software
  13.       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14.  */
  15. package com.mysql.jdbc;
  16. import java.io.ByteArrayInputStream;
  17. import java.io.IOException;
  18. import java.io.OutputStream;
  19. import java.sql.SQLException;
  20. /**
  21.  * The representation (mapping) in the JavaTM programming language  of an SQL
  22.  * BLOB value. An SQL BLOB is a built-in type that stores  a Binary Large
  23.  * Object as a column value in a row of a database  table. The driver
  24.  * implements Blob using an SQL locator(BLOB),  which means that a Blob object
  25.  * contains a logical pointer to the  SQL BLOB data rather than the data
  26.  * itself. A Blob object is valid  for the duration of the transaction in
  27.  * which is was created.   Methods in the interfaces ResultSet,
  28.  * CallableStatement, and  PreparedStatement, such as getBlob and setBlob
  29.  * allow a programmer  to access an SQL BLOB value. The Blob interface
  30.  * provides methods  for getting the length of an SQL BLOB (Binary Large
  31.  * Object) value,  for materializing a BLOB value on the client, and for
  32.  * determining  the position of a pattern of bytes within a BLOB value.   This
  33.  * class is new in the JDBC 2.0 API.
  34.  *
  35.  * @author Mark Matthews
  36.  *
  37.  * @version $Id: Blob.java,v 1.9.2.6 2003/12/24 05:16:26 mmatthew Exp $
  38.  */
  39. public class Blob implements java.sql.Blob, OutputStreamWatcher {
  40.     //~ Instance fields --------------------------------------------------------
  41.     /** The ResultSet that created this BLOB */
  42.     private ResultSet creatorResultSet;
  43.     //
  44.     // This is a real brain-dead implementation of BLOB. Once I add
  45.     // streamability to the I/O for MySQL this will be more efficiently
  46.     // implemented (except for the position() method, ugh).
  47.     //
  48.     /** The binary data that makes up this BLOB */
  49.     private byte[] binaryData = null;
  50.     /** The column that this BLOB came from */
  51.     private int columnIndex;
  52.     //~ Constructors -----------------------------------------------------------
  53.     /**
  54.      * Creates a BLOB encapsulating the given binary data
  55.      */
  56.     Blob(byte[] data) {
  57.         setBinaryData(data);
  58.         this.creatorResultSet = null;
  59.         this.columnIndex = 0;
  60.     }
  61.     /**
  62.      * Creates an updatable BLOB that can update in-place
  63.      * (not implemented yet).
  64.      */
  65.     Blob(byte[] data, ResultSet creatorResultSet, int columnIndex) {
  66.         setBinaryData(data);
  67.         this.creatorResultSet = creatorResultSet;
  68.         this.columnIndex = columnIndex;
  69.     }
  70.     //~ Methods ----------------------------------------------------------------
  71.     /**
  72.      * @see Blob#setBinaryStream(long)
  73.      */
  74.     public OutputStream setBinaryStream(long indexToWriteAt)
  75.         throws SQLException {
  76.         if (indexToWriteAt < 1) {
  77.             throw new SQLException("indexToWriteAt must be >= 1", SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
  78.         }
  79.         WatchableOutputStream bytesOut = new WatchableOutputStream();
  80.         bytesOut.setWatcher(this);
  81.         if (indexToWriteAt > 0) {
  82.             bytesOut.write(this.binaryData, 0, (int) (indexToWriteAt - 1));
  83.         }
  84.         return bytesOut;
  85.     }
  86.     /**
  87.      * Retrieves the BLOB designated by this Blob instance as a stream.
  88.      *
  89.      * @return this BLOB represented as a binary stream of bytes.
  90.      *
  91.      * @throws SQLException if a database error occurs
  92.      */
  93.     public java.io.InputStream getBinaryStream() throws SQLException {
  94.         return new ByteArrayInputStream(getBinaryData());
  95.     }
  96.     /**
  97.      * @see Blob#setBytes(long, byte[], int, int)
  98.      */
  99.     public int setBytes(long writeAt, byte[] bytes, int offset, int length)
  100.         throws SQLException {
  101.         OutputStream bytesOut = setBinaryStream(writeAt);
  102.         try {
  103.             bytesOut.write(bytes, offset, length);
  104.         } catch (IOException ioEx) {
  105.             throw new SQLException("IO Error while writing bytes to blob",
  106.                 SQLError.SQL_STATE_GENERAL_ERROR);
  107.         } finally {
  108.             try {
  109.                 bytesOut.close();
  110.             } catch (IOException doNothing) {
  111.                 ; // do nothing
  112.             }
  113.         }
  114.         return length;
  115.     }
  116.     /**
  117.      * @see Blob#setBytes(long, byte[])
  118.      */
  119.     public int setBytes(long writeAt, byte[] bytes) throws SQLException {
  120.         return setBytes(writeAt, bytes, 0, bytes.length);
  121.     }
  122.     /**
  123.      * Returns as an array of bytes, part or all of the BLOB value that this
  124.      * Blob object designates.
  125.      *
  126.      * @param pos where to start the part of the BLOB
  127.      * @param length the length of the part of the BLOB you want returned.
  128.      *
  129.      * @return the bytes stored in the blob starting at position
  130.      *         <code>pos</code> and having a length of <code>length</code>.
  131.      *
  132.      * @throws SQLException if a database error occurs
  133.      */
  134.     public byte[] getBytes(long pos, int length) throws SQLException {
  135.         if (pos < 1) {
  136.             throw new SQLException("Position 'pos' can not be < 1", SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
  137.         }
  138.         byte[] newData = new byte[length];
  139.         System.arraycopy(getBinaryData(), (int) (pos - 1), newData, 0, length);
  140.         return newData;
  141.     }
  142.     /**
  143.      * Returns the number of bytes in the BLOB value designated by this Blob
  144.      * object.
  145.      *
  146.      * @return the length of this blob
  147.      *
  148.      * @throws SQLException if a database error occurs
  149.      */
  150.     public long length() throws SQLException {
  151.         return getBinaryData().length;
  152.     }
  153.     /**
  154.      * Finds the position of the given pattern in this BLOB.
  155.      *
  156.      * @param pattern the pattern to find
  157.      * @param start where to start finding the pattern
  158.      *
  159.      * @return the position where the pattern is found in the BLOB, -1 if not
  160.      *         found
  161.      *
  162.      * @throws SQLException if a database error occurs
  163.      */
  164.     public long position(java.sql.Blob pattern, long start)
  165.         throws SQLException {
  166.         return position(pattern.getBytes(0, (int) pattern.length()), start);
  167.     }
  168.     /**
  169.      * @see java.sql.Blob#position(byte[], long)
  170.      */
  171.     public long position(byte[] pattern, long start) throws SQLException {
  172.         throw new SQLException("Not implemented");
  173.     }
  174.     /**
  175.      * @see com.mysql.jdbc.OutputStreamWatcher#streamClosed(byte[])
  176.      */
  177.     public void streamClosed(byte[] byteData) {
  178.         this.binaryData = byteData;
  179.     }
  180.     /**
  181.      * @see Blob#truncate(long)
  182.      */
  183.     public void truncate(long arg0) throws SQLException {
  184.         throw new NotImplemented();
  185.     }
  186.     private void setBinaryData(byte[] binaryData) {
  187.         this.binaryData = binaryData;
  188.     }
  189.     private byte[] getBinaryData() {
  190.         return binaryData;
  191.     }
  192. }