How to use

BlobOutputStream

in

org.postgresql.largeobject

 /**
  * <p>Returns an {@link OutputStream} to this object.</p>
  *
  * <p>This OutputStream can then be used in any method that requires an OutputStream.</p>
  *
  * @return {@link OutputStream} from this object
  * @throws SQLException if a database-access error occurs.
  */
 public OutputStream getOutputStream() throws SQLException {
  if (os == null) {
   os = new BlobOutputStream(this, 4096);
  }
  return os;
 }
}

public void write(byte[] buf, int off, int len) throws java.io.IOException {
 checkClosed();
 try {
  // If we have any internally buffered data, send it first
  if (bpos > 0) {
   flush();
  }
  if (off == 0 && len == buf.length) {
   lo.write(buf); // save a buffer creation and copy since full buffer written
  } else {
   lo.write(buf, off, len);
  }
 } catch (SQLException se) {
  throw new IOException(se.toString());
 }
}

public void write(int b) throws java.io.IOException {
 checkClosed();
 try {
  if (bpos >= bsize) {
   lo.write(buf);
   bpos = 0;
  }
  buf[bpos++] = (byte) b;
 } catch (SQLException se) {
  throw new IOException(se.toString());
 }
}

public void close() throws IOException {
 if (lo != null) {
  try {
   flush();
   lo.close();
   lo = null;
  } catch (SQLException se) {
   throw new IOException(se.toString());
  }
 }
}

public void write(int b) throws java.io.IOException
{
  checkClosed();
  try
  {
    if (bpos >= bsize)
    {
      lo.write(buf);
      bpos = 0;
    }
    buf[bpos++] = (byte)b;
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * Closes this output stream and releases any system resources
 * associated with this stream. The general contract of <code>close</code>
 * is that it closes the output stream. A closed stream cannot perform
 * output operations and cannot be reopened.
 * <p>
 * The <code>close</code> method of <code>OutputStream</code> does nothing.
 *
 * @exception  IOException if an I/O error occurs.
 */
public void close() throws IOException
{
  if (lo != null) {
    try
    {
      flush();
      lo.close();
      lo = null;
    }
    catch (SQLException se)
    {
      throw new IOException(se.toString());
    }
  }
}

public void write(byte[] buf, int off, int len) throws java.io.IOException
{
  checkClosed();
  try
  {
    // If we have any internally buffered data, send it first
    if ( bpos > 0 )
      flush();
    if ( off == 0 && len == buf.length )
      lo.write(buf); // save a buffer creation and copy since full buffer written
    else
      lo.write(buf, off, len);
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * Flushes this output stream and forces any buffered output bytes to be written out. The general
 * contract of <code>flush</code> is that calling it is an indication that, if any bytes
 * previously written have been buffered by the implementation of the output stream, such bytes
 * should immediately be written to their intended destination.
 *
 * @throws IOException if an I/O error occurs.
 */
public void flush() throws IOException {
 checkClosed();
 try {
  if (bpos > 0) {
   lo.write(buf, 0, bpos);
  }
  bpos = 0;
 } catch (SQLException se) {
  throw new IOException(se.toString());
 }
}

os.flush();

/**
 * Returns an OutputStream to this object.
 *
 * <p>This OutputStream can then be used in any method that requires an
 * OutputStream.
 *
 * @exception SQLException if a database-access error occurs.
 */
public OutputStream getOutputStream() throws SQLException
{
  if (os == null)
    os = new BlobOutputStream(this, 4096);
  return os;
}

public void write(byte[] buf, int off, int len) throws java.io.IOException
{
  checkClosed();
  try
  {
    // If we have any internally buffered data, send it first
    if ( bpos > 0 )
      flush();
    if ( off == 0 && len == buf.length )
      lo.write(buf); // save a buffer creation and copy since full buffer written
    else
      lo.write(buf, off, len);
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * Flushes this output stream and forces any buffered output bytes
 * to be written out. The general contract of <code>flush</code> is
 * that calling it is an indication that, if any bytes previously
 * written have been buffered by the implementation of the output
 * stream, such bytes should immediately be written to their
 * intended destination.
 *
 * @exception  IOException if an I/O error occurs.
 */
public void flush() throws IOException
{
  checkClosed();
  try
  {
    if (bpos > 0)
      lo.write(buf, 0, bpos);
    bpos = 0;
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * This method closes the object. You must not call methods in this object after this is called.
 *
 * @throws SQLException if a database-access error occurs.
 */
public void close() throws SQLException {
 if (!closed) {
  // flush any open output streams
  if (os != null) {
   try {
    // we can't call os.close() otherwise we go into an infinite loop!
    os.flush();
   } catch (IOException ioe) {
    throw new PSQLException("Exception flushing output stream", PSQLState.DATA_ERROR, ioe);
   } finally {
    os = null;
   }
  }
  // finally close
  FastpathArg[] args = new FastpathArg[1];
  args[0] = new FastpathArg(fd);
  fp.fastpath("lo_close", args); // true here as we dont care!!
  closed = true;
  if (this.commitOnClose) {
   this.conn.commit();
  }
 }
}

/**
 * Returns an OutputStream to this object.
 *
 * <p>This OutputStream can then be used in any method that requires an
 * OutputStream.
 *
 * @exception SQLException if a database-access error occurs.
 */
public OutputStream getOutputStream() throws SQLException
{
  if (os == null)
    os = new BlobOutputStream(this, 4096);
  return os;
}

public void write(byte[] buf, int off, int len) throws java.io.IOException
{
  checkClosed();
  try
  {
    // If we have any internally buffered data, send it first
    if ( bpos > 0 )
      flush();
    if ( off == 0 && len == buf.length )
      lo.write(buf); // save a buffer creation and copy since full buffer written
    else
      lo.write(buf, off, len);
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

public void write(int b) throws java.io.IOException
{
  checkClosed();
  try
  {
    if (bpos >= bsize)
    {
      lo.write(buf);
      bpos = 0;
    }
    buf[bpos++] = (byte)b;
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * Closes this output stream and releases any system resources
 * associated with this stream. The general contract of <code>close</code>
 * is that it closes the output stream. A closed stream cannot perform
 * output operations and cannot be reopened.
 * <p>
 * The <code>close</code> method of <code>OutputStream</code> does nothing.
 *
 * @exception  IOException if an I/O error occurs.
 */
public void close() throws IOException
{
  if (lo != null) {
    try
    {
      flush();
      lo.close();
      lo = null;
    }
    catch (SQLException se)
    {
      throw new IOException(se.toString());
    }
  }
}

/**
 * Returns an OutputStream to this object.
 *
 * <p>This OutputStream can then be used in any method that requires an
 * OutputStream.
 *
 * @exception SQLException if a database-access error occurs.
 */
public OutputStream getOutputStream() throws SQLException
{
  if (os == null)
    os = new BlobOutputStream(this, 4096);
  return os;
}

public void write(int b) throws java.io.IOException
{
  checkClosed();
  try
  {
    if (bpos >= bsize)
    {
      lo.write(buf);
      bpos = 0;
    }
    buf[bpos++] = (byte)b;
  }
  catch (SQLException se)
  {
    throw new IOException(se.toString());
  }
}

/**
 * Closes this output stream and releases any system resources
 * associated with this stream. The general contract of <code>close</code>
 * is that it closes the output stream. A closed stream cannot perform
 * output operations and cannot be reopened.
 * <p>
 * The <code>close</code> method of <code>OutputStream</code> does nothing.
 *
 * @exception  IOException if an I/O error occurs.
 */
public void close() throws IOException
{
  if (lo != null) {
    try
    {
      flush();
      lo.close();
      lo = null;
    }
    catch (SQLException se)
    {
      throw new IOException(se.toString());
    }
  }
}