org.postgresql.largeobject.BlobOutputStream java code examples

Common ways to obtain BlobOutputStream

private void myMethod () {
 BlobOutputStream b =LargeObject largeObject;new BlobOutputStream(largeObject, int1)
Smart code suggestions by Tabnine
}

 /**
  * <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());
    }
  }
}

Javadoc

This implements a basic output stream that writes to a LargeObject.

Most used methods

<init>
Create an OutputStream to a large object.
checkClosed
flush
Flushes this output stream and forces any buffered output bytes to be written out. The general contr

Popular in Java

Parsing JSON documents to java classes using gson
getSharedPreferences (Context)
onCreateOptionsMenu (Activity)
getApplicationContext (Context)
BigDecimal (java.math)
An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
MessageDigest (java.security)
Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
ConcurrentHashMap (java.util.concurrent)
A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This version is based on or
JButton (javax.swing)
Top 15 Vim Plugins

How to useBlobOutputStream in org.postgresql.largeobject

Best Java code snippets using org.postgresql.largeobject.BlobOutputStream (Showing top 20 results out of 315)

How to use
BlobOutputStream
in
org.postgresql.largeobject