congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
BlobOutputStream
Code IndexAdd Tabnine to your IDE (free)

How to use
BlobOutputStream
in
org.postgresql.largeobject

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

origin: org.postgresql/postgresql

 /**
  * <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;
 }
}
origin: org.postgresql/postgresql

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());
 }
}
origin: org.postgresql/postgresql

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());
 }
}
origin: org.postgresql/postgresql

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

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());
  }
}
origin: postgresql/postgresql

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

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());
  }
}
origin: org.postgresql/postgresql

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

os.flush();
origin: postgresql/postgresql

/**
 * 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;
}
origin: org.ancoron.postgresql/org.postgresql.osgi

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());
  }
}
origin: postgresql/postgresql

/**
 * 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());
  }
}
origin: org.postgresql/postgresql

/**
 * 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();
  }
 }
}
origin: org.ancoron.postgresql/org.postgresql

/**
 * 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;
}
origin: org.ancoron.postgresql/org.postgresql

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());
  }
}
origin: org.ancoron.postgresql/org.postgresql

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());
  }
}
origin: org.ancoron.postgresql/org.postgresql.osgi

/**
 * 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());
    }
  }
}
origin: org.ancoron.postgresql/org.postgresql.osgi

/**
 * 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;
}
origin: org.ancoron.postgresql/org.postgresql.osgi

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());
  }
}
origin: org.ancoron.postgresql/org.postgresql

/**
 * 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());
    }
  }
}
org.postgresql.largeobjectBlobOutputStream

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

  • Reading from database using SQL prepared statement
  • getSystemService (Context)
  • setContentView (Activity)
  • startActivity (Activity)
  • Pointer (com.sun.jna)
    An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
  • File (java.io)
    An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • System (java.lang)
    Provides access to system-related information and resources including standard input and output. Ena
  • URL (java.net)
    A Uniform Resource Locator that identifies the location of an Internet resource as specified by RFC
  • Collections (java.util)
    This class consists exclusively of static methods that operate on or return collections. It contains
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now