* java -cp <your classpath> org.postgresql.pljava.deploy.Deployer [ options ]
* * It's recommended that create a shell script or a .bat script that does this * for you so that you don't have to do this over and over again. *
** * @author Thomas Hallgren */ public class Deployer { private static final int CMD_AMBIGUOUS = -2; private static final int CMD_UNKNOWN = -1; private static final int CMD_UNINSTALL = 0; private static final int CMD_INSTALL = 1; private static final int CMD_REINSTALL = 2; private static final int CMD_USER = 3; private static final int CMD_PASSWORD = 4; private static final int CMD_DATABASE = 5; private static final int CMD_HOSTNAME = 6; private static final int CMD_PORT = 7; private static final int CMD_WINDOWS = 8; private final Connection m_connection; private static final ArrayList s_commands = new ArrayList(); static { s_commands.add(CMD_UNINSTALL, "uninstall"); s_commands.add(CMD_INSTALL, "install"); s_commands.add(CMD_REINSTALL, "reinstall"); s_commands.add(CMD_USER, "user"); s_commands.add(CMD_PASSWORD, "password"); s_commands.add(CMD_DATABASE, "database"); s_commands.add(CMD_HOSTNAME, "host"); s_commands.add(CMD_PORT, "port"); s_commands.add(CMD_WINDOWS, "windows"); } private static final int getCommand(String arg) { int top = s_commands.size(); int candidateCmd = CMD_UNKNOWN; for(int idx = 0; idx < top; ++idx) { if(((String)s_commands.get(idx)).startsWith(arg)) { if(candidateCmd != CMD_UNKNOWN) return CMD_AMBIGUOUS; candidateCmd = idx; } } return candidateCmd; } public static void printUsage() { PrintStream out = System.err; out.println("usage: java -jar deploy.jar"); out.println(" {-install | -uninstall | -reinstall}"); out.println(" [ -host*
Option *Description ** *-install *Installs the Java language along with the sqlj procedures. The deployer * will fail if the language is installed already. ** *-reinstall *Reinstalls the Java language and the sqlj procedures. This will * effectively drop all jar files that have been loaded. ** *-remove *Drops the Java language and the sqjl procedures and loaded jars ** *-user <user name> *Name of user that connects to the database. Default is current user ** *-password <password> *Password of user that connects to the database. Default is no password * ** *-database <database> *The name of the database to connect to. Default is current user ** *-host <hostname> *Name of the host. Default is "localhost" ** *-windows *Use this option if the host runs on a windows platform. Affects the * name used for the Pl/Java dynamic library *
* <descriptor file> ::=
* SQLActions <left bracket> <right bracket> <equal sign>
* { [ <double quote> <action group> <double quote>
* [ <comma> <double quote> <action group> <double quote> ] ] }
*
* <action group> ::=
* <install actions>
* | <remove actions>
*
* <install actions> ::=
* BEGIN INSTALL [ <command> <semicolon> ]... END INSTALL
*
* <remove actions> ::=
* BEGIN REMOVE [ <command> <semicolon> ]... END REMOVE
*
* <command> ::=
* <SQL statement>
* | <implementor block>
*
* <SQL statement> ::= <SQL token>...
*
* <implementor block> ::=
* BEGIN <implementor name> <SQL token>... END <implementor name>
*
* <implementor name> ::= <identifier>
*
* <SQL token> ::= an SQL lexical unit specified by the term "<token>" in
* Subclause 5.2, "<token>" and "<separator>", in ISO/IEC 9075-2.descImage using
* implementorName as discriminator for implementor specific
* blocks. The install and remove blocks are remembered for later execution
* with calls to {@link #install install()} and {@link #remove remove()}.
* @param descImage The image to parse
* @param implementorName The discriminator to use for implementor blocks
* @throws ParseException If a parse error is encountered
*/
public SQLDeploymentDescriptor(String descImage, String implementorName)
throws ParseException
{
m_image = descImage.toCharArray();
m_implementorName = implementorName;
m_logger = Logger.getAnonymousLogger();
this.readDescriptor();
}
/**
* Executes the INSTALL actions.
* @param conn The connection to use for the execution.
* @throws SQLException
*/
public void install(Connection conn)
throws SQLException
{
this.executeArray(m_installCommands, conn);
}
/**
* Executes the REMOVE actions.
* @param conn The connection to use for the execution.
* @throws SQLException
*/
public void remove(Connection conn)
throws SQLException
{
this.executeArray(m_removeCommands, conn);
}
/**
* Returns the original image.
*/
public String toString()
{
return new String(m_image);
}
private void executeArray(ArrayList array, Connection conn)
throws SQLException
{
m_logger.entering("org.postgresql.pljava.management.SQLDeploymentDescriptor", "executeArray");
Statement stmt = conn.createStatement();
PreparedStatement pstmt = null;
ResultSet rs = stmt.executeQuery(
"SELECT session_user, current_user");
if (rs.next())
{
sessionUser = rs.getString(1);
currentUser = rs.getString(2);
rs.close();
}
else
{
rs.close();
throw new SQLException(
"Error obtaining session/current user");
}
executeAs = !currentUser.equals(sessionUser);
if (executeAs)
{
createExecuteAsFunction(stmt);
}
int top = array.size();
for(int idx = 0; idx < top; ++idx)
{
String cmd = (String)array.get(idx);
m_logger.finer(cmd);
if (executeAs)
{
pstmt = conn.prepareStatement(
callExecuteAsFunction());
pstmt.setString(1, cmd);
//This strange looking construction is
//here because otherwise nothing happend -
//neither an error not the desired action
pstmt.executeQuery().next();
//This did not work:
//pstmt.execute();
pstmt.close();
}
else
{
stmt.execute(cmd);
}
}
if (executeAs)
{
dropExecuteAsFunction(stmt);
}
stmt.close();
m_logger.exiting("org.postgresql.pljava.management.SQLDeploymentDescriptor", "executeArray");
}
private void createExecuteAsFunction(Statement stmt) throws SQLException
{
//Generate a temporary function name, which is 100% unique.
//This is done by
// backend pid => no confilct with other backends
// current timestamp => no conflict in quick cycles
// random number => no conflic in extra quick cycles
//Thr problem is that if we used only the backend pid,
//we would get "Cache lookup failed" error in some cases.
//When using absolutely unique function IDs, this error
//never occurs.
String uniqueId = null;
ResultSet rs = stmt.executeQuery(
"select pg_backend_pid()||'_'||" +
"trunc(extract(epoch from current_timestamp)*10000)||" +
"'_'||" +
"trunc(random()*100000)");
if (rs.next())
{
uniqueId = rs.getString(1);
executeAsFunctionName =
"\"sqlj\".\"execute_as_" +
sessionUser + "_pid_" + uniqueId + "\"";
stmt.execute(
"CREATE OR REPLACE FUNCTION " +
executeAsFunctionName +
"(varchar) RETURNS VOID AS " +
"'org.postgresql.pljava.management.Commands.executeAs'" +
"LANGUAGE 'java' VOLATILE SECURITY DEFINER");
stmt.execute(
"ALTER FUNCTION " +
executeAsFunctionName + "(varchar)" +
" OWNER TO \"" + sessionUser + "\"");
rs.close();
}
else
{
rs.close();
throw new SQLException("Cannot get unique function ID");
}
}
private String callExecuteAsFunction()
{
return "SELECT " + executeAsFunctionName + "(?)";
}
private void dropExecuteAsFunction(Statement stmt) throws SQLException
{
stmt.execute(
"DROP FUNCTION " + executeAsFunctionName + "(varchar)");
}
private ParseException parseError(String msg)
{
return new ParseException(msg, m_position);
}
private void readDescriptor()
throws ParseException
{
m_logger.entering("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readDescriptor");
if(!"SQLACTIONS".equals(this.readIdentifier()))
throw this.parseError("Excpected keyword 'SQLActions'");
this.readToken('[');
this.readToken(']');
this.readToken('=');
this.readToken('{');
for(;;)
{
readActionGroup();
if(readToken("},") == '}')
{
// Only whitespace allowed now
//
int c = this.skipWhite();
if(c >= 0)
throw this.parseError(
"Extraneous characters at end of descriptor");
m_logger.exiting("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readDescriptor");
return;
}
}
}
private void readActionGroup()
throws ParseException
{
m_logger.entering("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readActionGroup");
this.readToken('"');
if(!"BEGIN".equals(this.readIdentifier()))
throw this.parseError("Excpected keyword 'BEGIN'");
ArrayList commands;
String actionType = this.readIdentifier();
if("INSTALL".equals(actionType))
commands = m_installCommands;
else if("REMOVE".equals(actionType))
commands = m_removeCommands;
else
throw this.parseError("Excpected keyword 'INSTALL' or 'REMOVE'");
for(;;)
{
String cmd = this.readCommand();
// Check if the cmd is in the form:
//
// SELECT sqlj.install_jar(<jar_url>, <jar_name>, ;<deploy>);
* **
* *jar_url *The URL that denotes the location of the jar that should be loaded * ** *jar_name *This is the name by which this jar can be referenced once it has been * loaded ** *deploy *True if the jar should be deployed according to a {@link * org.postgresql.pljava.management.SQLDeploymentDescriptor deployment descriptor}, * false otherwise *
SELECT sqlj.replace_jar(<jar_url>, <jar_name>, ;<redeploy>);
* **
* *jar_url *The URL that denotes the location of the jar that should be loaded * ** *jar_name *The name of the jar to be replaced ** *redeploy *True if the old and new jar should be undeployed and deployed according * to their respective {@link * org.postgresql.pljava.management.SQLDeploymentDescriptor deployment descriptors}, * false otherwise *
SELECT sqlj.remove_jar(<jar_name>, <undeploy>);
* **
* *jar_name *The name of the jar to be removed ** *undeploy *True if the jar should be undeployed according to its {@link * org.postgresql.pljava.management.SQLDeploymentDescriptor deployment descriptor}, * false otherwise *
SELECT sqlj.get_classpath(<schema>);
* **
* *schema *The name of the schema *
SELECT sqlj.set_classpath(<schema>, <classpath>);
* * * @author Thomas Hallgren */ public class Commands { /** * Installs a new Jar in the database jar repository under name*
* *schema *The name of the schema ** *classpath *The colon separated list of jar names *
jarName.
* Once installed classpaths can be defined that refrences this jar. This
* method is exposed in SQL as
* sqlj.install_jar(VARCHAR, VARCHAR, BOOLEAN).
*
* @param urlString
* The location of the jar that will be installed.
* @param jarName
* The name by which the system will refer to this jar.
* @param deploy
* If set, execute install commands found in the deployment descriptor.
* @throws SQLException
* if the jarName contains characters that are
* invalid or if the named jar already exists in the system.
* @see #setClassPath
*/
public static void installJar(String urlString, String jarName, boolean deploy)
throws SQLException
{
assertJarName(jarName);
Connection conn = DriverManager.getConnection("jdbc:default:connection");
try
{
if(getJarId(conn, jarName) >= 0)
throw new SQLException("A jar named '" + jarName + "' already exists");
PreparedStatement stmt = conn.prepareStatement(
"INSERT INTO sqlj.jar_repository(jarName, jarOrigin) VALUES(?, ?)");
try
{
stmt.setString(1, jarName);
stmt.setString(2, urlString);
if(stmt.executeUpdate() != 1)
throw new SQLException("Jar repository insert did not insert 1 row");
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
int jarId = getJarId(conn, jarName);
if(jarId < 0)
throw new SQLException("Unable to obtain id of '" + jarName + "'");
addClassImages(conn, jarId, urlString);
if(deploy)
deployInstall(conn, jarId);
}
finally
{
try { conn.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
* Replaces the image of jar named jarName in the database jar
* repository. This method is exposed in SQL as
* sqlj.replace_jar(VARCHAR, VARCHAR, BOOLEAN).
* @param urlString The location of the jar that will be installed.
* @param jarName The name by which the system referes this jar.
* @param redeploy If set, execute remove commands found in the deployment
* descriptor of the old jar and install commands found in the deployment
* descriptor of the new jar.
* @throws SQLException if the named jar cannot be found in the repository.
*/
public static void replaceJar(String urlString, String jarName, boolean redeploy)
throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection");
try
{
int jarId = getJarId(conn, jarName);
if(jarId < 0)
throw new SQLException("No Jar named '" + jarName + "' is known to the system");
if(redeploy)
deployRemove(conn, jarId);
PreparedStatement stmt = conn.prepareStatement(
"UPDATE sqlj.jar_repository SET jarOrigin = ?, deploymentDesc = NULL WHERE jarId = ?");
try
{
stmt.setString(1, urlString);
stmt.setInt(2, jarId);
if(stmt.executeUpdate() != 1)
throw new SQLException("Jar repository update did not update 1 row");
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
stmt = conn.prepareStatement("DELETE FROM sqlj.jar_entry WHERE jarId = ?");
try
{
stmt.setInt(1, jarId);
stmt.executeUpdate();
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
addClassImages(conn, jarId, urlString);
if(redeploy)
deployInstall(conn, jarId);
}
finally
{
try { conn.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
* Removes the jar named jarName from the database jar
* repository. Class path entries that references this jar will also be
* removed (just the entry, not the whole path). This method is exposed in
* SQL as sqlj.remove_jar(VARCHAR, BOOLEAN).
* @param jarName The name by which the system referes this jar.
* @param undeploy If set, execute remove commands found in the deployment
* descriptor of the jar.
* @throws SQLException if the named jar cannot be found in the repository.
*/
public static void removeJar(String jarName, boolean undeploy)
throws SQLException
{
assertJarName(jarName);
Connection conn = DriverManager.getConnection("jdbc:default:connection");
try
{
int jarId = getJarId(conn, jarName);
if(jarId < 0)
throw new SQLException("No Jar named '" + jarName + "' is known to the system");
if(undeploy)
deployRemove(conn, jarId);
PreparedStatement stmt = conn.prepareStatement(
"DELETE FROM sqlj.jar_repository WHERE jarId = ?");
try
{
stmt.setInt(1, jarId);
if(stmt.executeUpdate() != 1)
throw new SQLException("Jar repository update did not update 1 row");
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
finally
{
try { conn.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
* Define the class path to use for Java functions, triggers, and procedures
* that are created in the schema named schemaName
*
* This method is exposed in SQL as sqlj.set_classpath(VARCHAR, VARCHAR).
*
* @param schemaName
* Name of the schema for which this path is valid.
* @param path
* Colon separated list of names. Each name must denote the name
* of a jar that is present in the jar repository.
* @throws SQLException
* If no schema can be found with the givene name, or if one or
* several names of the path denotes a nonexistant jar file.
*/
public static void setClassPath(String schemaName, String path)
throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection");
try
{
if(schemaName == null || schemaName.length() == 0)
schemaName = "public";
else
schemaName = schemaName.toLowerCase();
if(getSchemaId(conn, schemaName) == null)
throw new SQLException("No such schema: " + schemaName);
PreparedStatement stmt;
ArrayList entries = null;
if(path != null && path.length() > 0)
{
// Collect and verify that all entries in the path represents a
// valid jar
//
entries = new ArrayList();
stmt = conn.prepareStatement(
"SELECT jarId FROM sqlj.jar_repository WHERE jarName = ?");
try
{
for(;;)
{
int colon = path.indexOf(':');
String jarName;
if(colon >= 0)
{
jarName = path.substring(0, colon);
path = path.substring(colon + 1);
}
else
jarName = path;
int jarId = getJarId(stmt, jarName);
if(jarId < 0)
throw new SQLException("No such jar: " + jarName);
entries.add(new Integer(jarId));
if(colon < 0)
break;
}
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
// Delete the old classpath
//
stmt = conn.prepareStatement(
"DELETE FROM sqlj.classpath_entry WHERE schemaName = ?");
try
{
stmt.setString(1, schemaName);
stmt.executeUpdate();
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
if(entries != null)
{
// Insert the new path.
//
stmt = conn.prepareStatement(
"INSERT INTO sqlj.classpath_entry(schemaName, ordinal, jarId) VALUES(?, ?, ?)");
try
{
int top = entries.size();
for(int idx = 0; idx < top; ++idx)
{
int jarId = ((Integer)entries.get(idx)).intValue();
stmt.setString(1, schemaName);
stmt.setInt(2, idx + 1);
stmt.setInt(3, jarId);
stmt.executeUpdate();
}
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
}
finally
{
try { conn.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
* Return the classpath that has been defined for the schema named schemaName
*
* This method is exposed in SQL as sqlj.get_classpath(VARCHAR).
*
* @param schemaName
* Name of the schema for which this path is valid.
* @return The defined classpath or null if this schema has no classpath.
* @throws SQLException
*/
public static String getClassPath(String schemaName)
throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection");
try
{
if(schemaName == null || schemaName.length() == 0)
schemaName = "public";
else
schemaName = schemaName.toLowerCase();
PreparedStatement stmt = conn.prepareStatement(
"SELECT r.jarName" +
" FROM sqlj.jar_repository r INNER JOIN sqlj.classpath_entry c ON r.jarId = c.jarId" +
" WHERE c.schemaName = ? ORDER BY c.ordinal");
try
{
stmt.setString(1, schemaName);
ResultSet rs = stmt.executeQuery();
try
{
StringBuffer buf = null;
while(rs.next())
{
if(buf == null)
buf = new StringBuffer();
else
buf.append(':');
buf.append(rs.getString(1));
}
return (buf == null) ? null : buf.toString();
}
finally
{
try { rs.close(); } catch(SQLException e) { /* ignore */ }
}
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore */ }
}
}
finally
{
try { conn.close(); } catch(SQLException e) { /* ignore */ }
}
}
protected static void addClassImages(Connection conn, int jarId, String urlString)
throws SQLException
{
InputStream urlStream = null;
PreparedStatement stmt = null;
PreparedStatement descIdStmt = null;
ResultSet rs = null;
try
{
int deployImageId = -1;
URL url = new URL(urlString);
urlStream = url.openStream();
byte[] buf = new byte[1024];
ByteArrayOutputStream img = new ByteArrayOutputStream();
stmt = conn.prepareStatement(
"INSERT INTO sqlj.jar_entry(entryName, jarId, entryImage) VALUES(?, ?, ?)");
JarInputStream jis = new JarInputStream(urlStream);
for(;;)
{
JarEntry je = jis.getNextJarEntry();
if(je == null)
break;
if(je.isDirectory())
continue;
String entryName = je.getName();
Attributes attrs = je.getAttributes();
boolean isDepDescr = false;
if(attrs != null)
{
isDepDescr = "true".equalsIgnoreCase(
attrs.getValue("SQLJDeploymentDescriptor"));
if(isDepDescr && deployImageId >= 0)
throw new SQLException("Only one SQLJDeploymentDescriptor allowed");
}
int nBytes;
img.reset();
while((nBytes = jis.read(buf)) > 0)
img.write(buf, 0, nBytes);
jis.closeEntry();
stmt.setString(1, entryName);
stmt.setInt(2, jarId);
stmt.setBytes(3, img.toByteArray());
if(stmt.executeUpdate() != 1)
throw new SQLException("Jar entry insert did not insert 1 row");
if(isDepDescr)
{
descIdStmt = conn.prepareStatement(
"SELECT entryId FROM sqlj.jar_entry" +
" WHERE jarId = ? AND entryName = ?");
descIdStmt.setInt(1, jarId);
descIdStmt.setString(2, entryName);
rs = descIdStmt.executeQuery();
if(!rs.next())
throw new SQLException("Failed to refecth row in sqlj.jar_entry");
deployImageId = rs.getInt(1);
}
}
if(deployImageId >= 0)
{
stmt.close();
stmt = conn.prepareStatement(
"UPDATE sqlj.jar_repository SET deploymentDesc = ? WHERE jarId = ?");
stmt.setInt(1, deployImageId);
stmt.setInt(2, jarId);
if(stmt.executeUpdate() != 1)
throw new SQLException("Jar repository update did not insert 1 row");
}
}
catch(IOException e)
{
throw new SQLException("I/O exception reading jar file: " + e.getMessage());
}
finally
{
if(urlStream != null)
try { urlStream.close(); } catch(IOException e) { /* ignore */ }
if(rs != null)
try { rs.close(); } catch(SQLException e) { /* ignore */ }
if(descIdStmt != null)
try { descIdStmt.close(); } catch(SQLException e) { /* ignore */ }
if(stmt != null)
try { stmt.close(); } catch(SQLException e) { /* ignore */ }
}
}
protected static void deployInstall(Connection conn, int jarId)
throws SQLException
{
SQLDeploymentDescriptor depDesc = getDeploymentDescriptor(conn, jarId);
if(depDesc != null)
depDesc.install(conn);
}
protected static void deployRemove(Connection conn, int jarId)
throws SQLException
{
SQLDeploymentDescriptor depDesc = getDeploymentDescriptor(conn, jarId);
if(depDesc != null)
depDesc.remove(conn);
}
/**
* Throws an exception if the given name cannot be used as the name of
* a jar.
* @param jarName The naem to check.
* @throws IOException
*/
protected static void assertJarName(String jarName)
throws SQLException
{
if(jarName != null)
{
int len = jarName.length();
if(len > 0 && Character.isJavaIdentifierStart(jarName.charAt(0)))
{
int idx = 1;
for(; idx < len; ++idx)
if(!Character.isJavaIdentifierPart(jarName.charAt(idx)))
break;
if(idx == len)
return;
}
}
throw new SQLException("The jar name '" + jarName + "' is not a valid name");
}
/**
* Returns the primary key identifier for the given Jar.
* @param conn The connection to use for the query.
* @param jarName The name of the jar.
* @return The primary key value of the given jar or -1 if no
* such jar is found.
* @throws SQLException
*/
protected static int getJarId(Connection conn, String jarName)
throws SQLException
{
PreparedStatement stmt = conn.prepareStatement(
"SELECT jarId FROM sqlj.jar_repository WHERE jarName = ?");
try
{
return getJarId(stmt, jarName);
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
protected static int getJarId(PreparedStatement stmt, String jarName)
throws SQLException
{
stmt.setString(1, jarName);
ResultSet rs = stmt.executeQuery();
try
{
if(!rs.next())
return -1;
return rs.getInt(1);
}
finally
{
try { rs.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
protected static SQLDeploymentDescriptor getDeploymentDescriptor(Connection conn, int jarId)
throws SQLException
{
PreparedStatement stmt = conn.prepareStatement(
"SELECT e.entryImage" +
" FROM sqlj.jar_repository r INNER JOIN sqlj.jar_entry e" +
" ON r.deploymentDesc = e.entryId" +
" WHERE r.jarId = ?");
try
{
stmt.setInt(1, jarId);
ResultSet rs = stmt.executeQuery();
try
{
if(!rs.next())
return null;
byte[] bytes = rs.getBytes(1);
if(bytes.length == 0)
return null;
// Accodring to the SQLJ standard, this entry must be
// UTF8 encoded.
//
return new SQLDeploymentDescriptor(new String(bytes, "UTF8"), "postgresql");
}
catch (UnsupportedEncodingException e)
{
// Excuse me? No UTF8 encoding?
//
throw new SQLException("JVM does not support UTF8!!");
}
catch(ParseException e)
{
throw new SQLException(e.getMessage() + " at " + e.getErrorOffset());
}
finally
{
try { rs.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
* Returns the Oid for the given Schema.
* @param conn The connection to use for the query.
* @param schemaName The name of the schema.
* @return The Oid of the given schema or null if no such
* schema is found.
* @throws SQLException
*/
protected static Oid getSchemaId(Connection conn, String schemaName)
throws SQLException
{
PreparedStatement stmt = conn.prepareStatement(
"SELECT oid FROM pg_namespace WHERE nspname = ?");
try
{
stmt.setString(1, schemaName);
ResultSet rs = stmt.executeQuery();
try
{
if(!rs.next())
return null;
return (Oid)rs.getObject(1);
}
finally
{
try { rs.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
finally
{
try { stmt.close(); } catch(SQLException e) { /* ignore close errors */ }
}
}
/**
Executes an SQL command. The purpose of this method is
to be executed as a "SECURITY DEFINER" function, so that
the effective user is different from session user.
*/
public static void executeAs(String cmd)
throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection");
Statement stmt = conn.createStatement();
try
{
stmt.executeUpdate(cmd);
}
catch(SQLException e)
{
throw new SQLException(
"Cannot execute: " + cmd + ", " +
"reason: " + e.getMessage(),
e.getSQLState(),
e.getErrorCode());
}
finally
{
stmt.close();
}
}
}