| java.lang.Object
 org.postgresql.fastpath.Fastpath
| Fastpath | | public class Fastpath (Code) | | This class implements the Fastpath api.
This is a means of executing functions imbeded in the org.postgresql
backend from within a java application.
It is based around the file src/interfaces/libpq/fe-exec.c
|
| Method Summary | |
| public void | addFunction(String name, int fnid)
This adds a function to our lookup table.
User code should use the addFunctions method, which is based upon a
query, rather than hard coding the oid. | | public void | addFunctions(ResultSet rs)
This takes a ResultSet containing two columns. | | public static FastpathArg | createOIDArg(long oid)
Creates a FastpathArg with an oid parameter. | | public Object | fastpath(int fnId, boolean resultType, FastpathArg[] args)
| | public Object | fastpath(String name, boolean resulttype, FastpathArg[] args)
Send a function call to the PostgreSQL backend by name. | | public byte[] | getData(String name, FastpathArg[] args)
| | public int | getID(String name)
This returns the function id associated by its name. | | public int | getInteger(String name, FastpathArg[] args)
| | public long | getOID(String name, FastpathArg[] args)
This convenience method assumes that the return value is an oid. |
| Fastpath | | public Fastpath(BaseConnection conn)(Code) | | Initialises the fastpath system
Parameters:
conn - BaseConnection to attach to |
| addFunction | | public void addFunction(String name, int fnid)(Code) | | This adds a function to our lookup table.
User code should use the addFunctions method, which is based upon a
query, rather than hard coding the oid. The oid for a function is not
guaranteed to remain static, even on different servers of the same
version.
Parameters:
name - Function name
Parameters:
fnid - Function id |
| addFunctions | | public void addFunctions(ResultSet rs) throws SQLException(Code) | | This takes a ResultSet containing two columns. Column 1 contains the
function name, Column 2 the oid.
It reads the entire ResultSet, loading the values into the function
table.
REMEMBER to close() the resultset after calling this!!
Implementation note about function name lookups:
PostgreSQL stores the function id's and their corresponding names in
the pg_proc table. To speed things up locally, instead of querying each
function from that table when required, a Hashtable is used. Also, only
the function's required are entered into this table, keeping connection
times as fast as possible.
The org.postgresql.largeobject.LargeObject class performs a query upon it's startup,
and passes the returned ResultSet to the addFunctions() method here.
Once this has been done, the LargeObject api refers to the functions by
name.
Dont think that manually converting them to the oid's will work. Ok,
they will for now, but they can change during development (there was some
discussion about this for V7.0), so this is implemented to prevent any
unwarranted headaches in the future.
Parameters:
rs - ResultSet
exception:
SQLException - if a database-access error occurs.
See Also: org.postgresql.largeobject.LargeObjectManager |
| createOIDArg | | public static FastpathArg createOIDArg(long oid)(Code) | | Creates a FastpathArg with an oid parameter.
This is here instead of a constructor of FastpathArg
because the constructor can't tell the difference between
an long that's really int8 and a long thats an oid.
|
| fastpath | | public Object fastpath(int fnId, boolean resultType, FastpathArg[] args) throws SQLException(Code) | | Send a function call to the PostgreSQL backend
Parameters:
fnId - Function id
Parameters:
resultType - True if the result is an integer, false for other results
Parameters:
args - FastpathArguments to pass to fastpath null if no data, Integer if an integer result, or byte[] otherwise
exception:
SQLException - if a database-access error occurs. |
| fastpath | | public Object fastpath(String name, boolean resulttype, FastpathArg[] args) throws SQLException(Code) | | 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
Parameters:
name - Function name
Parameters:
resulttype - True if the result is an integer, false for otherresults
Parameters:
args - FastpathArguments to pass to fastpath null if no data, Integer if an integer result, or byte[] otherwise
exception:
SQLException - if name is unknown or if a database-access erroroccurs.
See Also: org.postgresql.largeobject.LargeObject |
| getData | | public byte[] getData(String name, FastpathArg[] args) throws SQLException(Code) | | This convenience method assumes that the return value is not an Integer
Parameters:
name - Function name
Parameters:
args - Function arguments byte[] array containing result
exception:
SQLException - if a database-access error occurs or no result |
| getID | | public int getID(String name) throws SQLException(Code) | | This returns the function id associated by its name.
If addFunction() or addFunctions() have not been called for this name,
then an SQLException is thrown.
Parameters:
name - Function name to lookup Function ID for fastpath call
exception:
SQLException - is function is unknown. |
| getInteger | | public int getInteger(String name, FastpathArg[] args) throws SQLException(Code) | | This convenience method assumes that the return value is an Integer
Parameters:
name - Function name
Parameters:
args - Function arguments integer result
exception:
SQLException - if a database-access error occurs or no result |
| getOID | | public long getOID(String name, FastpathArg[] args) throws SQLException(Code) | | This convenience method assumes that the return value is an oid.
Parameters:
name - Function name
Parameters:
args - Function arguments
exception:
SQLException - if a database-access error occurs or no result |
|
|