With this release, the Pl/Java project has reached its fourth major milestone
A source tarball and a variety of binaries can be found in the download area. Two for Windows. one win32 native for PostgreSQL 8.0 and one cygwin based for older PostgreSQL versions. On Linux PL/Java also comes in a GNU Java (GCJ) flavor where the actual pljava.jar is compiled into the pljava shared object.
Get the binary distribution of Pl/Java for your platform. Unzip it into a directory of your own choice.
Get the PostgreSQL environment up and running. You will need to modify the
postgresql.conf
file.
With PostgreSQL 7.4.x you must make the postmaster accept TCP/IP connections (needed by the client JDBC driver). So ensure that you have:
tcpip_socket = true
In order to find the PL/Java shared object, you can do one of two things. Either
you install the shared object in a directory already searched by the postmaster
(such as the data directory) or you tell the postmaster where to find it using the
dynamic_library_path
. I.e. you have a setting similar to this:
dynamic_library_path = '$libdir:<pljava installation>/pljava.jar'
Note that on the win32 platform (not cygwin) you need to use a semicolon as a path separator and double backslashes (since backslash is the escape character in the postgresql.conf file) as directory separators.
In order to see the logging from the tests add the following:
log_min_messages
=info
PostgreSQL 8.0 adds the ability do define custom variable classes to the
postgresql.conf
file. Add the following entrires:
custom_variable_classes = 'pljava' pljava.classpath = <pljava installation>/pljava.jar
The pljava.classpath is not needed when you run GCJ since the pljava.jar is compiled
into the shared object.
Using PostgreSQL 7.4, the postgresql.conf
have no entry to configure
Java specific environment variables yet so you will need use an external environment
setting:
exportCLASSPATH
=<pljava installation>/pljava.jar
.
Finally, unless you use GCJ, the postmaster must be made aware of the location
of the Java runtime shared objects. This accomplished by setting the LD_LIBRARY_PATH
(Unix) or PATH
(Windows). A standard install on an Intel Linux box
will need:
export LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/i386:$JAVA_HOME/jre/lib/i386/client
.
Note: Some discussions took place on the postgres hackers list wether or not the LD_LIBRARY_PATH could be set using the dynamic_library_path but it was concluded that it would be too difficult. In essence, the postmaster would need to restart itself in order for the setting to become effective since the loader is initialized when the process is created.
You are now ready to start the postmaster.
Pl/Java adds a schema named SQLJ to the database (the naming is from the proposed
SQL standard for Java backend mapping) and adds a couple of tables and functions
to that schema. A deploy program exists that should be used for this purpose. In
order to run this program, you must see to that the PostgreSQL jdbc driver package
postgresql.jar
and the deploy.jar
file is in your
CLASSPATH
, then run:
java org.postgresql.pljava.deploy.DeployerThis will result in a list of options. Typically you would use something like:
java org.postgresql.pljava.deploy.Deployer -install -user <your name>
That's all there's to it. You are now ready to start using the Pl/Java system.
If the server runs on a Cygwin system you will need to add the option -windows
.
The reason for this is that PostgreSQL and Java dynamic loading uses different naming
on Windows.
The tests are divided into two jar files. One is the client part found in the test.jar
. It contains some methods that executes
SQL statements and prints the output (all contained there can of course also be
executed from psql or any other client). The other is the example.jar
which contains the sample code that runs in the backend. The latter must be installed
in the database in order to function. An easy way to do this is to use psql and
issue the command:
SELECT sqlj.install_jar('file:///some/directory/example.jar', 'samples', true);
If this command succeeds, everything is working correctly. You may get a couple of errors here though.
org.postgresql.pljava.
<something>
cannot be found. CLASSPATH
seen by the postmaster
is incorrect so that the pljava.jar is not found.dynamic_library_path
in the postgresql.conf
file is incorrect.Once loaded, you must also set the classpath used by the Pl/Java runtime. This
classpath is set per schema (namespace). A schema that lacks a classpath will default
to the classpath that has been set for the public schema. The tests will use the
schema javatest
. To define the classpath for this schema, simply use
psql and issue the command:
SELECT sqlj.set_classpath('javatest', 'samples');
The first argument is the name of the schema, the second is a colon separated list of jar names. The names must reflect jars that are installed in the system.
Now, you should be able to run the tests:
java org.postgresql.pljava.test.Tester