How to use

Fastpath

in

org.postgresql.fastpath

public Fastpath getFastpathAPI() throws SQLException {
 checkClosed();
 if (fastpath == null) {
  fastpath = new Fastpath(this);
 }
 return fastpath;
}

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

/**
 * Reads some data from the object, and return as a byte[] array.
 *
 * @param len number of bytes to read
 * @return byte[] array containing data read
 * @throws SQLException if a database-access error occurs.
 */
public byte[] read(int len) throws SQLException {
 // This is the original method, where the entire block (len bytes)
 // is retrieved in one go.
 FastpathArg[] args = new FastpathArg[2];
 args[0] = new FastpathArg(fd);
 args[1] = new FastpathArg(len);
 return fp.getData("loread", args);
}

/**
 * This opens a large object.
 *
 * <p>If the object does not exist, then an SQLException is thrown.
 *
 * @param fp FastPath API for the connection to use
 * @param oid of the Large Object to open
 * @param mode Mode of opening the large object
 * (defined in LargeObjectManager)
 * @exception SQLException if a database-access error occurs.
 * @see org.postgresql.largeobject.LargeObjectManager
 */
protected LargeObject(Fastpath fp, long oid, int mode) throws SQLException
{
  this.fp = fp;
  this.oid = oid;
  this.mode = mode;
  FastpathArg args[] = new FastpathArg[2];
  args[0] = Fastpath.createOIDArg(oid);
  args[1] = new FastpathArg(mode);
  this.fd = fp.getInteger("lo_open", args);
}

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

/**
 * 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 an oid.
 * @param name Function name
 * @param args Function arguments
 * @exception SQLException if a database-access error occurs or no result
 */
public long getOID(String name, FastpathArg[] args) throws SQLException
{
  long oid = getInteger(name, args);
  if (oid < 0)
    oid += NUM_OIDS;
  return oid;
}

/**
 * This creates a large object, returning its OID.
 *
 * @param mode a bitmask describing different attributes of the new object
 * @return oid of new object
 * @throws SQLException on error
 */
public long createLO(int mode) throws SQLException {
 if (conn.getAutoCommit()) {
  throw new PSQLException(GT.tr("Large Objects may not be used in auto-commit mode."),
    PSQLState.NO_ACTIVE_SQL_TRANSACTION);
 }
 FastpathArg[] args = new FastpathArg[1];
 args[0] = new FastpathArg(mode);
 return fp.getOID("lo_creat", args);
}

fp.addFunctions(res);
res.close();
stmt.close();

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

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

/**
 * <p>This opens a large object.</p>
 *
 * <p>If the object does not exist, then an SQLException is thrown.</p>
 *
 * @param fp FastPath API for the connection to use
 * @param oid of the Large Object to open
 * @param mode Mode of opening the large object
 * @param conn the connection to the database used to access this LOB
 * @param commitOnClose commit the transaction when this LOB will be closed (defined in
 *        LargeObjectManager)
 * @throws SQLException if a database-access error occurs.
 * @see org.postgresql.largeobject.LargeObjectManager
 */
protected LargeObject(Fastpath fp, long oid, int mode, BaseConnection conn, boolean commitOnClose)
  throws SQLException {
 this.fp = fp;
 this.oid = oid;
 this.mode = mode;
 if (commitOnClose) {
  this.commitOnClose = true;
  this.conn = conn;
 } else {
  this.commitOnClose = false;
 }
 FastpathArg[] args = new FastpathArg[2];
 args[0] = Fastpath.createOIDArg(oid);
 args[1] = new FastpathArg(mode);
 this.fd = fp.getInteger("lo_open", args);
}

/**
 * This convenience method assumes that the return value is an oid.
 *
 * @param name Function name
 * @param args Function arguments
 * @return oid of the given call
 * @throws SQLException if a database-access error occurs or no result
 */
public long getOID(String name, FastpathArg[] args) throws SQLException {
 long oid = getInteger(name, args);
 if (oid < 0) {
  oid += NUM_OIDS;
 }
 return oid;
}

/**
 * This creates a large object, returning its OID
 *
 * @param mode a bitmask describing different attributes of the new object
 * @return oid of new object
 * @exception SQLException on error
 */
public long createLO(int mode) throws SQLException
{
  if (conn.getAutoCommit())
    throw new PSQLException(GT.tr("Large Objects may not be used in auto-commit mode."),
                PSQLState.NO_ACTIVE_SQL_TRANSACTION);
  FastpathArg args[] = new FastpathArg[1];
  args[0] = new FastpathArg(mode);
  return fp.getOID("lo_creat", args);
}

  throw new PSQLException(GT.tr("Failed to initialize LargeObject API"), PSQLState.SYSTEM_ERROR);
fp.addFunctions(res);
res.close();

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

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

/**
 * 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 opens a large object.
 *
 * <p>If the object does not exist, then an SQLException is thrown.
 *
 * @param fp FastPath API for the connection to use
 * @param oid of the Large Object to open
 * @param mode Mode of opening the large object
 * (defined in LargeObjectManager)
 * @exception SQLException if a database-access error occurs.
 * @see org.postgresql.largeobject.LargeObjectManager
 */
protected LargeObject(Fastpath fp, long oid, int mode) throws SQLException
{
  this.fp = fp;
  this.oid = oid;
  this.mode = mode;
  FastpathArg args[] = new FastpathArg[2];
  args[0] = Fastpath.createOIDArg(oid);
  args[1] = new FastpathArg(mode);
  this.fd = fp.getInteger("lo_open", args);
}

/**
 * @return the current position within the object
 * @throws SQLException if a database-access error occurs.
 */
public int tell() throws SQLException {
 FastpathArg[] args = new FastpathArg[1];
 args[0] = new FastpathArg(fd);
 return fp.getInteger("lo_tell", args);
}