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