How to use

fastpath

method

in

org.postgresql.fastpath.Fastpath

/**
 * This convenience method assumes that the return value is not an Integer.
 *
 * @param name Function name
 * @param args Function arguments
 * @return byte[] array containing result
 * @throws SQLException if a database-access error occurs or no result
 */
public byte[] getData(String name, FastpathArg[] args) throws SQLException {
 return fastpath(name, args);
}

/**
 * This convenience method assumes that the return value is not an Integer
 * @param name Function name
 * @param args Function arguments
 * @return byte[] array containing result
 * @exception SQLException if a database-access error occurs or no result
 */
public byte[] getData(String name, FastpathArg[] args) throws SQLException
{
  return (byte[])fastpath(name, false, args);
}

/**
 * This deletes a large object.
 *
 * @param oid describing object to delete
 * @throws SQLException on error
 */
public void delete(long oid) throws SQLException {
 FastpathArg[] args = new FastpathArg[1];
 args[0] = Fastpath.createOIDArg(oid);
 fp.fastpath("lo_unlink", args);
}

/**
 * This deletes a large object.
 *
 * @param oid describing object to delete
 * @exception SQLException on error
 */
public void delete(long oid) throws SQLException
{
  FastpathArg args[] = new FastpathArg[1];
  args[0] = Fastpath.createOIDArg(oid);
  fp.fastpath("lo_unlink", false, args);
}

/**
 * This convenience method assumes that the return value is an Integer
 * @param name Function name
 * @param args Function arguments
 * @return integer result
 * @exception SQLException if a database-access error occurs or no result
 */
public int getInteger(String name, FastpathArg[] args) throws SQLException
{
  Integer i = (Integer)fastpath(name, true, args);
  if (i == null)
    throw new PSQLException(GT.tr("Fastpath call {0} - No result was returned and we expected an integer.", name),
                PSQLState.NO_DATA);
  return i.intValue();
}

/**
 * @param name Function name
 * @param resulttype True if the result is a numeric (Integer or Long)
 * @param args FastpathArguments to pass to fastpath
 * @return null if no data, Integer if an integer result, Long if a long result, or byte[]
 *         otherwise
 * @throws SQLException if something goes wrong
 * @see #fastpath(int, FastpathArg[])
 * @see #fastpath(String, FastpathArg[])
 * @deprecated Use {@link #getData(String, FastpathArg[])} if you expect a binary result, or one
 *             of {@link #getInteger(String, FastpathArg[])} or
 *             {@link #getLong(String, FastpathArg[])} if you expect a numeric one
 */
@Deprecated
public Object fastpath(String name, boolean resulttype, FastpathArg[] args) throws SQLException {
 connection.getLogger().log(Level.FINEST, "Fastpath: calling {0}", name);
 return fastpath(getID(name), resulttype, args);
}

/**
 * Writes an array to the object.
 *
 * @param buf array to write
 * @throws SQLException if a database-access error occurs.
 */
public void write(byte[] buf) throws SQLException {
 FastpathArg[] args = new FastpathArg[2];
 args[0] = new FastpathArg(fd);
 args[1] = new FastpathArg(buf);
 fp.fastpath("lowrite", args);
}

/**
 * Writes some data from an array to the object.
 *
 * @param buf destination array
 * @param off offset within array
 * @param len number of bytes to write
 * @throws SQLException if a database-access error occurs.
 */
public void write(byte[] buf, int off, int len) throws SQLException {
 FastpathArg[] args = new FastpathArg[2];
 args[0] = new FastpathArg(fd);
 args[1] = new FastpathArg(buf, off, len);
 fp.fastpath("lowrite", args);
}

/**
 * Writes an array to the object
 *
 * @param buf array to write
 * @exception SQLException if a database-access error occurs.
 */
public void write(byte buf[]) throws SQLException
{
  FastpathArg args[] = new FastpathArg[2];
  args[0] = new FastpathArg(fd);
  args[1] = new FastpathArg(buf);
  fp.fastpath("lowrite", false, args);
}

/**
 * <p>Send a function call to the PostgreSQL backend by name.</p>
 *
 * <p>Note: the mapping for the procedure name to function id needs to exist, usually to an earlier
 * call to addfunction().</p>
 *
 * <p>This is the preferred method to call, as function id's can/may change between versions of the
 * backend.</p>
 *
 * <p>For an example of how this works, refer to org.postgresql.largeobject.LargeObject</p>
 *
 * @param name Function name
 * @param args FastpathArguments to pass to fastpath
 * @return null if no data, byte[] otherwise
 * @throws SQLException if name is unknown or if a database-access error occurs.
 * @see org.postgresql.largeobject.LargeObject
 */
public byte[] fastpath(String name, FastpathArg[] args) throws SQLException {
 connection.getLogger().log(Level.FINEST, "Fastpath: calling {0}", name);
 return fastpath(getID(name), args);
}

/**
 * Writes some data from an array to the object
 *
 * @param buf destination array
 * @param off offset within array
 * @param len number of bytes to write
 * @exception SQLException if a database-access error occurs.
 */
public void write(byte buf[], int off, int len) throws SQLException
{
  FastpathArg args[] = new FastpathArg[2];
  args[0] = new FastpathArg(fd);
  args[1] = new FastpathArg(buf, off, len);
  fp.fastpath("lowrite", false, args);
}

/**
 * Sets the current position within the object using 64-bit value (9.3+).
 *
 * @param pos position within object
 * @param ref Either SEEK_SET, SEEK_CUR or SEEK_END
 * @throws SQLException if a database-access error occurs.
 */
public void seek64(long pos, int ref) throws SQLException {
 FastpathArg[] args = new FastpathArg[3];
 args[0] = new FastpathArg(fd);
 args[1] = new FastpathArg(pos);
 args[2] = new FastpathArg(ref);
 fp.fastpath("lo_lseek64", args);
}

/**
 * <p>Sets the current position within the object.</p>
 *
 * <p>This is similar to the fseek() call in the standard C library. It allows you to have random
 * access to the large object.</p>
 *
 * @param pos position within object
 * @param ref Either SEEK_SET, SEEK_CUR or SEEK_END
 * @throws SQLException if a database-access error occurs.
 */
public void seek(int pos, int ref) throws SQLException {
 FastpathArg[] args = new FastpathArg[3];
 args[0] = new FastpathArg(fd);
 args[1] = new FastpathArg(pos);
 args[2] = new FastpathArg(ref);
 fp.fastpath("lo_lseek", args);
}

/**
 * Sets the current position within the object.
 *
 * <p>This is similar to the fseek() call in the standard C library. It
 * allows you to have random access to the large object.
 *
 * @param pos position within object
 * @param ref Either SEEK_SET, SEEK_CUR or SEEK_END
 * @exception SQLException if a database-access error occurs.
 */
public void seek(int pos, int ref) throws SQLException
{
  FastpathArg args[] = new FastpathArg[3];
  args[0] = new FastpathArg(fd);
  args[1] = new FastpathArg(pos);
  args[2] = new FastpathArg(ref);
  fp.fastpath("lo_lseek", false, args);
}

/**
 * Send a function call to the PostgreSQL backend.
 *
 * @param fnId Function id
 * @param resultType True if the result is a numeric (Integer or Long)
 * @param args FastpathArguments to pass to fastpath
 * @return null if no data, Integer if an integer result, Long if a long result, or byte[]
 *         otherwise
 * @throws SQLException if a database-access error occurs.
 * @deprecated please use {@link #fastpath(int, FastpathArg[])}
 */
@Deprecated
public Object fastpath(int fnId, boolean resultType, FastpathArg[] args) throws SQLException {
 // Run it.
 byte[] returnValue = fastpath(fnId, args);
 // Interpret results.
 if (!resultType || returnValue == null) {
  return returnValue;
 }
 if (returnValue.length == 4) {
  return ByteConverter.int4(returnValue, 0);
 } else if (returnValue.length == 8) {
  return ByteConverter.int8(returnValue, 0);
 } else {
  throw new PSQLException(
    GT.tr("Fastpath call {0} - No result was returned and we expected a numeric.", fnId),
    PSQLState.NO_DATA);
 }
}

fp.fastpath("lo_close", false, args); // true here as we dont care!!
closed = true;

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

/**
 * This convenience method assumes that the return value is an integer.
 *
 * @param name Function name
 * @param args Function arguments
 * @return integer result
 * @throws SQLException if a database-access error occurs or no result
 */
public int getInteger(String name, FastpathArg[] args) throws SQLException {
 byte[] returnValue = fastpath(name, args);
 if (returnValue == null) {
  throw new PSQLException(
    GT.tr("Fastpath call {0} - No result was returned and we expected an integer.", name),
    PSQLState.NO_DATA);
 }
 if (returnValue.length == 4) {
  return ByteConverter.int4(returnValue, 0);
 } else {
  throw new PSQLException(GT.tr(
    "Fastpath call {0} - No result was returned or wrong size while expecting an integer.",
    name), PSQLState.NO_DATA);
 }
}

/**
 * This convenience method assumes that the return value is a long (bigint).
 *
 * @param name Function name
 * @param args Function arguments
 * @return long result
 * @throws SQLException if a database-access error occurs or no result
 */
public long getLong(String name, FastpathArg[] args) throws SQLException {
 byte[] returnValue = fastpath(name, args);
 if (returnValue == null) {
  throw new PSQLException(
    GT.tr("Fastpath call {0} - No result was returned and we expected a long.", name),
    PSQLState.NO_DATA);
 }
 if (returnValue.length == 8) {
  return ByteConverter.int8(returnValue, 0);
 } else {
  throw new PSQLException(
    GT.tr("Fastpath call {0} - No result was returned or wrong size while expecting a long.",
      name),
    PSQLState.NO_DATA);
 }
}

/**
 * Send a function call to the PostgreSQL backend by name.
 *
 * Note: the mapping for the procedure name to function id needs to exist,
 * usually to an earlier call to addfunction().
 *
 * This is the prefered method to call, as function id's can/may change
 * between versions of the backend.
 *
 * For an example of how this works, refer to org.postgresql.largeobject.LargeObject
 *
 * @param name Function name
 * @param resulttype True if the result is an integer, false for other
 * results
 * @param args FastpathArguments to pass to fastpath
 * @return null if no data, Integer if an integer result, or byte[] otherwise
 * @exception SQLException if name is unknown or if a database-access error
 * occurs.
 * @see org.postgresql.largeobject.LargeObject
 */
public Object fastpath(String name, boolean resulttype, FastpathArg[] args) throws SQLException
{
  if (connection.getLogger().logDebug())
    connection.getLogger().debug("Fastpath: calling " + name);
  return fastpath(getID(name), resulttype, args);
}