");
if(implementorName.equalsIgnoreCase(m_implementorName))
cmd = cmd.substring(pos+1, endPos);
else
// Block is not intended for this implementor.
//
cmd = null;
}
if(cmd != null)
commands.add(cmd.trim());
// Check if we have END INSTALL or END REMOVE
//
int savePos = m_position;
try
{
String tmp = this.readIdentifier();
if("END".equals(tmp))
{
tmp = this.readIdentifier();
if(actionType.equals(tmp))
break;
}
m_position = savePos;
}
catch(ParseException e)
{
m_position = savePos;
}
}
this.readToken('"');
m_logger.exiting("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readActionGroup");
}
private String readCommand()
throws ParseException
{
m_logger.entering("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readCommand");
int startQuotePos = -1;
int inQuote = 0;
int c = this.skipWhite();
m_buffer.setLength(0);
while(c != -1)
{
switch(c)
{
case '\\':
m_buffer.append((char)c);
c = this.read();
if(c != -1)
{
m_buffer.append((char)c);
c = this.read();
}
break;
case '"':
case '\'':
if(inQuote == 0)
{
startQuotePos = m_position;
inQuote = c;
}
else if(inQuote == c)
{
startQuotePos = -1;
inQuote = 0;
}
m_buffer.append((char)c);
c = this.read();
break;
case ';':
if(inQuote == 0)
{
String cmd = m_buffer.toString();
m_logger.exiting("org.postgresql.pljava.management.SQLDeploymentDescriptor", "readCommand", cmd);
return cmd;
}
m_buffer.append((char)c);
c = this.read();
break;
default:
if(inQuote == 0 && Character.isWhitespace((char)c))
{
// Change multiple whitespace into one singe space.
//
m_buffer.append(' ');
c = this.skipWhite();
}
else
{
m_buffer.append((char)c);
c = this.read();
}
}
}
if(inQuote != 0)
throw this.parseError("Untermintated " + (char)inQuote +
" starting at position " + startQuotePos);
throw this.parseError("Unexpected EOF. Expecting ';' to end command");
}
private int skipWhite()
throws ParseException
{
int c;
for(;;)
{
c = this.read();
if(c >= 0 && Character.isWhitespace((char)c))
continue;
if(c == '/')
{
switch(this.peek())
{
// "//" starts a line comment. Skip until end of line.
//
case '/':
this.skip();
for(;;)
{
c = this.read();
switch(c)
{
case '\n':
case '\r':
case -1:
break;
default:
continue;
}
break;
}
continue;
// "/*" starts a line comment. Skip until "*/"
//
case '*':
this.skip();
for(;;)
{
c = this.read();
switch(c)
{
case -1:
throw this.parseError(
"Unexpected EOF when expecting end of multi line comment");
case '*':
if(this.peek() == '/')
{
this.skip();
break;
}
continue;
default:
continue;
}
break;
}
continue;
}
}
break;
}
return c;
}
private String readIdentifier()
throws ParseException
{
int c = this.skipWhite();
if(c < 0)
throw this.parseError("Unexpected EOF when expecting start of identifier");
char ch = (char)c;
if(!Character.isJavaIdentifierStart(ch))
throw this.parseError(
"Syntax error at '" + ch +
"', expected identifier");
m_buffer.setLength(0);
m_buffer.append(ch);
for(;;)
{
c = this.peek();
if(c < 0)
break;
ch = (char)c;
if(Character.isJavaIdentifierPart(ch))
{
m_buffer.append(ch);
this.skip();
continue;
}
break;
}
return m_buffer.toString().toUpperCase();
}
private char readToken(String tokens)
throws ParseException
{
int c = this.skipWhite();
if(c < 0)
throw this.parseError("Unexpected EOF when expecting one of \"" + tokens + '"');
char ch = (char)c;
if(tokens.indexOf(ch) < 0)
throw this.parseError(
"Syntax error at '" + ch +
"', expected one of '" + tokens + "'");
return ch;
}
private char readToken(char token)
throws ParseException
{
int c = this.skipWhite();
if(c < 0)
throw this.parseError("Unexpected EOF when expecting token '" + token + '\'');
char ch = (char)c;
if(ch != token)
throw this.parseError(
"Syntax error at '" + ch +
"', expected '" + token + "'");
return ch;
}
private int peek()
{
return (m_position >= m_image.length) ? -1 : m_image[m_position];
}
private void skip()
{
m_position++;
}
private int read()
{
int pos = m_position++;
return (pos >= m_image.length) ? -1 : m_image[pos];
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/ResultSetHandle.java 0000664 0000767 0000770 00000002251 10630554503 027155 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* An implementation of this interface is returned from functions and procedures
* that are declared to return SET OF a complex type in the form
* of a {@link java.sql.ResultSet}. The primary motivation for this interface is
* that an implementation that returns a ResultSet must be able to close the
* connection and statement when no more rows are requested.
* @author Thomas Hallgren
*/
public interface ResultSetHandle
{
/**
* An implementation of this method will probably execute a query
* and return the result of that query.
* @return The ResultSet that represents the rows to be returned.
* @throws SQLException
*/
ResultSet getResultSet()
throws SQLException;
/**
* Called after the last row has returned or when the query evaluator decides
* that it does not need any more rows.
*/
void close()
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/Session.java 0000664 0000767 0000770 00000007222 10630554503 025535 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.Connection;
import java.sql.SQLException;
/**
* A Session maintains transaction coordinated in-memory data. The data
* added since the last commit will be lost on a transaction rollback, i.e.
* the Session state is synchronized with the transaction.
*
* Please note that if nested objects (such as lists and maps) are stored
* in the session, changes internal to those objects are not subject to
* the session semantics since the session is unaware of them.
*
* @author Thomas Hallgren
*/
public interface Session
{
/**
* Adds the specified listener to the list of listeners that will
* receive savepoint events. This method does nothing if the listener
* was already added.
* @param listener The listener to be added.
*/
void addSavepointListener(SavepointListener listener);
/**
* Adds the specified listener to the list of listeners that will
* receive transactional events. This method does nothing if the listener
* was already added.
* @param listener The listener to be added.
*/
void addTransactionListener(TransactionListener listener);
/**
* Obtain an attribute from the current session.
* @param attributeName The name of the attribute
* @return The value of the attribute
*/
Object getAttribute(String attributeName);
/**
* Return an object pool for the given class. The class must implement
* the interface {@link PooledObject}.
* @param cls
* @return An object pool that pools object of the given class.
*/
ObjectPool getObjectPool(Class cls);
/**
* Return the name of the effective user. If the currently
* executing funciton is declared with SECURITY DEFINER,
* then this method returns the name of the user that defined
* the function, otherwise, this method will return the same
* as {@link #getSessionUserName()}.
*/
String getUserName();
/**
* Return the name of the user that owns the current session.
*/
String getSessionUserName();
/**
* Execute a statement as a session user rather then the effective
* user. This is useful when functions declared using
* SECURITY DEFINER wants to give up the definer
* rights.
* @param conn The connection used for the execution
* @param statement The statement to execute
* @throws SQLException if something goes wrong when executing.
* @see java.sql.Statement#execute(java.lang.String)
*/
void executeAsSessionUser(Connection conn, String statement)
throws SQLException;
/**
* Remove an attribute previously stored in the session. If
* no attribute is found, nothing happens.
* @param attributeName The name of the attribute.
*/
void removeAttribute(String attributeName);
/**
* Removes the specified listener from the list of listeners that will
* receive savepoint events. This method does nothing unless the listener is
* found.
* @param listener The listener to be removed.
*/
void removeSavepointListener(SavepointListener listener);
/**
* Removes the specified listener from the list of listeners that will
* receive transactional events. This method does nothing unless the listener is
* found.
* @param listener The listener to be removed.
*/
void removeTransactionListener(TransactionListener listener);
/**
* Set an attribute to a value in the current session.
* @param attributeName
* @param value
*/
void setAttribute(String attributeName, Object value);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/SessionManager.java 0000664 0000767 0000770 00000002536 10630554503 027033 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLException;
/**
* The SessionManager makes the current {@link Session} available to the
* caller.
* @author Thomas Hallgren
*/
public class SessionManager
{
private static Method s_getSession;
/**
* Returns the current session.
*/
public static Session current()
throws SQLException
{
try
{
if(s_getSession == null)
{
String sp = System.getProperty(
"org.postgresql.pljava.sessionprovider",
"org.postgresql.pljava.internal.Backend");
Class spc = Class.forName(sp);
s_getSession = spc.getMethod("getSession", null);
}
return (Session)s_getSession.invoke(null, null);
}
catch (RuntimeException e)
{
throw e;
}
catch (InvocationTargetException e)
{
Throwable t = e.getTargetException();
if(t instanceof SQLException)
throw (SQLException)t;
if(t instanceof RuntimeException)
throw (RuntimeException)t;
throw new SQLException(t.getMessage());
}
catch (Exception e)
{
throw new SQLException(e.getMessage());
}
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/SavepointListener.java 0000664 0000767 0000770 00000001224 10630554503 027564 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.SQLException;
import java.sql.Savepoint;
/**
* @author Thomas Hallgren
*/
public interface SavepointListener
{
void onAbort(Session session, Savepoint savepoint, Savepoint parent) throws SQLException;
void onCommit(Session session, Savepoint savepoint, Savepoint parent) throws SQLException;
void onStart(Session session, Savepoint savepoint, Savepoint parent) throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/TriggerException.java 0000664 0000767 0000770 00000004074 10630554503 027376 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.SQLException;
/**
* An exception specially suited to be thrown from within a method
* designated to be a trigger function. The message generated by
* this exception will contain information on what trigger and
* what relation it was that caused the exception
*
* @author Thomas Hallgren
*/
public class TriggerException extends SQLException
{
private static final long serialVersionUID = 5543711707414329116L;
private static boolean s_recursionLock = false;
public static final String TRIGGER_ACTION_EXCEPTION = "09000";
private static final String makeMessage(TriggerData td, String message)
{
StringBuffer bld = new StringBuffer();
bld.append("In Trigger ");
if(!s_recursionLock)
{
s_recursionLock = true;
try
{
bld.append(td.getName());
bld.append(" on relation ");
bld.append(td.getTableName());
}
catch(SQLException e)
{
bld.append("(exception while generating exception message)");
}
finally
{
s_recursionLock = false;
}
}
if(message != null)
{
bld.append(": ");
bld.append(message);
}
return bld.toString();
}
/**
* Create an exception based on the TriggerData that was
* passed to the trigger method.
* @param td The TriggerData that was passed to the trigger
* method.
*/
public TriggerException(TriggerData td)
{
super(makeMessage(td, null), TRIGGER_ACTION_EXCEPTION);
}
/**
* Create an exception based on the TriggerData that was
* passed to the trigger method and an additional message.
* @param td The TriggerData that was passed to the trigger
* method.
* @param reason An additional message with info about the exception.
*/
public TriggerException(TriggerData td, String reason)
{
super(makeMessage(td, reason), TRIGGER_ACTION_EXCEPTION);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/TransactionListener.java 0000664 0000767 0000770 00000001010 10630554503 030072 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public interface TransactionListener
{
void onAbort(Session session) throws SQLException;
void onCommit(Session session) throws SQLException;
void onPrepare(Session session) throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ 0000775 0000767 0000770 00000000000 10630554503 025060 5 ustar iwasakims iwasakims pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Relation.java 0000664 0000767 0000770 00000005201 10630554503 027476 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The Relation correspons to the internal PostgreSQL
* Relation.
*
* @author Thomas Hallgren
*/
public class Relation extends JavaWrapper
{
private TupleDesc m_tupleDesc;
Relation(long pointer)
{
super(pointer);
}
/**
* Returns the name of this Relation.
* @throws SQLException
*/
public String getName()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getName(this.getNativePointer());
}
}
/**
* Returns the schema name of this Relation.
* @throws SQLException
*/
public String getSchema()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getSchema(this.getNativePointer());
}
}
/**
* Returns a descriptor that describes tuples in this Relation.
* @throws SQLException
*/
public TupleDesc getTupleDesc()
throws SQLException
{
if(m_tupleDesc == null)
{
synchronized(Backend.THREADLOCK)
{
m_tupleDesc = _getTupleDesc(this.getNativePointer());
}
}
return m_tupleDesc;
}
/**
* Creates a new Tuple by substituting new values for selected columns
* copying the columns of the original Tuple at other positions. The
* original Tuple is not modified.
* @param original The tuple that serves as the source.
* @param fieldNumbers An array of one based indexes denoting the positions that
* are to receive modified values.
* @param values The array of new values. Each value in this array corresponds to
* an index in the fieldNumbers array.
* @return A copy of the original with modifications.
* @throws SQLException if indexes are out of range or the values illegal.
*/
public Tuple modifyTuple(Tuple original, int[] fieldNumbers, Object[] values)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _modifyTuple(this.getNativePointer(), original.getNativePointer(), fieldNumbers, values);
}
}
protected native void _free(long pointer);
private static native String _getName(long pointer)
throws SQLException;
private static native String _getSchema(long pointer)
throws SQLException;
private static native TupleDesc _getTupleDesc(long pointer)
throws SQLException;
private static native Tuple _modifyTuple(long pointer, long original, int[] fieldNumbers, Object[] values)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/SPI.java 0000664 0000767 0000770 00000010261 10630554503 026356 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
/**
* The SPI class provides access to some global
* variables used by SPI.
*
* @author Thomas Hallgren
*/
public class SPI
{
public static final int ERROR_CONNECT = -1;
public static final int ERROR_COPY = -2;
public static final int ERROR_OPUNKNOWN = -3;
public static final int ERROR_UNCONNECTED = -4;
public static final int ERROR_CURSOR = -5;
public static final int ERROR_ARGUMENT = -6;
public static final int ERROR_PARAM = -7;
public static final int ERROR_TRANSACTION = -8;
public static final int ERROR_NOATTRIBUTE = -9;
public static final int ERROR_NOOUTFUNC = -10;
public static final int ERROR_TYPUNKNOWN = -11;
public static final int OK_CONNECT = 1;
public static final int OK_FINISH = 2;
public static final int OK_FETCH = 3;
public static final int OK_UTILITY = 4;
public static final int OK_SELECT = 5;
public static final int OK_SELINTO = 6;
public static final int OK_INSERT = 7;
public static final int OK_DELETE = 8;
public static final int OK_UPDATE = 9;
public static final int OK_CURSOR = 10;
/**
* Execute a command using the internal SPI_exec function.
* @param command The command to execute.
* @param rowCount The maximum number of tuples to create. A value
* of rowCount of zero is interpreted as no limit, i.e.,
* run to completion.
* @return One of the declared status codes.
*/
public static int exec(String command, int rowCount)
{
synchronized(Backend.THREADLOCK)
{
return _exec(System.identityHashCode(Thread.currentThread()), command, rowCount);
}
}
public static void freeTupTable()
{
synchronized(Backend.THREADLOCK)
{
_freeTupTable();
}
}
/**
* Returns the value of the global variable SPI_processed.
*/
public static int getProcessed()
{
synchronized(Backend.THREADLOCK)
{
return _getProcessed();
}
}
/**
* Returns the value of the global variable SPI_result.
*/
public static int getResult()
{
synchronized(Backend.THREADLOCK)
{
return _getResult();
}
}
/**
* Returns the value of the global variable SPI_tuptable.
*/
public static TupleTable getTupTable(TupleDesc known)
{
synchronized(Backend.THREADLOCK)
{
return _getTupTable(known);
}
}
/**
* Returns a textual representatio of a result code
*/
public static String getResultText(int resultCode)
{
String s;
switch(resultCode)
{
case ERROR_CONNECT:
s = "ERROR_CONNECT";
break;
case ERROR_COPY:
s = "ERROR_COPY";
break;
case ERROR_OPUNKNOWN:
s = "ERROR_OPUNKNOWN";
break;
case ERROR_UNCONNECTED:
s = "ERROR_UNCONNECTED";
break;
case ERROR_CURSOR:
s = "ERROR_CURSOR";
break;
case ERROR_ARGUMENT:
s = "ERROR_ARGUMENT";
break;
case ERROR_PARAM:
s = "ERROR_PARAM";
break;
case ERROR_TRANSACTION:
s = "ERROR_TRANSACTION";
break;
case ERROR_NOATTRIBUTE:
s = "ERROR_NOATTRIBUTE";
break;
case ERROR_NOOUTFUNC:
s = "ERROR_NOOUTFUNC";
break;
case ERROR_TYPUNKNOWN:
s = "ERROR_TYPUNKNOWN";
break;
case OK_CONNECT:
s = "OK_CONNECT";
break;
case OK_FINISH:
s = "OK_FINISH";
break;
case OK_FETCH:
s = "OK_FETCH";
break;
case OK_UTILITY:
s = "OK_UTILITY";
break;
case OK_SELECT:
s = "OK_SELECT";
break;
case OK_SELINTO:
s = "OK_SELINTO";
break;
case OK_INSERT:
s = "OK_INSERT";
break;
case OK_DELETE:
s = "OK_DELETE";
break;
case OK_UPDATE:
s = "OK_UPDATE";
break;
case OK_CURSOR:
s = "OK_CURSOR";
break;
default:
s = "Unkown result code: " + resultCode;
}
return s;
}
private native static int _exec(long threadId, String command, int rowCount);
private native static int _getProcessed();
private native static int _getResult();
private native static void _freeTupTable();
private native static TupleTable _getTupTable(TupleDesc known);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ELogHandler.java 0000664 0000767 0000770 00000012412 10630554503 030047 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.logging.Filter;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
/**
* Provides access to the loggin mechanism of the PostgreSQL server.
*
* @author Thomas Hallgren
*/
public class ELogHandler extends Handler
{
/**
* Debugging messages, in categories of
* decreasing detail.
*/
public static final int LOG_DEBUG5 = 10;
public static final int LOG_DEBUG4 = 11;
public static final int LOG_DEBUG3 = 12;
public static final int LOG_DEBUG2 = 13;
public static final int LOG_DEBUG1 = 14;
/**
* Server operational messages; sent only
* to server log by default.
*/
public static final int LOG_LOG = 15;
/**
* Informative messages that are always
* sent to client; is not affected by
* client_min_messages
*/
public static final int LOG_INFO = 17;
/**
* Helpful messages to users about query
* operation; sent to client and server
* log by default.
*/
public static final int LOG_NOTICE = 18;
/**
* Warnings
*/
public static final int LOG_WARNING = 19;
/**
* user error - abort transaction; return
* to known state
*/
public static final int LOG_ERROR = 20;
/**
* fatal error - abort process
*/
public static final int LOG_FATAL = 21;
/**
* take down the other backends with me
*/
public static final int LOG_PANIC = 22;
/* (non-Javadoc)
* @see java.util.logging.Handler#publish(java.util.logging.LogRecord)
*/
public void publish(LogRecord record)
{
Level level = record.getLevel();
int pgLevel;
if(level == null)
pgLevel = LOG_LOG;
else if(level.equals(Level.SEVERE))
pgLevel = LOG_ERROR;
else if(level.equals(Level.WARNING))
pgLevel = LOG_WARNING;
else if(level.equals(Level.INFO))
pgLevel = LOG_INFO;
else if(level.equals(Level.FINE))
pgLevel = LOG_DEBUG1;
else if(level.equals(Level.FINER))
pgLevel = LOG_DEBUG2;
else if(level.equals(Level.FINEST))
pgLevel = LOG_DEBUG3;
else
pgLevel = LOG_LOG;
Backend.log(pgLevel, this.getFormatter().format(record));
}
public ELogHandler()
{
this.configure();
}
/**
* This is a no-op.
*/
public void flush()
{
}
/**
* This is a no-op.
*/
public void close() throws SecurityException
{
}
public static void init()
{
Properties props = new Properties();
props.setProperty("handlers", ELogHandler.class.getName());
props.setProperty(".level", getPgLevel().getName());
ByteArrayOutputStream po = new ByteArrayOutputStream();
try
{
props.store(po, null);
LogManager.getLogManager().readConfiguration(
new ByteArrayInputStream(po.toByteArray()));
}
catch(IOException e)
{
}
}
/**
* Obtains the "log_min_messages" configuration variable and
* translates it into a {@link Level} object.
* @return The Level that corresponds to the configuration variable.
*/
public static Level getPgLevel()
{
// We use this little trick to provide the correct config option
// without having to call back into the JNI code the first time
// around since that call will be a bit premature (it will come
// during JVM initialization and before the native method is
// registered).
//
String pgLevel = Backend.getConfigOption("log_min_messages");
Level level = Level.ALL;
if(pgLevel != null)
{
pgLevel = pgLevel.toLowerCase().trim();
if(pgLevel.equals("panic") || pgLevel.equals("fatal"))
level = Level.OFF;
else if(pgLevel.equals("error"))
level = Level.SEVERE;
else if(pgLevel.equals("warning"))
level = Level.WARNING;
else if(pgLevel.equals("notice"))
level = Level.CONFIG;
else if(pgLevel.equals("info"))
level = Level.INFO;
else if(pgLevel.equals("debug1"))
level = Level.FINE;
else if(pgLevel.equals("debug2"))
level = Level.FINER;
else if(pgLevel.equals("debug3") || pgLevel.equals("debug4") || pgLevel.equals("debug5"))
level = Level.FINEST;
}
return level;
}
// Private method to configure an ELogHandler
//
private void configure()
{
LogManager mgr = LogManager.getLogManager();
String cname = ELogHandler.class.getName();
String val = mgr.getProperty(cname + ".filter");
if(val != null)
{
try
{
this.setFilter((Filter)Class.forName(val.trim()).newInstance());
}
catch (Exception e)
{
val = null;
}
}
if(val == null)
this.setFilter(null);
val = mgr.getProperty(cname + ".formatter");
if(val != null)
{
try
{
this.setFormatter((Formatter)Class.forName(val.trim()).newInstance());
}
catch (Exception e)
{
val = null;
}
}
if(val == null)
this.setFormatter(new ELogFormatter());
val = mgr.getProperty(cname + ".encoding");
if(val != null)
{
try
{
setEncoding(val.trim());
}
catch(Exception e)
{
val = null;
}
}
if(val == null)
try { setEncoding(null); } catch (Exception e) { /* ignore */ }
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ServerException.java 0000664 0000767 0000770 00000001277 10630554503 031057 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class ServerException extends SQLException
{
private static final long serialVersionUID = 8812755938793744633L;
private transient final ErrorData m_errorData;
public ServerException(ErrorData errorData)
{
super(errorData.getMessage(), errorData.getSqlState());
m_errorData = errorData;
}
public final ErrorData getErrorData()
{
return m_errorData;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ErrorData.java 0000664 0000767 0000770 00000010577 10630554503 027620 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
/**
* The ErrorData correspons to the ErrorData obtained
* using an internal PostgreSQL CopyErrorData call.
*
* @author Thomas Hallgren
*/
public class ErrorData extends JavaWrapper
{
ErrorData(long pointer)
{
super(pointer);
}
/**
* Returns The error level
*/
public int getErrorLevel()
{
synchronized(Backend.THREADLOCK)
{
return _getErrorLevel(this.getNativePointer());
}
}
/**
* Returns true if the error will be reported to the server log
*/
public boolean isOutputToServer()
{
synchronized(Backend.THREADLOCK)
{
return _isOutputToServer(this.getNativePointer());
}
}
/**
* Returns true if the error will be reported to the client
*/
public boolean isOutputToClient()
{
synchronized(Backend.THREADLOCK)
{
return _isOutputToClient(this.getNativePointer());
}
}
/**
* Returns true if funcname inclusion is set
*/
public boolean isShowFuncname()
{
synchronized(Backend.THREADLOCK)
{
return _isShowFuncname(this.getNativePointer());
}
}
/**
* Returns The file where the error occured
*/
public String getFilename()
{
synchronized(Backend.THREADLOCK)
{
return _getFilename(this.getNativePointer());
}
}
/**
* Returns The line where the error occured
*/
public int getLineno()
{
synchronized(Backend.THREADLOCK)
{
return _getLineno(this.getNativePointer());
}
}
/**
* Returns the name of the function where the error occured
*/
public String getFuncname()
{
synchronized(Backend.THREADLOCK)
{
return _getFuncname(this.getNativePointer());
}
}
/**
* Returns the unencoded ERRSTATE
*/
public String getSqlState()
{
synchronized(Backend.THREADLOCK)
{
return _getSqlState(this.getNativePointer());
}
}
/**
* Returns the primary error message
*/
public String getMessage()
{
synchronized(Backend.THREADLOCK)
{
return _getMessage(this.getNativePointer());
}
}
/**
* Returns the detailed error message
*/
public String getDetail()
{
synchronized(Backend.THREADLOCK)
{
return _getDetail(this.getNativePointer());
}
}
/**
* Returns the hint message
*/
public String getHint()
{
synchronized(Backend.THREADLOCK)
{
return _getHint(this.getNativePointer());
}
}
/**
* Returns the context message
*/
public String getContextMessage()
{
synchronized(Backend.THREADLOCK)
{
return _getContextMessage(this.getNativePointer());
}
}
/**
* Returns the cursor index into the query string
*/
public int getCursorPos()
{
synchronized(Backend.THREADLOCK)
{
return _getCursorPos(this.getNativePointer());
}
}
/**
* Returns the cursor index into internal query
*/
public int getInternalPos()
{
synchronized(Backend.THREADLOCK)
{
return _getInternalPos(this.getNativePointer());
}
}
/**
* Returns the internally-generated query
*/
public String getInternalQuery()
{
synchronized(Backend.THREADLOCK)
{
return _getInternalQuery(this.getNativePointer());
}
}
/**
* Returns the errno at entry
*/
public int getSavedErrno()
{
synchronized(Backend.THREADLOCK)
{
return _getSavedErrno(this.getNativePointer());
}
}
private static native int _getErrorLevel(long pointer);
private static native boolean _isOutputToServer(long pointer);
private static native boolean _isOutputToClient(long pointer);
private static native boolean _isShowFuncname(long pointer);
private static native String _getFilename(long pointer);
private static native int _getLineno(long pointer);
private static native String _getFuncname(long pointer);
private static native String _getSqlState(long pointer);
private static native String _getMessage(long pointer);
private static native String _getDetail(long pointer);
private static native String _getHint(long pointer);
private static native String _getContextMessage(long pointer);
private static native int _getCursorPos(long pointer);
private static native int _getInternalPos(long pointer);
private static native String _getInternalQuery(long pointer);
private static native int _getSavedErrno(long pointer); /* errno at entry */
protected native void _free(long pointer);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/SubXactListener.java 0000664 0000767 0000770 00000004055 10630554503 031006 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
import java.util.HashMap;
import org.postgresql.pljava.SavepointListener;
/**
* Class that enables registrations using the PostgreSQL RegisterSubXactCallback
* function.
*
* @author Thomas Hallgren
*/
class SubXactListener
{
private static final HashMap s_listeners = new HashMap();
static void onAbort(long listenerId, int spId, int parentSpId) throws SQLException
{
SavepointListener listener = (SavepointListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onAbort(Backend.getSession(), PgSavepoint.forId(spId), PgSavepoint.forId(parentSpId));
}
static void onCommit(long listenerId, int spId, int parentSpId) throws SQLException
{
SavepointListener listener = (SavepointListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onCommit(Backend.getSession(), PgSavepoint.forId(spId), PgSavepoint.forId(parentSpId));
}
static void onStart(long listenerId, long spPointer, int parentSpId) throws SQLException
{
SavepointListener listener = (SavepointListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onStart(Backend.getSession(), new PgSavepoint(spPointer), PgSavepoint.forId(parentSpId));
}
static void addListener(SavepointListener listener)
{
synchronized(Backend.THREADLOCK)
{
long key = System.identityHashCode(listener);
if(s_listeners.put(new Long(key), listener) != listener)
_register(key);
}
}
static void removeListener(SavepointListener listener)
{
synchronized(Backend.THREADLOCK)
{
long key = System.identityHashCode(listener);
if(s_listeners.remove(new Long(key)) == listener)
_unregister(key);
}
}
private static native void _register(long listenerId);
private static native void _unregister(long listenerId);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/HeapTupleHeader.java 0000664 0000767 0000770 00000002704 10630554503 030726 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The HeapTupleHeader correspons to the internal PostgreSQL
* HeapTupleHeader struct.
*
* @author Thomas Hallgren
*/
public class HeapTupleHeader extends JavaWrapper
{
private final TupleDesc m_tupleDesc;
HeapTupleHeader(long pointer, TupleDesc tupleDesc)
{
super(pointer);
m_tupleDesc = tupleDesc;
}
/**
* Obtains a value from the underlying native HeapTupleHeader
* structure.
* @param index Index of value in the structure (one based).
* @return The value or null.
* @throws SQLException If the underlying native structure has gone stale.
*/
public final Object getObject(int index)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getObject(this.getNativePointer(), m_tupleDesc.getNativePointer(), index);
}
}
/**
* Obtains the TupleDesc that describes the tuple and returns it.
* @return The TupleDesc that describes this tuple.
*/
public final TupleDesc getTupleDesc()
{
return m_tupleDesc;
}
protected native void _free(long pointer);
private static native Object _getObject(long pointer, long tupleDescPointer, int index)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/JavaWrapper.java 0000664 0000767 0000770 00000002117 10630554503 030146 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
public abstract class JavaWrapper
{
private final long m_pointer;
/**
* Creates an instance of this class that will be attached to a native
* structure represented by pointer. This constructor must only be called
* from native code.
*
* @param pointer The wapped pointer.
*/
protected JavaWrapper(long pointer)
{
m_pointer = pointer;
}
public void finalize()
{
synchronized(Backend.THREADLOCK)
{
_free(m_pointer);
}
}
/**
* Returns the native pointer
*/
public final long getNativePointer()
{
return m_pointer;
}
/**
* Calls the C function pfree() with the given pointer as an argument.
* Subclasses may override this method if special handling is needed when
* freeing up the object.
*
* @param pointer The pointer to free.
*/
protected native void _free(long pointer);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Session.java 0000664 0000767 0000770 00000006316 10630554503 027354 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import org.postgresql.pljava.ObjectPool;
import org.postgresql.pljava.SavepointListener;
import org.postgresql.pljava.TransactionListener;
import org.postgresql.pljava.jdbc.SQLUtils;
/**
* An instance of this interface reflects the current session. The attribute
* store is transactional.
*
* @author Thomas Hallgren
*/
public class Session implements org.postgresql.pljava.Session
{
private final TransactionalMap m_attributes = new TransactionalMap(new HashMap());
/**
* Adds the specified listener to the list of listeners that will
* receive transactional events.
*/
public void addTransactionListener(TransactionListener listener)
{
XactListener.addListener(listener);
}
/**
* Adds the specified listener to the list of listeners that will
* receive savepoint events.
*/
public void addSavepointListener(SavepointListener listener)
{
SubXactListener.addListener(listener);
}
public Object getAttribute(String attributeName)
{
return m_attributes.get(attributeName);
}
public ObjectPool getObjectPool(Class cls)
{
return ObjectPoolImpl.getObjectPool(cls);
}
/**
* Return the current user.
*/
public String getUserName()
{
return AclId.getUser().getName();
}
/**
* Return the session user.
*/
public String getSessionUserName()
{
return AclId.getSessionUser().getName();
}
public void removeAttribute(String attributeName)
{
m_attributes.remove(attributeName);
}
public void setAttribute(String attributeName, Object value)
{
m_attributes.put(attributeName, value);
}
/**
* Removes the specified listener from the list of listeners that will
* receive transactional events.
*/
public void removeTransactionListener(TransactionListener listener)
{
XactListener.removeListener(listener);
}
/**
* Removes the specified listener from the list of listeners that will
* receive savepoint events.
*/
public void removeSavepointListener(SavepointListener listener)
{
SubXactListener.removeListener(listener);
}
public void executeAsSessionUser(Connection conn, String statement)
throws SQLException
{
Statement stmt = conn.createStatement();
synchronized(Backend.THREADLOCK)
{
ResultSet rs = null;
AclId sessionUser = AclId.getSessionUser();
AclId effectiveUser = AclId.getUser();
try
{
_setUser(sessionUser);
if(stmt.execute(statement))
{
rs = stmt.getResultSet();
rs.next();
}
}
finally
{
SQLUtils.close(rs);
SQLUtils.close(stmt);
_setUser(effectiveUser);
}
}
}
/**
* Called from native code when the JVM is instantiated.
*/
static long init()
throws SQLException
{
ELogHandler.init();
// Should be replace with a Thread.getId() once we abandon
// Java 1.4
//
return System.identityHashCode(Thread.currentThread());
}
private static native void _setUser(AclId userId);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/LargeObject.java 0000664 0000767 0000770 00000007670 10630554503 030116 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The LargeObject correspons to the internal PostgreSQL
* LargeObjectDesc.
*
* @author Thomas Hallgren
*/
public class LargeObject extends JavaWrapper
{
/**
* Write mode flag to be passed to {@link #create} and {@link #open}
*/
public static final int INV_WRITE = 0x00020000;
/**
* Read mode flag to be passed to {@link #create} and {@link #open}
*/
public static final int INV_READ = 0x00040000;
/**
* Flag returned by {@link #create} and {@link #open}
*/
public static final int IFS_RDLOCK = (1 << 0);
/**
* Flag returned by {@link #create} and {@link #open}
*/
public static final int IFS_WRLOCK = (1 << 1);
/**
* Flag to be passed to {@link #seek} denoting that the
* offset parameter should be treated as an absolute address.
*/
public static final int SEEK_SET = 0;
/**
* Flag to be passed to {@link #seek} denoting that the
* offset parameter should be treated relative to the current
* address.
*/
public static final int SEEK_CUR = 1;
/**
* Flag to be passed to {@link #seek} denoting that the
* offset parameter should be treated relative to the end
* of the data.
*/
public static final int SEEK_END = 2;
LargeObject(long nativePointer)
{
super(nativePointer);
}
/**
* Creates a LargeObject handle and returns the {@link Oid} of
* that handle.
* @param flags Flags to use for creation.
* @return A Oid that can be used in a call to {@link #open(Oid, int)}
* or {@link #drop(Oid)}.
* @throws SQLException
*/
public static Oid create(int flags)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _create(flags);
}
}
public static LargeObject open(Oid lobjId, int flags)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _open(lobjId, flags);
}
}
public void close()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
_close(this.getNativePointer());
}
}
public static int drop(Oid lobjId)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _drop(lobjId);
}
}
public Oid getId()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getId(this.getNativePointer());
}
}
public long length()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _length(this.getNativePointer());
}
}
public long seek(long offset, int whence)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _seek(this.getNativePointer(), offset, whence);
}
}
public long tell()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _tell(this.getNativePointer());
}
}
public int read(byte[] buf)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _read(this.getNativePointer(), buf);
}
}
public int write(byte[] buf)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _write(this.getNativePointer(), buf);
}
}
private static native Oid _create(int flags)
throws SQLException;
private static native int _drop(Oid lobjId)
throws SQLException;
private static native LargeObject _open(Oid lobjId, int flags)
throws SQLException;
private static native void _close(long pointer)
throws SQLException;
private static native Oid _getId(long pointer)
throws SQLException;
private static native long _length(long pointer)
throws SQLException;
private static native long _seek(long pointer, long offset, int whence)
throws SQLException;
private static native long _tell(long pointer)
throws SQLException;
private static native int _read(long pointer, byte[] buf)
throws SQLException;
private static native int _write(long pointer, byte[] buf)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Backend.java 0000664 0000767 0000770 00000014257 10630554503 027263 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.io.File;
import java.io.FilePermission;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.Permission;
import java.sql.SQLException;
import java.util.PropertyPermission;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.postgresql.pljava.management.Commands;
/**
* Provides access to some useful routines in the PostgreSQL server.
* @author Thomas Hallgren
*/
public class Backend
{
/**
* All native calls synchronize on this object.
*/
public static final Object THREADLOCK = new Object();
private static Session s_session;
public static synchronized Session getSession()
{
if(s_session == null)
s_session = new Session();
return s_session;
}
/**
* Returns the configuration option as read from the Global
* Unified Config package (GUC).
* @param key The name of the option.
* @return The value of the option.
*/
public static String getConfigOption(String key)
{
synchronized(THREADLOCK)
{
return _getConfigOption(key);
}
}
/**
* Returns the size of the statement cache.
* @return the size of the statement cache.
*/
public static int getStatementCacheSize()
{
synchronized(THREADLOCK)
{
return _getStatementCacheSize();
}
}
/**
* Log a message using the internal elog command.
* @param logLevel The log level as defined in
* {@link ELogHandler}.
* @param str The message
*/
static void log(int logLevel, String str)
{
synchronized(THREADLOCK)
{
_log(logLevel, str);
}
}
private static class PLJavaSecurityManager extends SecurityManager
{
private boolean m_recursion = false;
public void checkPermission(Permission perm)
{
this.nonRecursiveCheck(perm);
}
public void checkPermission(Permission perm, Object context)
{
this.nonRecursiveCheck(perm);
}
private synchronized void nonRecursiveCheck(Permission perm)
{
if(m_recursion)
//
// Something, probably a ClassLoader loading one of
// the referenced classes, caused a recursion. Well
// everything done within this method is permitted
// so we just return here.
//
return;
m_recursion = true;
try
{
this.assertPermission(perm);
}
finally
{
m_recursion = false;
}
}
void assertPermission(Permission perm)
{
if(perm instanceof RuntimePermission)
{
String name = perm.getName();
if("*".equals(name) || "exitVM".equals(name))
throw new SecurityException();
else if("setSecurityManager".equals(name) && !s_inSetTrusted)
//
// Attempt to set another security manager while not
// in the setTrusted method
//
throw new SecurityException();
}
else if(perm instanceof PropertyPermission)
{
if(perm.getActions().indexOf("write") >= 0)
{
// We never allow this to be changed.
//
String propName = perm.getName();
if(propName.equals("java.home"))
throw new SecurityException();
}
}
}
}
private static boolean s_inSetTrusted = false;
private static final SecurityManager s_untrustedSecurityManager = new PLJavaSecurityManager();
/**
* This security manager will block all attempts to access the file system
*/
private static final SecurityManager s_trustedSecurityManager = new PLJavaSecurityManager()
{
void assertPermission(Permission perm)
{
if(perm instanceof FilePermission)
{
String actions = perm.getActions();
if("read".equals(actions))
{
// Must be able to read timezone info etc. in the java
// installation directory.
//
File javaHome = new File(System.getProperty("java.home"));
File accessedFile = new File(perm.getName());
File fileDir = accessedFile.getParentFile();
while(fileDir != null)
{
if(fileDir.equals(javaHome))
return;
fileDir = fileDir.getParentFile();
}
}
throw new SecurityException(perm.getActions() + " on " + perm.getName());
}
super.assertPermission(perm);
}
};
public static void addClassImages(int jarId, String urlString)
throws SQLException
{
InputStream urlStream = null;
boolean wasTrusted = (System.getSecurityManager() == s_trustedSecurityManager);
if(wasTrusted)
setTrusted(false);
try
{
URL url = new URL(urlString);
urlStream = url.openStream();
Commands.addClassImages(jarId, urlStream);
}
catch(IOException e)
{
throw new SQLException("I/O exception reading jar file: " + e.getMessage());
}
finally
{
if(urlStream != null)
try { urlStream.close(); } catch(IOException e) {}
if(wasTrusted)
setTrusted(true);
}
}
public static void clearFunctionCache()
{
synchronized(THREADLOCK)
{
_clearFunctionCache();
}
}
/**
* Called when the JVM is first booted and then everytime a switch
* is made between calling a trusted function versus an untrusted
* function.
*/
private static void setTrusted(boolean trusted)
{
s_inSetTrusted = true;
try
{
Logger log = Logger.getAnonymousLogger();
if(log.isLoggable(Level.FINE))
log.fine("Using SecurityManager for " + (trusted ? "trusted" : "untrusted") + " language");
System.setSecurityManager(trusted ? s_trustedSecurityManager : s_untrustedSecurityManager);
}
finally
{
s_inSetTrusted = false;
}
}
/**
* Returns true if the backend is awaiting a return from a
* call into the JVM. This method will only return false
* when called from a thread other then the main thread and the main
* thread has returned from the call into the JVM.
*/
public native static boolean isCallingJava();
/**
* Returns the value of the GUC custom variable
* pljava.release_lingering_savepoints.
*/
public native static boolean isReleaseLingeringSavepoints();
private native static String _getConfigOption(String key);
private native static int _getStatementCacheSize();
private native static void _log(int logLevel, String str);
private native static void _clearFunctionCache();
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Oid.java 0000664 0000767 0000770 00000012273 10630554503 026443 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
import java.util.HashMap;
/**
* The Oid correspons to the internal PostgreSQL Oid.
* Should the size of that change from 32 bit, this class must change too.
* In Java, the InvalidOid is represented as null.
*
* @author Thomas Hallgren
*/
public class Oid extends Number
{
private static final HashMap s_class2typeId = new HashMap();
private static final HashMap s_typeId2class = new HashMap();
static
{
try
{
// Ensure that the SPI JDBC driver is loaded and registered
// with the java.sql.DriverManager.
//
Class.forName("org.postgresql.pljava.jdbc.SPIDriver");
}
catch(ClassNotFoundException e)
{
throw new ExceptionInInitializerError(e);
}
}
/**
* Finds the PostgreSQL well known Oid for the given class.
* @param clazz The class.
* @return The well known Oid or null if no such Oid could be found.
*/
public static Oid forJavaClass(Class clazz)
{
return (Oid)s_class2typeId.get(clazz);
}
/**
* Finds the PostgreSQL well known Oid for a type name.
* @param typeString The name of the type, optionally qualified with a namespace.
* @return The well known Oid.
* @throws SQLException if the type could not be found
*/
public static Oid forTypeName(String typeString)
{
synchronized(Backend.THREADLOCK)
{
return new Oid(_forTypeName(typeString));
}
}
/**
* Finds the PostgreSQL well known Oid for the XOPEN Sql type.
* @param sqlType The XOPEN type code.
* @throws SQLException if the type could not be found
*/
public static Oid forSqlType(int sqlType)
{
synchronized(Backend.THREADLOCK)
{
return new Oid(_forSqlType(sqlType));
}
}
/**
* Returns the PostgreSQL type id for the Oid type.
*/
public static Oid getTypeId()
{
synchronized(Backend.THREADLOCK)
{
return _getTypeId();
}
}
/**
* A Type well known to PostgreSQL but not known as a standard XOPEN
* SQL type can be registered here. This includes types like the Oid
* itself and all the geometry related types.
* @param clazz The Java class that corresponds to the type id.
* @param typeId The well known type id.
*/
public static void registerType(Class clazz, Oid typeId)
{
s_class2typeId.put(clazz, typeId);
if(!s_typeId2class.containsKey(typeId))
s_typeId2class.put(typeId, clazz);
}
/*
* The native Oid represented as a 32 bit quantity.
* See definition in file "include/postgres_ext" of the
* PostgreSQL distribution.
*/
private final int m_native;
public Oid(int value)
{
m_native = value;
}
public double doubleValue()
{
return m_native;
}
/**
* Checks to see if the other object is an Oid, and if so,
* if the native value of that Oid equals the native value
* of this Oid.
* @return true if the objects are equal.
*/
public boolean equals(Object o)
{
return (o == this) || ((o instanceof Oid) && ((Oid)o).m_native == m_native);
}
public float floatValue()
{
return m_native;
}
public Class getJavaClass()
throws SQLException
{
Class c = (Class)s_typeId2class.get(this);
if(c == null)
{
String className;
synchronized(Backend.THREADLOCK)
{
className = _getJavaClassName(m_native);
}
try
{
c = Class.forName(getCanonicalClassName(className, 0));
}
catch(ClassNotFoundException e)
{
throw new SQLException(e.getMessage());
}
s_typeId2class.put(this, c);
s_class2typeId.put(c, this);
}
return c;
}
/**
* The native value is used as the hash code.
* @return The hashCode for this Oid.
*/
public int hashCode()
{
return m_native;
}
public int intValue()
{
return m_native;
}
public long longValue()
{
return m_native;
}
/**
* Returns a string representation of this OID.
*/
public String toString()
{
return "OID(" + m_native + ')';
}
private static String getCanonicalClassName(String name, int nDims)
{
if(name.endsWith("[]"))
return getCanonicalClassName(name.substring(0, name.length() - 2), nDims + 1);
boolean primitive = true;
if(name.equals("boolean"))
name = "Z";
else if(name.equals("byte"))
name = "B";
else if(name.equals("char"))
name = "C";
else if(name.equals("double"))
name = "D";
else if(name.equals("float"))
name = "F";
else if(name.equals("int"))
name = "I";
else if(name.equals("long"))
name = "J";
else if(name.equals("short"))
name = "S";
else
primitive = false;
if(nDims > 0)
{
StringBuffer bld = new StringBuffer();
while(--nDims >= 0)
bld.append('[');
if(primitive)
bld.append(name);
else
{
bld.append('L');
bld.append(name);
bld.append(';');
}
name = bld.toString();
}
return name;
}
private native static int _forTypeName(String typeString);
private native static int _forSqlType(int sqlType);
private native static Oid _getTypeId();
private native static String _getJavaClassName(int nativeOid)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/TransactionalMap.java 0000664 0000767 0000770 00000016057 10630554503 031174 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Collection;
import java.util.Iterator;
import java.util.AbstractSet;
import java.util.AbstractCollection;
import java.util.NoSuchElementException;
/**
* A TransactionalMap acts as a modifiable front for a backing map. All
* modifications can be reverted by a call to abort or propagated to
* the backing map by a call to commit.
*
* The map is not synchronized so care should be taken if multiple threads
* will access the map.
*
* @author Thomas Hallgren
*/
public class TransactionalMap extends HashMap
{
private static final long serialVersionUID = 5337569423915578121L;
// The object representing no object (i.e. a shadowed entry)
//
private static final Object s_noObject = new Object();
// Cache of backed collections.
//
private Set m_entrySet;
private Set m_keySet;
private Collection m_valueColl;
// Commited data
//
private final Map m_base;
protected TransactionalMap(Map base)
{
m_base = base;
}
/**
* Undo all changes made since the map was created or since
* last commit or abort.
*/
public void abort()
{
super.clear();
}
/**
* Clear this map (an anti-object is inserted for each entry
* present in the backed map).
*/
public void clear()
{
super.clear();
// Add an anti-entry for each key represented in the
// parent scope.
//
Iterator itor = m_base.keySet().iterator();
while(itor.hasNext())
super.put(itor.next(), s_noObject);
}
/**
* Commit all changes made since the map was created or since
* last commit or abort. All changes are propagated to the backing
* map.
*/
public void commit()
{
Iterator itor = super.entrySet().iterator();
while(itor.hasNext())
{
Map.Entry e = (Map.Entry)itor.next();
Object key = e.getKey();
Object val = e.getValue();
if(val == s_noObject)
m_base.remove(key);
else
m_base.put(key, val);
}
super.clear();
}
public boolean containsKey(Object key)
{
Object v = super.get(key);
if(v != null)
return (v != s_noObject);
return super.containsKey(key) || m_base.containsKey(key);
}
public Object get(Object key)
{
Object val = super.get(key);
if(val == s_noObject)
val = null;
else
if(val == null && !super.containsKey(key))
val = m_base.get(key);
return val;
}
public Object remove(Object key)
{
Object val = super.get(key);
if(val == s_noObject)
//
// Already removed
//
return null;
Object bval = m_base.get(key);
if(bval == null && !m_base.containsKey(key))
{
// Not present in base
//
if(val != null || super.containsKey(key))
super.remove(key);
return val;
}
if(val == null && !super.containsKey(key))
val = bval;
super.put(key, s_noObject);
return val;
}
public int size()
{
int sz = m_base.size();
int psz = super.size();
if(sz == 0)
return psz;
if(psz == 0)
return sz;
Iterator itor = super.entrySet().iterator();
// Decrease counter for entries present in both maps.
//
while(itor.hasNext())
{
Map.Entry me = (Map.Entry)itor.next();
Object val = me.getValue();
if(val == s_noObject)
--sz;
else if(!m_base.containsKey(me.getKey()))
++sz;
}
return sz;
}
public boolean containsValue(Object val)
{
Iterator itor = this.getValueIterator();
while(itor.hasNext())
{
Object v = itor.next();
if(v == val || (v != null && v.equals(val)))
return true;
}
return false;
}
public Set entrySet()
{
if(m_entrySet == null)
{
m_entrySet = new AbstractSet()
{
public Iterator iterator()
{
return TransactionalMap.this.getEntryIterator();
}
public int size()
{
return TransactionalMap.this.size();
}
public boolean contains(Object k)
{
return TransactionalMap.this.containsKey(k);
}
};
}
return m_entrySet;
}
public boolean isEmpty()
{
return (this.size() == 0);
}
public Set keySet()
{
if(m_keySet == null)
{
m_keySet = new AbstractSet()
{
public Iterator iterator()
{
return TransactionalMap.this.getKeyIterator();
}
public int size()
{
return TransactionalMap.this.size();
}
public boolean contains(Object k)
{
return TransactionalMap.this.containsKey(k);
}
};
}
return m_keySet;
}
public Object put(Object key, Object value)
{
Object old = this.get(key);
super.put(key, value);
return old;
}
public void putAll(Map t)
{
super.putAll(t);
}
public Collection values()
{
if(m_valueColl == null)
{
m_valueColl = new AbstractCollection()
{
public Iterator iterator()
{
return TransactionalMap.this.getValueIterator();
}
public int size()
{
return TransactionalMap.this.size();
}
public boolean contains(Object v)
{
return TransactionalMap.this.containsValue(v);
}
};
}
return m_valueColl;
}
private Set superKeySet()
{
return super.keySet();
}
protected Iterator getEntryIterator()
{
return new EntryIterator();
}
protected Iterator getKeyIterator()
{
return new KeyIterator();
}
protected Iterator getValueIterator()
{
return new ValueIterator();
}
protected class BackedEntry implements Map.Entry
{
private Object m_key;
public BackedEntry(Object key)
{
m_key = key;
}
public Object getKey()
{
return m_key;
}
public Object getValue()
{
return TransactionalMap.this.get(m_key);
}
public Object setValue(Object value)
{
return TransactionalMap.this.put(m_key, value);
}
}
protected class KeyIterator implements Iterator
{
private boolean m_phaseA = true;
private Iterator m_currentItor = TransactionalMap.this.superKeySet().iterator();
private Object m_currentKey = null;
public boolean hasNext()
{
m_currentKey = this.getValidKey(m_currentKey);
return (m_currentKey != null);
}
public Object next()
{
Object key = this.getValidKey(m_currentKey);
if(key == null)
throw new NoSuchElementException();
m_currentKey = null; // Force retrieval of next key
return key;
}
public void remove()
{
throw new UnsupportedOperationException();
}
protected Object getValidKey(Object key)
{
if(key != null && TransactionalMap.this.containsKey(key))
return key;
// Entry is not valid. Get next entry.
//
for(;;)
{
while(m_currentItor.hasNext())
{
key = m_currentItor.next();
if(TransactionalMap.this.containsKey(key))
return key;
}
if(!m_phaseA)
break;
m_currentItor = m_base.keySet().iterator();
m_phaseA = false;
}
return null;
}
}
protected class EntryIterator extends KeyIterator
{
public Object next()
{
return new BackedEntry(super.next());
}
}
protected class ValueIterator extends KeyIterator
{
public Object next()
{
return TransactionalMap.this.get(super.next());
}
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/PgSavepoint.java 0000664 0000767 0000770 00000005414 10630554503 030166 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.WeakHashMap;
import java.util.logging.Logger;
/**
* @author Thomas Hallgren
*/
public class PgSavepoint implements java.sql.Savepoint
{
private static final WeakHashMap s_knownSavepoints = new WeakHashMap();
private long m_pointer;
PgSavepoint(long pointer)
{
m_pointer = pointer;
}
public static PgSavepoint set(String name)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
PgSavepoint sp = new PgSavepoint(_set(name));
s_knownSavepoints.put(sp, Boolean.TRUE);
return sp;
}
}
static PgSavepoint forId(int savepointId)
{
if(savepointId != 0)
{
synchronized(Backend.THREADLOCK)
{
Iterator itor = s_knownSavepoints.keySet().iterator();
while(itor.hasNext())
{
PgSavepoint sp = (PgSavepoint)itor.next();
if(savepointId == _getId(sp.m_pointer))
return sp;
}
}
}
return null;
}
public int hashCode()
{
return this.getSavepointId();
}
public boolean equals(Object o)
{
return (this == o);
}
public void release()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
_release(m_pointer);
s_knownSavepoints.remove(this);
m_pointer = 0;
}
}
public void rollback()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
_rollback(m_pointer);
s_knownSavepoints.remove(this);
m_pointer = 0;
}
}
public String getSavepointName() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getName(m_pointer);
}
}
public int getSavepointId()
{
synchronized(Backend.THREADLOCK)
{
return _getId(m_pointer);
}
}
public void onInvocationExit(Connection conn)
throws SQLException
{
if(m_pointer == 0)
return;
Logger logger = Logger.getAnonymousLogger();
if(Backend.isReleaseLingeringSavepoints())
{
logger.warning("Releasing savepoint '" + _getId(m_pointer) +
"' since its lifespan exceeds that of the function where it was set");
conn.releaseSavepoint(this);
}
else
{
logger.warning("Rolling back to savepoint '" + _getId(m_pointer) +
"' since its lifespan exceeds that of the function where it was set");
conn.rollback(this);
}
}
private static native long _set(String name)
throws SQLException;
private static native void _release(long pointer)
throws SQLException;
private static native void _rollback(long pointer)
throws SQLException;
private static native String _getName(long pointer);
private static native int _getId(long pointer);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/SPIException.java 0000664 0000767 0000770 00000001141 10630554503 030232 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class SPIException extends SQLException
{
private static final long serialVersionUID = -834098440757881189L;
public SPIException(int resultCode)
{
super("SPI exception. Result = " + SPI.getResultText(resultCode));
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/TupleDesc.java 0000664 0000767 0000770 00000006336 10630554503 027623 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The TupleDesc correspons to the internal PostgreSQL
* TupleDesc.
*
* @author Thomas Hallgren
*/
public class TupleDesc extends JavaWrapper
{
private final int m_size;
private Class[] m_columnClasses;
TupleDesc(long pointer, int size) throws SQLException
{
super(pointer);
m_size = size;
}
/**
* Returns the name of the column at index.
* @param index The one based index of the column.
* @return The name of the column.
* @throws SQLException If the index is out of range for this
* tuple descriptor.
*/
public String getColumnName(int index)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getColumnName(this.getNativePointer(), index);
}
}
/**
* Returns the index of the column named colName.
* @param colName The name of the column.
* @return The index for column colName.
* @throws SQLException If no column with the given name can
* be found in this tuple descriptor.
*/
public int getColumnIndex(String colName)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getColumnIndex(this.getNativePointer(), colName.toLowerCase());
}
}
/**
* Creates a Tuple that is described by this descriptor and
* initialized with the supplied values.
* @return The created Tuple.
* @throws SQLException If the length of the values array does not
* match the size of the descriptor or if the handle of this descriptor
* has gone stale.
*/
public Tuple formTuple(Object[] values)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _formTuple(this.getNativePointer(), values);
}
}
/**
* Returns the number of columns in this tuple descriptor.
*/
public int size()
{
return m_size;
}
/**
* Returns the Java class of the column at index
*/
public Class getColumnClass(int index)
throws SQLException
{
if(m_columnClasses == null)
{
m_columnClasses = new Class[m_size];
synchronized(Backend.THREADLOCK)
{
long _this = this.getNativePointer();
for(int idx = 0; idx < m_size; ++idx)
m_columnClasses[idx] = _getOid(_this, idx+1).getJavaClass();
}
}
return m_columnClasses[index-1];
}
/**
* Returns OID of the column type.
*/
public Oid getOid(int index)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getOid(this.getNativePointer(), index);
}
}
/**
* Calls the backend function FreeTupleDesc(TupleDesc desc)
* @param pointer The native pointer to the source TupleDesc
*/
protected native void _free(long pointer);
private static native String _getColumnName(long _this, int index) throws SQLException;
private static native int _getColumnIndex(long _this, String colName) throws SQLException;
private static native Tuple _formTuple(long _this, Object[] values) throws SQLException;
private static native Oid _getOid(long _this, int index) throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Tuple.java 0000664 0000767 0000770 00000002507 10630554503 027020 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The Tuple correspons to the internal PostgreSQL
* HeapTuple.
*
* @author Thomas Hallgren
*/
public class Tuple extends JavaWrapper
{
Tuple(long pointer)
{
super(pointer);
}
/**
* Obtains a value from the underlying native HeapTuple
* structure.
* @param tupleDesc The Tuple descriptor for this instance.
* @param index Index of value in the structure (one based).
* @return The value or null.
* @throws SQLException If the underlying native structure has gone stale.
*/
public Object getObject(TupleDesc tupleDesc, int index)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getObject(this.getNativePointer(), tupleDesc.getNativePointer(), index);
}
}
/**
* Calls the backend function heap_freetuple(HeapTuple tuple)
* @param pointer The native pointer to the source HeapTuple
*/
protected native void _free(long pointer);
private static native Object _getObject(long pointer, long tupleDescPointer, int index)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ELogFormatter.java 0000664 0000767 0000770 00000003302 10630554503 030433 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.MessageFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;
/**
* A default formatter for the ELogHandler.
*
* @author Thomas Hallgren
*/
public class ELogFormatter extends Formatter
{
private final static MessageFormat s_tsFormatter = new MessageFormat(
"{0,date,dd MMM yy} {0,time,HH:mm:ss} {1} {2}");
private final static String s_lineSeparator = System.getProperty("line.separator");
private final Date m_timestamp = new Date();
private final Object m_args[] = new Object[] { m_timestamp, null, null };
private final StringBuffer m_buffer = new StringBuffer();
/**
* Format the given LogRecord.
* @param record the log record to be formatted.
* @return a formatted log record
*/
public synchronized String format(LogRecord record)
{
StringBuffer sb = m_buffer;
sb.setLength(0);
m_timestamp.setTime(record.getMillis());
String tmp = record.getSourceClassName();
m_args[1] = (tmp == null) ? record.getLoggerName() : tmp;
m_args[2] = this.formatMessage(record);
s_tsFormatter.format(m_args, sb, null);
Throwable thrown = record.getThrown();
if(thrown != null)
{
sb.append(s_lineSeparator);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
record.getThrown().printStackTrace(pw);
pw.close();
sb.append(sw.toString());
}
return sb.toString();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ExecutionPlan.java 0000664 0000767 0000770 00000013276 10630554503 030512 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
import java.util.Collections;
import java.util.Map;
import java.util.LinkedHashMap;
/**
* The ExecutionPlan correspons to the execution plan obtained
* using an internal PostgreSQL SPI_prepare call.
*
* @author Thomas Hallgren
*/
public class ExecutionPlan
{
static final int INITIAL_CACHE_CAPACITY = 29;
static final float CACHE_LOAD_FACTOR = 0.75f;
private long m_pointer;
/**
* MRU cache for prepared plans.
*/
static final class PlanCache extends LinkedHashMap
{
private final int m_cacheSize;
public PlanCache(int cacheSize)
{
super(INITIAL_CACHE_CAPACITY, CACHE_LOAD_FACTOR, true);
m_cacheSize = cacheSize;
}
protected boolean removeEldestEntry(Map.Entry eldest)
{
if(this.size() <= m_cacheSize)
return false;
ExecutionPlan evicted = (ExecutionPlan)eldest.getValue();
synchronized(Backend.THREADLOCK)
{
if(evicted.m_pointer != 0)
{
_invalidate(evicted.m_pointer);
evicted.m_pointer = 0;
}
}
return true;
}
};
static final class PlanKey
{
private final int m_hashCode;
private final String m_stmt;
private final Oid[] m_argTypes;
PlanKey(String stmt, Oid[] argTypes)
{
m_stmt = stmt;
m_hashCode = stmt.hashCode() + 1;
m_argTypes = argTypes;
}
public boolean equals(Object o)
{
if(!(o instanceof PlanKey))
return false;
PlanKey pk = (PlanKey)o;
if(!pk.m_stmt.equals(m_stmt))
return false;
Oid[] pat = pk.m_argTypes;
Oid[] mat = m_argTypes;
int idx = pat.length;
if(mat.length != idx)
return false;
while(--idx >= 0)
if(!pat[idx].equals(mat[idx]))
return false;
return true;
}
public int hashCode()
{
return m_hashCode;
}
}
private static final Map s_planCache;
private final Object m_key;
static
{
int cacheSize = Backend.getStatementCacheSize();
s_planCache = Collections.synchronizedMap(new PlanCache(cacheSize < 11
? 11
: cacheSize));
}
private ExecutionPlan(Object key, long pointer)
{
m_key = key;
m_pointer = pointer;
}
/**
* Close the plan.
*/
public void close()
{
ExecutionPlan old = (ExecutionPlan)s_planCache.put(m_key, this);
if(old != null && old.m_pointer != 0)
{
synchronized(Backend.THREADLOCK)
{
_invalidate(old.m_pointer);
old.m_pointer = 0;
}
}
}
/**
* Set up a cursor that will execute the plan using the internal
* SPI_cursor_open function
*
* @param cursorName Name of the cursor or null for a system
* generated name.
* @param parameters Values for the parameters.
* @return The Portal that represents the opened cursor.
* @throws SQLException If the underlying native structure has gone stale.
*/
public Portal cursorOpen(String cursorName, Object[] parameters)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _cursorOpen(m_pointer, System.identityHashCode(Thread
.currentThread()), cursorName, parameters);
}
}
/**
* Checks if this ExecutionPlan can create a Portal
*
* using {@link #cursorOpen}. This is true if the plan contains only one
* regular SELECT query.
*
* @return true if the plan can create a Portal
* @throws SQLException If the underlying native structure has gone stale.
*/
public boolean isCursorPlan() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isCursorPlan(m_pointer);
}
}
/**
* Execute the plan using the internal SPI_execp function.
*
* @param parameters Values for the parameters.
* @param rowCount The maximum number of tuples to create. A value of
* rowCount of zero is interpreted as no limit,
* i.e., run to completion.
* @return One of the status codes declared in class {@link SPI}.
* @throws SQLException If the underlying native structure has gone stale.
*/
public int execute(Object[] parameters, int rowCount) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _execute(m_pointer, System.identityHashCode(Thread
.currentThread()), parameters, rowCount);
}
}
/**
* Create an execution plan for a statement to be executed later using the
* internal SPI_prepare function.
*
* @param statement The command string.
* @param argTypes SQL types of argument types.
* @return An execution plan for the prepared statement.
* @throws SQLException
* @see java.sql.Types
*/
public static ExecutionPlan prepare(String statement, Oid[] argTypes)
throws SQLException
{
Object key = (argTypes == null)
? (Object)statement
: (Object)new PlanKey(statement, argTypes);
ExecutionPlan plan = (ExecutionPlan)s_planCache.remove(key);
if(plan == null)
{
synchronized(Backend.THREADLOCK)
{
plan = new ExecutionPlan(key, _prepare(
System.identityHashCode(Thread.currentThread()), statement, argTypes));
}
}
return plan;
}
private static native Portal _cursorOpen(long pointer, long threadId,
String cursorName, Object[] parameters) throws SQLException;
private static native boolean _isCursorPlan(long pointer)
throws SQLException;
private static native int _execute(long pointer, long threadId,
Object[] parameters, int rowCount) throws SQLException;
private static native long _prepare(long threadId, String statement, Oid[] argTypes)
throws SQLException;
private static native void _invalidate(long pointer);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/AclId.java 0000664 0000767 0000770 00000004760 10630554503 026706 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The AclId correspons to the internal PostgreSQL AclId.
*
* @author Thomas Hallgren
*/
public final class AclId
{
private final int m_native;
/**
* Called from native code.
*/
public AclId(int nativeAclId)
{
m_native = nativeAclId;
}
/**
* Returns equal if other is an AclId that is equal to this id.
*/
public boolean equals(Object other)
{
return this == other || ((other instanceof AclId) && ((AclId)other).m_native == m_native);
}
/**
* Returns the integer value of this id.
*/
public int intValue()
{
return m_native;
}
/**
* Returns the hashCode of this id.
*/
public int hashCode()
{
return m_native;
}
/**
* Return the id of the current database user.
*/
public static AclId getUser()
{
synchronized(Backend.THREADLOCK)
{
return _getUser();
}
}
/**
* Return the id of the session user.
*/
public static AclId getSessionUser()
{
synchronized(Backend.THREADLOCK)
{
return _getSessionUser();
}
}
/**
* Return the id of the session user.
* @throws SQLException if the user is unknown to the system.
*/
public static AclId fromName(String name) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _fromName(name);
}
}
/**
* Return the name that corresponds to this id.
*/
public String getName()
{
synchronized(Backend.THREADLOCK)
{
return this._getName();
}
}
/**
* Return true if this AclId has the right to create new objects
* in the given schema.
*/
public boolean hasSchemaCreatePermission(Oid oid)
{
synchronized(Backend.THREADLOCK)
{
return this._hasSchemaCreatePermission(oid);
}
}
/**
* Returns true if this AclId represents a super user.
*/
public boolean isSuperuser()
{
synchronized(Backend.THREADLOCK)
{
return this._isSuperuser();
}
}
/**
* Returns the result of calling #getName().
*/
public String toString()
{
return this.getName();
}
private static native AclId _getUser();
private static native AclId _getSessionUser();
private static native AclId _fromName(String name);
private native String _getName();
private native boolean _hasSchemaCreatePermission(Oid oid);
private native boolean _isSuperuser();
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/TriggerData.java 0000664 0000767 0000770 00000023367 10630554503 030133 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.postgresql.pljava.jdbc.TriggerResultSet;
/**
* The TriggerData correspons to the internal PostgreSQL TriggerData.
*
* @author Thomas Hallgren
*/
public class TriggerData extends JavaWrapper implements org.postgresql.pljava.TriggerData
{
private Relation m_relation;
private TriggerResultSet m_old = null;
private TriggerResultSet m_new = null;
private Tuple m_newTuple;
private Tuple m_triggerTuple;
TriggerData(long pointer)
{
super(pointer);
}
/**
* Returns the ResultSet that represents the new row. This ResultSet will
* be null for delete triggers and for triggers that was fired for
* statement.
The returned set will be updateable and positioned on a
* valid row.
*
* @return An updateable ResultSet containing one row or
* null.
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public ResultSet getNew() throws SQLException
{
if (m_new != null)
return m_new;
if (this.isFiredByDelete() || this.isFiredForStatement())
return null;
// PostgreSQL uses the trigger tuple as the new tuple for inserts.
//
Tuple tuple =
this.isFiredByInsert()
? this.getTriggerTuple()
: this.getNewTuple();
// Triggers fired after will always have a read-only row
//
m_new = new TriggerResultSet(this.getRelation().getTupleDesc(), tuple, this.isFiredAfter());
return m_new;
}
/**
* Returns the ResultSet that represents the old row. This ResultSet will
* be null for insert triggers and for triggers that was fired for
* statement.
The returned set will be read-only and positioned on a
* valid row.
*
* @return A read-only ResultSet containing one row or
* null.
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public ResultSet getOld() throws SQLException
{
if (m_old != null)
return m_old;
if (this.isFiredByInsert() || this.isFiredForStatement())
return null;
m_old = new TriggerResultSet(this.getRelation().getTupleDesc(), this.getTriggerTuple(), true);
return m_old;
}
/**
* Commits the changes made on the ResultSet representing
* new and returns the native pointer of new tuple. This
* method is called automatically by the trigger handler and should not
* be called in any other way.
*
* @return The modified tuple, or if no modifications have been made, the
* original tuple.
*/
public long getTriggerReturnTuple() throws SQLException
{
if(this.isFiredForStatement() || this.isFiredAfter())
//
// Only triggers fired before each row can have a return
// value.
//
return 0;
if (m_new != null)
{
Object[] changes = m_new.getChangeIndexesAndValues();
if (changes != null)
{
Tuple original = (Tuple)changes[0];
int[] indexes = (int[])changes[1];
Object[] values = (Object[])changes[2];
return this.getRelation().modifyTuple(original, indexes, values).getNativePointer();
}
}
// Return the original tuple.
//
return (this.isFiredByUpdate() ? this.getNewTuple() : this.getTriggerTuple()).getNativePointer();
}
public String getTableName()
throws SQLException
{
return this.getRelation().getName();
}
public String getSchemaName() throws SQLException {
return this.getRelation().getSchema();
}
/**
* Returns a descriptor for the Tuples exposed by this trigger.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public Relation getRelation()
throws SQLException
{
if(m_relation == null)
{
synchronized(Backend.THREADLOCK)
{
m_relation = _getRelation(this.getNativePointer());
}
}
return m_relation;
}
/**
* Returns a Tuple reflecting the row for which the trigger
* was fired. This is the row being inserted, updated, or deleted. If this
* trigger was fired for an
* INSERT or DELETE
* then this is what you should return to from the method if you don't want
* to replace the row with a different one (in the case of INSERT
* )
* or skip the operation.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public Tuple getTriggerTuple()
throws SQLException
{
if(m_triggerTuple == null)
{
synchronized(Backend.THREADLOCK)
{
m_triggerTuple = _getTriggerTuple(this.getNativePointer());
}
}
return m_triggerTuple;
}
/**
* Returns a Tuple reflecting the new version of the row, if
* the trigger was fired for an UPDATE, and null
* if it is for an INSERT or a DELETE. This
* is what you have to return from the function if the event is an UPDATE
* and you don't want to replace this row by a different one or skip the
* operation.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public Tuple getNewTuple()
throws SQLException
{
if(m_newTuple == null)
{
synchronized(Backend.THREADLOCK)
{
m_newTuple = _getNewTuple(this.getNativePointer());
}
}
return m_newTuple;
}
/**
* Returns the arguments for this trigger (as declared in the CREATE TRIGGER
* statement. If the trigger has no arguments, this method will return an
* array with size 0.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public String[] getArguments()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getArguments(this.getNativePointer());
}
}
/**
* Returns the name of the trigger (as declared in the CREATE TRIGGER
* statement).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public String getName()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getName(this.getNativePointer());
}
}
/**
* Returns true if the trigger was fired after the statement
* or row action that it is associated with.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredAfter()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredAfter(this.getNativePointer());
}
}
/**
* Returns true if the trigger was fired before the
* statement or row action that it is associated with.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredBefore()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredBefore(this.getNativePointer());
}
}
/**
* Returns true if this trigger is fired once for each row
* (as opposed to once for the entire statement).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredForEachRow()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredForEachRow(this.getNativePointer());
}
}
/**
* Returns true if this trigger is fired once for the entire
* statement (as opposed to once for each row).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredForStatement()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredForStatement(this.getNativePointer());
}
}
/**
* Returns true if this trigger was fired by a DELETE.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredByDelete()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredByDelete(this.getNativePointer());
}
}
/**
* Returns true if this trigger was fired by an INSERT.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredByInsert()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredByInsert(this.getNativePointer());
}
}
/**
* Returns true if this trigger was fired by an UPDATE.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
public boolean isFiredByUpdate()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isFiredByUpdate(this.getNativePointer());
}
}
protected native void _free(long pointer);
private static native Relation _getRelation(long pointer) throws SQLException;
private static native Tuple _getTriggerTuple(long pointer) throws SQLException;
private static native Tuple _getNewTuple(long pointer) throws SQLException;
private static native String[] _getArguments(long pointer) throws SQLException;
private static native String _getName(long pointer) throws SQLException;
private static native boolean _isFiredAfter(long pointer) throws SQLException;
private static native boolean _isFiredBefore(long pointer) throws SQLException;
private static native boolean _isFiredForEachRow(long pointer) throws SQLException;
private static native boolean _isFiredForStatement(long pointer) throws SQLException;
private static native boolean _isFiredByDelete(long pointer) throws SQLException;
private static native boolean _isFiredByInsert(long pointer) throws SQLException;
private static native boolean _isFiredByUpdate(long pointer) throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ObjectPoolImpl.java 0000664 0000767 0000770 00000007644 10630554503 030620 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.sql.SQLException;
import java.util.IdentityHashMap;
import org.postgresql.pljava.ObjectPool;
import org.postgresql.pljava.PooledObject;
class ObjectPoolImpl implements ObjectPool
{
/**
* An InstanceHandle is a link in a single linked list that
* holds on to a ResultSetProvider.
*/
private static class PooledObjectHandle
{
private PooledObject m_instance;
private PooledObjectHandle m_next;
}
private static Class[] s_ctorSignature = { ObjectPool.class };
private static PooledObjectHandle s_handlePool;
private static final IdentityHashMap s_poolCache = new IdentityHashMap();
private final Constructor m_ctor;
private PooledObjectHandle m_providerPool;
private ObjectPoolImpl(Class c)
{
if(!PooledObject.class.isAssignableFrom(c))
throw new IllegalArgumentException("Class " + c + " does not implement the " +
PooledObject.class + " interface");
try
{
m_ctor = c.getConstructor(s_ctorSignature);
}
catch(SecurityException e)
{
throw new RuntimeException(e);
}
catch(NoSuchMethodException e)
{
throw new IllegalArgumentException("Unable to locate constructor " + c + "(ObjectPool)");
}
}
/**
* Obtain a pool for the given class.
* @param cls
* @return
* @throws SQLException
*/
public static ObjectPoolImpl getObjectPool(Class cls)
{
ObjectPoolImpl pool = (ObjectPoolImpl)s_poolCache.get(cls);
if(pool == null)
{
pool = new ObjectPoolImpl(cls);
s_poolCache.put(cls, pool);
}
return pool;
}
public PooledObject activateInstance()
throws SQLException
{
PooledObject instance;
PooledObjectHandle handle = m_providerPool;
if(handle != null)
{
m_providerPool = handle.m_next;
instance = handle.m_instance;
// Return the handle to the unused handle pool.
//
handle.m_instance = null;
handle.m_next = s_handlePool;
s_handlePool = handle;
}
else
{
try
{
instance = (PooledObject)m_ctor.newInstance(new Object[] { this });
}
catch(InvocationTargetException e)
{
Throwable t = e.getTargetException();
if(t instanceof SQLException)
throw (SQLException)t;
if(t instanceof RuntimeException)
throw (RuntimeException)t;
if(t instanceof Error)
throw (Error)t;
throw new SQLException(e.getMessage());
}
catch(RuntimeException e)
{
throw e;
}
catch(Exception e)
{
throw new SQLException("Failed to create an instance of: " +
m_ctor.getDeclaringClass() + " :" + e.getMessage());
}
}
try
{
instance.activate();
}
catch(SQLException e)
{
instance.remove();
throw e;
}
return instance;
}
public void passivateInstance(PooledObject instance)
throws SQLException
{
try
{
instance.passivate();
}
catch(SQLException e)
{
instance.remove();
throw e;
}
// Obtain a handle from the pool of handles so that
// we have something to wrap the instance in.
//
PooledObjectHandle handle = s_handlePool;
if(handle != null)
s_handlePool = handle.m_next;
else
handle = new PooledObjectHandle();
handle.m_instance = instance;
handle.m_next = m_providerPool;
m_providerPool = handle;
}
public void removeInstance(PooledObject instance) throws SQLException
{
PooledObjectHandle prev = null;
for(PooledObjectHandle handle = m_providerPool; handle != null; handle = handle.m_next)
{
if(handle.m_instance == instance)
{
if(prev == null)
m_providerPool = handle.m_next;
else
prev.m_next = handle.m_next;
handle.m_instance = null;
handle.m_next = s_handlePool;
s_handlePool = handle;
break;
}
}
instance.remove();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/Portal.java 0000664 0000767 0000770 00000010400 10630554503 027157 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
/**
* The Portal correspons to the internal PostgreSQL
* Portal type.
*
* @author Thomas Hallgren
*/
public class Portal
{
private long m_pointer;
Portal(long pointer)
{
m_pointer = pointer;
}
/**
* Invalidates this structure and frees up memory using the
* internal function SPI_cursor_close
*/
public void close()
{
synchronized(Backend.THREADLOCK)
{
_close(m_pointer);
m_pointer = 0;
}
}
/**
* Returns the name of this Portal.
* @throws SQLException if the handle to the native structur is stale.
*/
public String getName()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getName(m_pointer);
}
}
/**
* Returns the value of the portalPos attribute.
* @throws SQLException if the handle to the native structur is stale.
*/
public int getPortalPos()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getPortalPos(m_pointer);
}
}
/**
* Returns the TupleDesc that describes the row Tuples for this
* Portal.
* @throws SQLException if the handle to the native structur is stale.
*/
public TupleDesc getTupleDesc()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getTupleDesc(m_pointer);
}
}
/**
* Performs an SPI_cursor_fetch.
* @param forward Set to true for forward, false for backward.
* @param count Maximum number of rows to fetch.
* @return The actual number of fetched rows.
* @throws SQLException if the handle to the native structur is stale.
*/
public int fetch(boolean forward, int count)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _fetch(m_pointer, forward, count);
}
}
/**
* Returns the value of the atEnd attribute.
* @throws SQLException if the handle to the native structur is stale.
*/
public boolean isAtEnd()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isAtEnd(m_pointer);
}
}
/**
* Returns the value of the atStart attribute.
* @throws SQLException if the handle to the native structur is stale.
*/
public boolean isAtStart()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isAtStart(m_pointer);
}
}
/**
* Returns the value of the posOverflow attribute.
* @throws SQLException if the handle to the native structur is stale.
*/
public boolean isPosOverflow()
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _isPosOverflow(m_pointer);
}
}
/**
* Checks if the portal is still active. I can be closed either explicitly
* using the {@link #close()} mehtod or implicitly due to a pop of invocation
* context.
*/
public boolean isValid()
{
return m_pointer != 0;
}
/**
* Performs an SPI_cursor_move.
* @param forward Set to true for forward, false for backward.
* @param count Maximum number of rows to fetch.
* @return The value of the global variable SPI_result.
* @throws SQLException if the handle to the native structur is stale.
*/
public int move(boolean forward, int count)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _move(m_pointer, forward, count);
}
}
private static native String _getName(long pointer)
throws SQLException;
private static native int _getPortalPos(long pointer)
throws SQLException;
private static native TupleDesc _getTupleDesc(long pointer)
throws SQLException;
private static native int _fetch(long pointer, boolean forward, int count)
throws SQLException;
private static native void _close(long pointer);
private static native boolean _isAtEnd(long pointer)
throws SQLException;
private static native boolean _isAtStart(long pointer)
throws SQLException;
private static native boolean _isPosOverflow(long pointer)
throws SQLException;
private static native int _move(long pointer, boolean forward, int count)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/ResultSetPicker.java 0000664 0000767 0000770 00000002152 10630554503 031013 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.postgresql.pljava.ResultSetHandle;
import org.postgresql.pljava.ResultSetProvider;
import org.postgresql.pljava.jdbc.SingleRowWriter;
public class ResultSetPicker implements ResultSetProvider
{
private final ResultSetHandle m_resultSetHandle;
private final ResultSet m_resultSet;
public ResultSetPicker(ResultSetHandle resultSetHandle)
throws SQLException
{
m_resultSetHandle = resultSetHandle;
m_resultSet = resultSetHandle.getResultSet();
}
public boolean assignRowValues(ResultSet receiver, int currentRow)
throws SQLException
{
if(m_resultSet == null || !m_resultSet.next())
return false;
((SingleRowWriter)receiver).copyRowFrom(m_resultSet);
return true;
}
public void close()
throws SQLException
{
m_resultSet.close();
m_resultSetHandle.close();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/TupleTable.java 0000664 0000767 0000770 00000002024 10630554503 027762 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
/**
* The SPITupleTable correspons to the internal PostgreSQL
* SPITupleTable type.
*
* @author Thomas Hallgren
*/
public class TupleTable
{
private final TupleDesc m_tupleDesc;
private final Tuple[] m_tuples;
TupleTable(TupleDesc tupleDesc, Tuple[] tuples)
{
m_tupleDesc = tupleDesc;
m_tuples = tuples;
}
public final TupleDesc getTupleDesc()
{
return m_tupleDesc;
}
/**
* Returns the number of Tuple instances contained in this table.
*/
public final int getCount()
{
return m_tuples.length;
}
/**
* Returns the Tuple at the given index.
* @param position Index of desired slot. First slot has index zero.
*/
public final Tuple getSlot(int position)
{
return m_tuples[position];
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/internal/XactListener.java 0000664 0000767 0000770 00000003500 10630554503 030326 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.internal;
import java.sql.SQLException;
import java.util.HashMap;
import org.postgresql.pljava.TransactionListener;
/**
* Class that enables registrations using the PostgreSQL RegisterXactCallback
* function.
*
* @author Thomas Hallgren
*/
class XactListener
{
private static final HashMap s_listeners = new HashMap();
static void onAbort(long listenerId) throws SQLException
{
TransactionListener listener = (TransactionListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onAbort(Backend.getSession());
}
static void onCommit(long listenerId) throws SQLException
{
TransactionListener listener = (TransactionListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onCommit(Backend.getSession());
}
static void onPrepare(long listenerId) throws SQLException
{
TransactionListener listener = (TransactionListener)s_listeners.get(new Long(listenerId));
if(listener != null)
listener.onPrepare(Backend.getSession());
}
static void addListener(TransactionListener listener)
{
synchronized(Backend.THREADLOCK)
{
long key = System.identityHashCode(listener);
if(s_listeners.put(new Long(key), listener) != listener)
_register(key);
}
}
static void removeListener(TransactionListener listener)
{
synchronized(Backend.THREADLOCK)
{
long key = System.identityHashCode(listener);
if(s_listeners.remove(new Long(key)) == listener)
_unregister(key);
}
}
private static native void _register(long listenerId);
private static native void _unregister(long listenerId);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/ResultSetProvider.java 0000664 0000767 0000770 00000002645 10630554503 027563 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* An implementation of this interface is returned from functions and procedures
* that are declared to return SET OF a complex type. Functions that
* return SET OF a simple type should simply return an
* {@link java.util.Iterator Iterator}.
* @author Thomas Hallgren
*/
public interface ResultSetProvider
{
/**
* This method is called once for each row that should be returned from
* a procedure that returns a set of rows. The receiver
* is a {@link org.postgresql.pljava.jdbc.SingleRowWriter SingleRowWriter}
* writer instance that is used for capturing the data for the row.
* @param receiver Receiver of values for the given row.
* @param currentRow Row number. First call will have row number 0.
* @return true if a new row was provided, false
* if not (end of data).
* @throws SQLException
*/
boolean assignRowValues(ResultSet receiver, int currentRow)
throws SQLException;
/**
* Called after the last row has returned or when the query evaluator decides
* that it does not need any more rows.
*/
void close()
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/TriggerData.java 0000664 0000767 0000770 00000011225 10630554503 026305 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* The SQL 2003 spec. does not stipulate a standard way of mapping
* triggers to functions. The PLJava mapping use this interface. All
* functions that are intended to be triggers must be public, static,
* return void, and take a TriggerData as their argument.
*
* @author Thomas Hallgren
*/
public interface TriggerData
{
/**
* Returns the ResultSet that represents the new row. This ResultSet will
* be null for delete triggers and for triggers that was fired for
* statement.
The returned set will be updateable and positioned on a
* valid row. When the trigger call returns, the trigger manager will see
* the changes that has been made to this row and construct a new tuple
* which will become the new or updated row.
*
* @return An updateable ResultSet containing one row or
* null.
* @throws SQLException
* if the contained native buffer has gone stale.
*/
ResultSet getNew() throws SQLException;
/**
* Returns the ResultSet that represents the old row. This ResultSet will
* be null for insert triggers and for triggers that was fired for
* statement.
The returned set will be read-only and positioned on a
* valid row.
*
* @return A read-only ResultSet containing one row or
* null.
* @throws SQLException
* if the contained native buffer has gone stale.
*/
ResultSet getOld() throws SQLException;
/**
* Returns the arguments for this trigger (as declared in the CREATE TRIGGER
* statement. If the trigger has no arguments, this method will return an
* array with size 0.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
String[] getArguments() throws SQLException;
/**
* Returns the name of the trigger (as declared in the CREATE TRIGGER
* statement).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
String getName() throws SQLException;
/**
* Returns the name of the table for which this trigger was created (as
* declared in the CREATE TRIGGERCREATE TRIGGERtrue if the trigger was fired after the statement
* or row action that it is associated with.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredAfter() throws SQLException;
/**
* Returns true if the trigger was fired before the
* statement or row action that it is associated with.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredBefore() throws SQLException;
/**
* Returns true if this trigger is fired once for each row
* (as opposed to once for the entire statement).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredForEachRow() throws SQLException;
/**
* Returns true if this trigger is fired once for the entire
* statement (as opposed to once for each row).
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredForStatement() throws SQLException;
/**
* Returns true if this trigger was fired by a DELETE.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredByDelete() throws SQLException;
/**
* Returns true if this trigger was fired by an INSERT.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredByInsert() throws SQLException;
/**
* Returns true if this trigger was fired by an UPDATE.
*
* @throws SQLException
* if the contained native buffer has gone stale.
*/
boolean isFiredByUpdate() throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/PooledObject.java 0000664 0000767 0000770 00000002266 10630554503 026466 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava;
import java.sql.SQLException;
/**
* Interface for objects that are pooled and reused.
* @author Thomas Hallgren
*/
public interface PooledObject
{
/**
* The activate method is called when the instance is activated
* from its "passive" state.
* @throws SQLException if something goes wrong with the activation.
* When this happens, a call will be issued to {@link #remove()} and
* the object will no longer be part of the pool.
*/
void activate()
throws SQLException;
/**
* The passivate method is called before the instance enters
* the "passive" state.
* @throws SQLException if something goes wrong with the passivation.
* When this happens, a call will be issued to {@link #remove()} and
* the object will no longer be part of the pool.
*/
void passivate()
throws SQLException;
/**
* PLJava invokes this method before it ends the life of the
* pooled object.
*/
void remove();
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ 0000775 0000767 0000770 00000000000 10630554503 024146 5 ustar iwasakims iwasakims pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/TypeOid.java 0000664 0000767 0000770 00000002374 10630554503 026374 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import org.postgresql.pljava.internal.Oid;
/**
* Provides constants for well-known backend OIDs for the types we commonly
* use.
*/
public class TypeOid {
public static final Oid INVALID = new Oid(0);
public static final Oid INT2 = new Oid(21);
public static final Oid INT4 = new Oid(23);
public static final Oid INT8 = new Oid(20);
public static final Oid TEXT = new Oid(25);
public static final Oid NUMERIC = new Oid(1700);
public static final Oid FLOAT4 = new Oid(700);
public static final Oid FLOAT8 = new Oid(701);
public static final Oid BOOL = new Oid(16);
public static final Oid DATE = new Oid(1082);
public static final Oid TIME = new Oid(1083);
public static final Oid TIMESTAMP = new Oid(1114);
public static final Oid TIMESTAMPTZ = new Oid(1184);
public static final Oid BYTEA = new Oid(17);
public static final Oid VARCHAR = new Oid(1043);
public static final Oid OID = new Oid(26);
public static final Oid BPCHAR = new Oid(1042);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIConnection.java 0000664 0000767 0000770 00000057054 10630554503 027477 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.BitSet;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.postgresql.pljava.internal.Oid;
import org.postgresql.pljava.internal.PgSavepoint;
/**
* @author Thomas Hallgren
*/
public class SPIConnection implements Connection
{
private static final HashMap s_sqlType2Class = new HashMap(30);
private int[] VERSION_NUMBER = null; //version number
static
{
addType(String.class, Types.VARCHAR);
addType(Byte.class, Types.TINYINT);
addType(Short.class, Types.SMALLINT);
addType(Integer.class, Types.INTEGER);
addType(Long.class, Types.BIGINT);
addType(Float.class, Types.FLOAT);
addType(Double.class, Types.DOUBLE);
addType(BigDecimal.class, Types.DECIMAL);
addType(BigInteger.class, Types.NUMERIC);
addType(Boolean.class, Types.BOOLEAN);
addType(Blob.class, Types.BLOB);
addType(Clob.class, Types.CLOB);
addType(Date.class, Types.DATE);
addType(Time.class, Types.TIME);
addType(Timestamp.class, Types.TIMESTAMP);
addType(java.util.Date.class, Types.TIMESTAMP);
addType(byte[].class, Types.VARBINARY);
addType(BitSet.class, Types.BIT);
addType(URL.class, Types.DATALINK);
}
private static final void addType(Class clazz, int sqlType)
{
s_sqlType2Class.put(clazz, new Integer(sqlType));
}
/**
* Returns a default connection instance. It is the callers responsability
* to close this instance.
*/
public static Connection getDefault()
throws SQLException
{
return new SPIConnection();
}
/**
* Returns {@link ResultSet#CLOSE_CURSORS_AT_COMMIT}. Cursors are actually
* closed when a function returns to SQL.
*/
public int getHoldability() throws SQLException
{
return ResultSet.CLOSE_CURSORS_AT_COMMIT;
}
/**
* Returns {@link Connection#TRANSACTION_READ_COMMITTED}.
*/
public int getTransactionIsolation() throws SQLException
{
return TRANSACTION_READ_COMMITTED;
}
/**
* Warnings are not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void clearWarnings()
throws SQLException
{
throw new UnsupportedFeatureException("Connection.clearWarnings");
}
/**
* This is a no-op. The default connection never closes.
*/
public void close()
throws SQLException
{
}
/**
* It's not legal to do a commit within a call from SQL.
* @throws SQLException indicating that this feature is not supported.
*/
public void commit()
throws SQLException
{
throw new UnsupportedFeatureException("Connection.commit");
}
/**
* It's not legal to do a rollback within a call from SQL.
* @throws SQLException indicating that this feature is not supported.
*/
public void rollback()
throws SQLException
{
throw new UnsupportedFeatureException("Connection.rollback");
}
/**
* It is assumed that an SPI call is under transaction control. This method
* will always return false.
*/
public boolean getAutoCommit()
throws SQLException
{
return false;
}
/**
* Will always return false.
*/
public boolean isClosed()
throws SQLException
{
return false;
}
/**
* Returns false. The SPIConnection is not real-only.
*/
public boolean isReadOnly()
throws SQLException
{
return false;
}
/**
* Change of holdability is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void setHoldability(int holdability)
throws SQLException
{
throw new UnsupportedFeatureException("Connection.setHoldability");
}
/**
* Change of transaction isolation level is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void setTransactionIsolation(int level)
throws SQLException
{
throw new UnsupportedFeatureException("Connection.setTransactionIsolation");
}
/**
* It is assumed that an SPI call is under transaction control. Changing
* that is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void setAutoCommit(boolean autoCommit)
throws SQLException
{
throw new UnsupportedFeatureException("Connection.setAutoCommit");
}
/**
* It is assumed that an inserts and updates can be performed using and
* SPIConnection. Changing that is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void setReadOnly(boolean readOnly)
throws SQLException
{
throw new UnsupportedFeatureException("Connection.setReadOnly");
}
/**
* Returns null.
*/
public String getCatalog()
throws SQLException
{
return null;
}
/**
* The catalog name cannot be set.
* @throws SQLException indicating that this feature is not supported.
*/
public void setCatalog(String catalog)
throws SQLException
{
throw new UnsupportedFeatureException("Connection.setCatalog");
}
/**
* DatabaseMetaData is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public DatabaseMetaData getMetaData()
throws SQLException
{
return new SPIDatabaseMetaData(this);
}
/**
* Warnings are not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public SQLWarning getWarnings()
throws SQLException
{
throw new UnsupportedFeatureException("Connection.getWarnings");
}
public void releaseSavepoint(Savepoint savepoint) throws SQLException
{
if(!(savepoint instanceof PgSavepoint))
throw new IllegalArgumentException("Not a PL/Java Savepoint");
PgSavepoint sp = (PgSavepoint)savepoint;
sp.release();
forgetSavepoint(sp);
}
public void rollback(Savepoint savepoint) throws SQLException
{
if(!(savepoint instanceof PgSavepoint))
throw new IllegalArgumentException("Not a PL/Java Savepoint");
PgSavepoint sp = (PgSavepoint)savepoint;
Invocation.clearErrorCondition();
sp.rollback();
forgetSavepoint(sp);
}
/**
* Creates a new instance of SPIStatement.
*/
public Statement createStatement()
throws SQLException
{
if(this.isClosed())
throw new SQLException("Connection is closed");
return new SPIStatement(this);
}
/**
* Creates a new instance of SPIStatement.
*
* @throws SQLException
* if the resultSetType differs from {@link
* ResultSet#TYPE_FORWARD_ONLY} or if the resultSetConcurrencty
* differs from {@link ResultSet#CONCUR_READ_ONLY}.
*/
public Statement createStatement(
int resultSetType,
int resultSetConcurrency)
throws SQLException
{
if(resultSetType != ResultSet.TYPE_FORWARD_ONLY)
throw new UnsupportedOperationException("TYPE_FORWARD_ONLY supported ResultSet type");
if(resultSetConcurrency != ResultSet.CONCUR_READ_ONLY)
throw new UnsupportedOperationException("CONCUR_READ_ONLY is the supported ResultSet concurrency");
return this.createStatement();
}
/**
* Creates a new instance of SPIStatement.
*
* @throws SQLException
* if the resultSetType differs from {@link
* ResultSet#TYPE_FORWARD_ONLY}, if the resultSetConcurrencty
* differs from {@link ResultSet#CONCUR_READ_ONLY}, or if the
* resultSetHoldability differs from {@link ResultSet#CLOSE_CURSORS_AT_COMMIT}.
*/
public Statement createStatement(
int resultSetType,
int resultSetConcurrency,
int resultSetHoldability)
throws SQLException
{
if(resultSetHoldability != ResultSet.CLOSE_CURSORS_AT_COMMIT)
throw new UnsupportedOperationException(
"CLOSE_CURSORS_AT_COMMIT is the only supported ResultSet holdability");
return this.createStatement(resultSetType, resultSetConcurrency);
}
/**
* Returns null. Type map is not yet imlemented.
*/
public Map getTypeMap()
throws SQLException
{
return null;
}
/**
* Type map is not yet implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public void setTypeMap(Map map)
throws SQLException
{
throw new UnsupportedOperationException("Type map is not yet implemented");
}
/**
* Parse the JDBC SQL into PostgreSQL.
*/
public String nativeSQL(String sql)
throws SQLException
{
return this.nativeSQL(sql, null);
}
public String nativeSQL(String sql, int[] paramCountRet)
{
StringBuffer buf = new StringBuffer();
int len = sql.length();
char inQuote = 0;
int paramIndex = 1;
for(int idx = 0; idx < len; ++idx)
{
char c = sql.charAt(idx);
switch(c)
{
case '\\':
// Next character is escaped. Keep both
// escape and the character.
//
buf.append(c);
if(++idx == len)
break;
c = sql.charAt(idx);
break;
case '\'':
case '"':
// Strings within quotes should not be subject
// to '?' -> '$n' substitution.
//
if(inQuote == c)
inQuote = 0;
else
inQuote = c;
break;
case '?':
if(inQuote == 0)
{
buf.append('$');
buf.append(paramIndex++);
continue;
}
break;
default:
if(inQuote == 0 && Character.isWhitespace(c))
{
// Strip of multiple whitespace outside of
// strings.
//
++idx;
while(idx < len && Character.isWhitespace(sql.charAt(idx)))
++idx;
--idx;
c = ' ';
}
}
buf.append(c);
}
if(paramCountRet != null)
paramCountRet[0] = paramIndex - 1;
return buf.toString();
}
/**
* Procedure calls are not yet implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public CallableStatement prepareCall(String sql) throws SQLException
{
throw new UnsupportedOperationException("Procedure calls are not yet implemented");
}
/**
* Procedure calls are not yet implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public CallableStatement prepareCall(
String sql,
int resultSetType,
int resultSetConcurrency)
throws SQLException
{
throw new UnsupportedOperationException("Procedure calls are not yet implemented");
}
/**
* Procedure calls are not yet implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public CallableStatement prepareCall(
String sql,
int resultSetType,
int resultSetConcurrency,
int resultSetHoldability)
throws SQLException
{
throw new UnsupportedOperationException("Procedure calls are not yet implemented");
}
/**
* Creates a new instance of SPIPreparedStatement.
*/
public PreparedStatement prepareStatement(String sql)
throws SQLException
{
if(this.isClosed())
throw new SQLException("Connection is closed");
int[] pcount = new int[] { 0 };
sql = this.nativeSQL(sql, pcount);
PreparedStatement stmt = new SPIPreparedStatement(this, sql, pcount[0]);
Invocation.current().manageStatement(stmt);
return stmt;
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
/**
* Creates a new instance of SPIPreparedStatement.
*
* @throws SQLException
* if the resultSetType differs from {@link
* ResultSet#TYPE_FORWARD_ONLY} or if the resultSetConcurrencty
* differs from {@link ResultSet#CONCUR_READ_ONLY}.
*/
public PreparedStatement prepareStatement(
String sql,
int resultSetType,
int resultSetConcurrency)
throws SQLException
{
if(resultSetType != ResultSet.TYPE_FORWARD_ONLY)
throw new UnsupportedOperationException("TYPE_FORWARD_ONLY supported ResultSet type");
if(resultSetConcurrency != ResultSet.CONCUR_READ_ONLY)
throw new UnsupportedOperationException("CONCUR_READ_ONLY is the supported ResultSet concurrency");
return prepareStatement(sql);
}
/**
* Creates a new instance of SPIPreparedStatement.
*
* @throws SQLException
* if the resultSetType differs from {@link
* ResultSet#TYPE_FORWARD_ONLY}, if the resultSetConcurrencty
* differs from {@link ResultSet#CONCUR_READ_ONLY}, or if the
* resultSetHoldability differs from {@link ResultSet#CLOSE_CURSORS_AT_COMMIT}.
*/
public PreparedStatement prepareStatement(
String sql,
int resultSetType,
int resultSetConcurrency,
int resultSetHoldability)
throws SQLException
{
if(resultSetHoldability != ResultSet.CLOSE_CURSORS_AT_COMMIT)
throw new UnsupportedOperationException(
"CLOSE_CURSORS_AT_COMMIT is the only supported ResultSet holdability");
return this.prepareStatement(sql, resultSetType, resultSetConcurrency);
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public PreparedStatement prepareStatement(String sql, String[] columnNames)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
public Savepoint setSavepoint()
throws SQLException
{
return this.rememberSavepoint(PgSavepoint.set("anonymous_savepoint"));
}
public Savepoint setSavepoint(String name)
throws SQLException
{
return this.rememberSavepoint(PgSavepoint.set(name));
}
static int getTypeForClass(Class c)
{
if(c.isArray() && !c.equals(byte[].class))
return Types.ARRAY;
Integer sqt = (Integer)s_sqlType2Class.get(c);
if(sqt != null)
return sqt.intValue();
/*
* This is not a well known JDBC type.
*/
return Types.OTHER;
}
private Savepoint rememberSavepoint(PgSavepoint sp)
throws SQLException
{
// Remember the first savepoint for each call-level so
// that it can be released when the function call ends. Releasing
// the first savepoint will release all subsequent savepoints.
//
Invocation invocation = Invocation.current();
Savepoint old = invocation.getSavepoint();
if(old == null)
invocation.setSavepoint(sp);
return sp;
}
private static void forgetSavepoint(PgSavepoint sp)
throws SQLException
{
Invocation invocation = Invocation.current();
if(invocation.getSavepoint() == sp)
invocation.setSavepoint(null);
}
public int[] getVersionNumber() throws SQLException
{
if (VERSION_NUMBER != null)
return VERSION_NUMBER;
ResultSet rs = createStatement().executeQuery(
"SELECT version()");
try
{
if (!rs.next())
throw new SQLException(
"Cannot retrieve product version number");
String ver = rs.getString(1);
Pattern p = Pattern.compile(
"^PostgreSQL\\s+(\\d+)\\.(\\d+)(.\\d+)?.*");
Matcher m = p.matcher(ver);
if(m.matches())
{
VERSION_NUMBER = new int[3];
VERSION_NUMBER[0] = Integer.parseInt(m.group(1));
VERSION_NUMBER[1] = Integer.parseInt(m.group(2));
String bugfix = m.group(3);
if(bugfix != null && bugfix.length() > 1)
VERSION_NUMBER[2] = Integer.parseInt(bugfix.substring(1));
return VERSION_NUMBER;
}
throw new SQLException(
"Unexpected product version string format: " +
ver);
}
catch (PatternSyntaxException e)
{
throw new SQLException(
"Error in product version string parsing: " +
e.getMessage());
}
finally
{
rs.close();
}
}
/*
* This implemetation uses the jdbc3Types array to support the jdbc3
* datatypes. Basically jdbc2 and jdbc3 are the same, except that
* jdbc3 adds some
*/
public int getSQLType(String pgTypeName)
{
if (pgTypeName == null)
return Types.OTHER;
for (int i = 0;i < JDBC3_TYPE_NAMES.length;i++)
if (pgTypeName.equals(JDBC3_TYPE_NAMES[i]))
return JDBC_TYPE_NUMBERS[i];
return Types.OTHER;
}
/*
* This returns the java.sql.Types type for a PG type oid
*
* @param oid PostgreSQL type oid
* @return the java.sql.Types type
* @exception SQLException if a database access error occurs
*/
public int getSQLType(Oid oid) throws SQLException
{
return getSQLType(getPGType(oid));
}
public String getPGType(Oid oid) throws SQLException
{
String typeName = null;
PreparedStatement query = null;
ResultSet rs = null;
try
{
query = prepareStatement("SELECT typname FROM pg_catalog.pg_type WHERE oid=?");
query.setObject(1, oid);
rs = query.executeQuery();
if (rs.next())
{
typeName = rs.getString(1);
}
else
{
throw new SQLException("Cannot find PG type with oid=" + oid);
}
}
finally
{
if (query != null)
{
query.close();
}
}
return typeName;
}
static Object basicCoersion(Class cls, Object value)
throws SQLException
{
if(value == null || cls.isInstance(value))
return value;
if(cls == String.class)
{
if(value instanceof Number
|| value instanceof Boolean
|| value instanceof Timestamp
|| value instanceof Date
|| value instanceof Time)
return value.toString();
}
else if(cls == URL.class && value instanceof String)
{
try
{
return new URL((String)value);
}
catch(MalformedURLException e)
{
throw new SQLException(e.toString());
}
}
throw new SQLException("Cannot derive a value of class " +
cls.getName() + " from an object of class " + value.getClass().getName());
}
static Number basicNumericCoersion(Class cls, Object value)
throws SQLException
{
if(value == null || value instanceof Number)
return (Number)value;
if(cls == int.class || cls == long.class || cls == short.class || cls == byte.class)
{
if(value instanceof String)
return Long.valueOf((String)value);
if(value instanceof Boolean)
return new Long(((Boolean)value).booleanValue() ? 1 : 0);
}
else if(cls == BigDecimal.class)
{
if(value instanceof String)
return new BigDecimal((String)value);
if(value instanceof Boolean)
return new BigDecimal(((Boolean)value).booleanValue() ? 1 : 0);
}
if(cls == double.class || cls == float.class)
{
if(value instanceof String)
return Double.valueOf((String)value);
if(value instanceof Boolean)
return new Double(((Boolean)value).booleanValue() ? 1 : 0);
}
throw new SQLException("Cannot derive a Number from an object of class " + value.getClass().getName());
}
static Object basicCalendricalCoersion(Class cls, Object value, Calendar cal)
throws SQLException
{
if(value == null)
return value;
if(cls.isInstance(value))
return value;
if(cls == Timestamp.class)
{
if(value instanceof Date)
{
cal.setTime((Date)value);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return new Timestamp(cal.getTimeInMillis());
}
else if(value instanceof Time)
{
cal.setTime((Date)value);
cal.set(1970, 0, 1);
return new Timestamp(cal.getTimeInMillis());
}
else if(value instanceof String)
{
return Timestamp.valueOf((String)value);
}
}
else if(cls == Date.class)
{
if(value instanceof Timestamp)
{
Timestamp ts = (Timestamp)value;
cal.setTime(ts);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return new Date(cal.getTimeInMillis());
}
else if(value instanceof String)
{
return Date.valueOf((String)value);
}
}
else if(cls == Time.class)
{
if(value instanceof Timestamp)
{
Timestamp ts = (Timestamp)value;
cal.setTime(ts);
cal.set(1970, 0, 1);
return new Time(cal.getTimeInMillis());
}
else if(value instanceof String)
{
return Time.valueOf((String)value);
}
}
throw new SQLException("Cannot derive a value of class " +
cls.getName() + " from an object of class " + value.getClass().getName());
}
/*
* This table holds the org.postgresql names for the types supported.
* Any types that map to Types.OTHER (eg POINT) don't go into this table.
* They default automatically to Types.OTHER
*
* Note: This must be in the same order as below.
*
* Tip: keep these grouped together by the Types. value
*/
public static final String JDBC3_TYPE_NAMES[] = {
"int2",
"int4", "oid",
"int8",
"cash", "money",
"numeric",
"float4",
"float8",
"bpchar", "char", "char2", "char4", "char8", "char16",
"varchar", "text", "name", "filename",
"bytea",
"bool",
"bit",
"date",
"time", "timetz",
"abstime", "timestamp", "timestamptz",
"_bool", "_char", "_int2", "_int4", "_text",
"_oid", "_varchar", "_int8", "_float4", "_float8",
"_abstime", "_date", "_time", "_timestamp", "_numeric",
"_bytea"
};
/*
* This table holds the JDBC type for each entry above.
*
* Note: This must be in the same order as above
*
* Tip: keep these grouped together by the Types. value
*/
public static final int JDBC_TYPE_NUMBERS[] =
{
Types.SMALLINT,
Types.INTEGER, Types.INTEGER,
Types.BIGINT,
Types.DOUBLE, Types.DOUBLE,
Types.NUMERIC,
Types.REAL,
Types.DOUBLE,
Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR,
Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
Types.BINARY,
Types.BIT,
Types.BIT,
Types.DATE,
Types.TIME, Types.TIME,
Types.TIMESTAMP, Types.TIMESTAMP, Types.TIMESTAMP,
Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY,
Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY,
Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY, Types.ARRAY,
Types.ARRAY
};
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/TriggerResultSet.java 0000664 0000767 0000770 00000006506 10630554503 030276 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import java.util.ArrayList;
import org.postgresql.pljava.internal.Tuple;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A single row, updateable ResultSet specially made for triggers. The
* changes made to this ResultSet are remembered and converted to a
* SPI_modify_tuple call prior to function return.
*
* @author Thomas Hallgren
*/
public class TriggerResultSet extends SingleRowResultSet
{
private ArrayList m_tupleChanges;
private final TupleDesc m_tupleDesc;
private final Tuple m_tuple;
private final boolean m_readOnly;
public TriggerResultSet(TupleDesc tupleDesc, Tuple tuple, boolean readOnly)
throws SQLException
{
m_tupleDesc = tupleDesc;
m_tuple = tuple;
m_readOnly = readOnly;
}
/**
* Cancel all changes made to the Tuple.
*/
public void cancelRowUpdates()
throws SQLException
{
m_tupleChanges = null;
}
/**
* Cancels all changes but doesn't really close the set.
*/
public void close()
throws SQLException
{
m_tupleChanges = null;
}
/**
* Returns the concurrency for this ResultSet.
* @see java.sql.ResultSet#getConcurrency
*/
public int getConcurrency() throws SQLException
{
return m_readOnly ? CONCUR_READ_ONLY : CONCUR_UPDATABLE;
}
/**
* Returns true if this row has been updated.
*/
public boolean rowUpdated()
throws SQLException
{
return m_tupleChanges != null;
}
/**
* Store this change for later use
*/
public void updateObject(int columnIndex, Object x)
throws SQLException
{
if(m_readOnly)
throw new UnsupportedFeatureException("ResultSet is read-only");
if(m_tupleChanges == null)
m_tupleChanges = new ArrayList();
m_tupleChanges.add(new Integer(columnIndex));
m_tupleChanges.add(x);
}
/**
* Return a 2 element array describing the changes that has been made to
* the contained Tuple. The first element is an int[] containing
* the index of each changed value. The second element is an Object[]
* with containing the corresponding values.
*
* @return The 2 element array or null if no change has been made.
*/
public Object[] getChangeIndexesAndValues()
{
ArrayList changes = m_tupleChanges;
if(changes == null)
return null;
int top = changes.size();
if(changes.size() == 0)
return null;
top /= 2;
int[] indexes = new int[top];
Object[] values = new Object[top];
int vIdx = 0;
for(int idx = 0; idx < top; ++idx)
{
indexes[idx] = ((Integer)changes.get(vIdx++)).intValue();
values[idx] = changes.get(vIdx++);
}
return new Object[] { m_tuple, indexes, values };
}
protected Object getObjectValue(int columnIndex)
throws SQLException
{
// Check if this value has been changed.
//
ArrayList changes = m_tupleChanges;
if(changes != null)
{
int top = changes.size();
for(int idx = 0; idx < top; idx += 2)
if(columnIndex == ((Integer)changes.get(idx)).intValue())
return changes.get(idx + 1);
}
return m_tuple.getObject(this.getTupleDesc(), columnIndex);
}
protected final TupleDesc getTupleDesc()
{
return m_tupleDesc;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ResultSetBase.java 0000664 0000767 0000770 00000007116 10630554503 027543 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
/**
* A ResultSet base provides methods that are common both for
* a SyntheticResultSet (which is not associated with a
* statement) and SPIResultSet.
*
* @author Filip Hrbek
*/
abstract class ResultSetBase extends ReadOnlyResultSet
{
private int m_fetchSize;
private int m_row;
ResultSetBase(int fetchSize)
{
m_fetchSize = fetchSize;
m_row = 0; // First row is 1 so 0 is on undefined position.
}
public int getFetchDirection()
throws SQLException
{
return FETCH_FORWARD;
}
public final int getFetchSize()
throws SQLException
{
return m_fetchSize;
}
public final int getRow()
throws SQLException
{
return m_row;
}
public int getType()
throws SQLException
{
return TYPE_FORWARD_ONLY;
}
/**
* Cursor positoning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public void afterLast()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Cursor positoning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public void beforeFirst()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
public void close()
throws SQLException
{
m_row = -1;
}
/**
* Cursor positioning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean first() throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
public boolean isAfterLast() throws SQLException
{
return m_row < 0;
}
public boolean isBeforeFirst() throws SQLException
{
return m_row == 0;
}
public boolean isFirst() throws SQLException
{
return m_row == 1;
}
/**
* Cursor positioning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean last()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Reverse positioning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean previous()
throws SQLException
{
throw new UnsupportedFeatureException("Reverse positioning");
}
/**
* Cursor positioning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean absolute(int row)
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Cursor positioning is not implemented yet.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean relative(int rows)
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Only {@link java.sql.ResultSet#FETCH_FORWARD} is supported.
* @throws SQLException indicating that this feature is not supported
* for other values on direction.
*/
public void setFetchDirection(int direction)
throws SQLException
{
if(direction != FETCH_FORWARD)
throw new UnsupportedFeatureException("Non forward fetch direction");
}
public void setFetchSize(int fetchSize)
throws SQLException
{
if(fetchSize <= 0)
throw new IllegalArgumentException("Illegal fetch size for ResultSet");
m_fetchSize = fetchSize;
}
final void setRow(int row)
{
m_row = row;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/StatementClosedException.java 0000664 0000767 0000770 00000001240 10630554503 031763 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class StatementClosedException extends SQLException
{
private static final long serialVersionUID = 9108917755099200271L;
public static final String INVALID_SQL_STATEMENT_NAME = "26000";
public StatementClosedException()
{
super("Statement is closed", INVALID_SQL_STATEMENT_NAME);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIPreparedStatement.java 0000664 0000767 0000770 00000024543 10630554503 031024 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Arrays;
import java.util.Calendar;
import org.postgresql.pljava.internal.ExecutionPlan;
import org.postgresql.pljava.internal.Oid;
/**
*
* @author Thomas Hallgren
*/
public class SPIPreparedStatement extends SPIStatement implements PreparedStatement
{
private final Oid[] m_typeIds;
private final Object[] m_values;
private final int[] m_sqlTypes;
private final String m_statement;
private ExecutionPlan m_plan;
public SPIPreparedStatement(SPIConnection conn, String statement, int paramCount)
{
super(conn);
m_statement = statement;
m_typeIds = new Oid[paramCount];
m_values = new Object[paramCount];
m_sqlTypes = new int[paramCount];
Arrays.fill(m_sqlTypes, Types.NULL);
}
public void close()
throws SQLException
{
if(m_plan != null)
{
m_plan.close();
m_plan = null;
}
this.clearParameters();
super.close();
Invocation.current().forgetStatement(this);
}
public ResultSet executeQuery()
throws SQLException
{
this.execute();
return this.getResultSet();
}
public int executeUpdate()
throws SQLException
{
this.execute();
return this.getUpdateCount();
}
public void setNull(int columnIndex, int sqlType)
throws SQLException
{
this.setObject(columnIndex, null, sqlType);
}
public void setBoolean(int columnIndex, boolean value) throws SQLException
{
this.setObject(columnIndex, value ? Boolean.TRUE : Boolean.FALSE, Types.BOOLEAN);
}
public void setByte(int columnIndex, byte value) throws SQLException
{
this.setObject(columnIndex, new Byte(value), Types.TINYINT);
}
public void setShort(int columnIndex, short value) throws SQLException
{
this.setObject(columnIndex, new Short(value), Types.SMALLINT);
}
public void setInt(int columnIndex, int value) throws SQLException
{
this.setObject(columnIndex, new Integer(value), Types.INTEGER);
}
public void setLong(int columnIndex, long value) throws SQLException
{
this.setObject(columnIndex, new Long(value), Types.BIGINT);
}
public void setFloat(int columnIndex, float value) throws SQLException
{
this.setObject(columnIndex, new Float(value), Types.FLOAT);
}
public void setDouble(int columnIndex, double value) throws SQLException
{
this.setObject(columnIndex, new Double(value), Types.DOUBLE);
}
public void setBigDecimal(int columnIndex, BigDecimal value) throws SQLException
{
this.setObject(columnIndex, value, Types.DECIMAL);
}
public void setString(int columnIndex, String value) throws SQLException
{
this.setObject(columnIndex, value, Types.VARCHAR);
}
public void setBytes(int columnIndex, byte[] value) throws SQLException
{
this.setObject(columnIndex, value, Types.VARBINARY);
}
public void setDate(int columnIndex, Date value) throws SQLException
{
this.setObject(columnIndex, value, Types.DATE);
}
public void setTime(int columnIndex, Time value) throws SQLException
{
this.setObject(columnIndex, value, Types.TIME);
}
public void setTimestamp(int columnIndex, Timestamp value) throws SQLException
{
this.setObject(columnIndex, value, Types.TIMESTAMP);
}
public void setAsciiStream(int columnIndex, InputStream value, int length) throws SQLException
{
try
{
this.setObject(columnIndex,
new ClobValue(new InputStreamReader(value, "US-ASCII"), length),
Types.CLOB);
}
catch(UnsupportedEncodingException e)
{
throw new SQLException("US-ASCII encoding is not supported by this JVM");
}
}
/**
* @deprecated
*/
public void setUnicodeStream(int columnIndex, InputStream value, int arg2) throws SQLException
{
throw new UnsupportedFeatureException("PreparedStatement.setUnicodeStream");
}
public void setBinaryStream(int columnIndex, InputStream value, int length) throws SQLException
{
this.setObject(columnIndex, new BlobValue(value, length), Types.BLOB);
}
public void clearParameters()
throws SQLException
{
Arrays.fill(m_values, null);
Arrays.fill(m_sqlTypes, Types.NULL);
}
public void setObject(int columnIndex, Object value, int sqlType, int scale)
throws SQLException
{
this.setObject(columnIndex, value, sqlType);
}
public void setObject(int columnIndex, Object value, int sqlType)
throws SQLException
{
if(columnIndex < 1 || columnIndex > m_sqlTypes.length)
throw new SQLException("Illegal parameter index");
Oid id = (sqlType == Types.OTHER)
? Oid.forJavaClass(value.getClass())
: Oid.forSqlType(sqlType);
// Default to String.
//
if(id == null)
id = Oid.forSqlType(Types.VARCHAR);
Oid op = m_typeIds[--columnIndex];
if(op == null)
m_typeIds[columnIndex] = id;
else if(!op.equals(id))
{
m_typeIds[columnIndex] = id;
// We must re-prepare
//
if(m_plan != null)
m_plan.close();
m_plan = null;
}
m_sqlTypes[columnIndex] = sqlType;
m_values[columnIndex] = value;
}
public void setObject(int columnIndex, Object value)
throws SQLException
{
if(value == null)
throw new SQLException("Can't assign null unless the SQL type is known");
this.setObject(columnIndex, value, SPIConnection.getTypeForClass(value.getClass()));
}
/**
* Obtains the XOPEN SQL types for the parameters.
* @return The array of types.
*/
private int[] getSqlTypes()
{
int idx = m_sqlTypes.length;
int[] types = (int[])m_sqlTypes.clone();
while(--idx >= 0)
{
if(types[idx] == Types.NULL)
types[idx] = Types.VARCHAR; // Default.
}
return types;
}
public boolean execute()
throws SQLException
{
int[] sqlTypes = m_sqlTypes;
int idx = sqlTypes.length;
while(--idx >= 0)
if(sqlTypes[idx] == Types.NULL)
throw new SQLException("Not all parameters have been set");
if(m_plan == null)
m_plan = ExecutionPlan.prepare(m_statement, m_typeIds);
boolean result = this.executePlan(m_plan, m_values);
this.clearParameters(); // Parameters are cleared upon successful completion.
return result;
}
/**
* The prepared statement cannot be used for executing oter statements.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean execute(String statement)
throws SQLException
{
throw new UnsupportedFeatureException("Can't execute other statements using a prepared statement");
}
public void addBatch()
throws SQLException
{
this.internalAddBatch(m_values.clone());
this.clearParameters(); // Parameters are cleared upon successful completion.
}
/**
* The prepared statement cannot have other statements added too it.
* @throws SQLException indicating that this feature is not supported.
*/
public void addBatch(String statement)
throws SQLException
{
throw new UnsupportedFeatureException("Can't add batch statements to a prepared statement");
}
public void setCharacterStream(int columnIndex, Reader value, int length)
throws SQLException
{
this.setObject(columnIndex, new ClobValue(value, length), Types.CLOB);
}
public void setRef(int columnIndex, Ref value) throws SQLException
{
this.setObject(columnIndex, value, Types.REF);
}
public void setBlob(int columnIndex, Blob value) throws SQLException
{
this.setObject(columnIndex, value, Types.BLOB);
}
public void setClob(int columnIndex, Clob value) throws SQLException
{
this.setObject(columnIndex, value, Types.CLOB);
}
public void setArray(int columnIndex, Array value) throws SQLException
{
this.setObject(columnIndex, value, Types.ARRAY);
}
/**
* ResultSetMetaData is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public ResultSetMetaData getMetaData()
throws SQLException
{
throw new UnsupportedFeatureException("ResultSet meta data is not yet implemented");
}
public void setDate(int columnIndex, Date value, Calendar cal)
throws SQLException
{
if(cal == null || cal == Calendar.getInstance())
this.setObject(columnIndex, value, Types.DATE);
throw new UnsupportedFeatureException("Setting date using explicit Calendar");
}
public void setTime(int columnIndex, Time value, Calendar cal)
throws SQLException
{
if(cal == null || cal == Calendar.getInstance())
this.setObject(columnIndex, value, Types.TIME);
throw new UnsupportedFeatureException("Setting time using explicit Calendar");
}
public void setTimestamp(int columnIndex, Timestamp value, Calendar cal)
throws SQLException
{
if(cal == null || cal == Calendar.getInstance())
this.setObject(columnIndex, value, Types.TIMESTAMP);
throw new UnsupportedFeatureException("Setting time using explicit Calendar");
}
public void setNull(int columnIndex, int sqlType, String typeName)
throws SQLException
{
this.setNull(columnIndex, sqlType);
}
public void setURL(int columnIndex, URL value) throws SQLException
{
this.setObject(columnIndex, value, Types.DATALINK);
}
public String toString()
{
return m_statement;
}
/**
* Due to the design of the SPI_prepare, it is currently impossible to
* obtain the correct parameter meta data before all the parameters have been
* set, hence a ParameterMetaData obtained prior to setting the paramteres
* will have all parameters set to the default type {@link Types#VARCHAR}.
* Once the parameters have been set, a fair attempt is made to generate this
* object based on the supplied values.
* @return The meta data for parameter values.
*/
public ParameterMetaData getParameterMetaData()
throws SQLException
{
return new SPIParameterMetaData(this.getSqlTypes());
}
protected int executeBatchEntry(Object batchEntry)
throws SQLException
{
int ret = SUCCESS_NO_INFO;
System.arraycopy(batchEntry, 0, m_values, 0, m_values.length);
if(this.execute())
this.getResultSet().close();
else
{
int updCount = this.getUpdateCount();
if(updCount >= 0)
ret = updCount;
}
return ret;
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SQLOutputToTuple.java 0000664 0000767 0000770 00000011136 10630554503 030210 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.SQLData;
import java.sql.SQLException;
import java.sql.SQLOutput;
import java.sql.Struct;
import java.sql.Time;
import java.sql.Timestamp;
import org.postgresql.pljava.internal.Tuple;
import org.postgresql.pljava.internal.TupleDesc;
/**
* @author Thomas Hallgren
*/
public class SQLOutputToTuple implements SQLOutput
{
private final Object[] m_values;
private final TupleDesc m_tupleDesc;
private int m_index;
private Tuple m_tuple;
public SQLOutputToTuple(TupleDesc tupleDesc)
{
m_tupleDesc = tupleDesc;
m_values = new Object[tupleDesc.size()];
m_index = 0;
}
/**
* Creates a tuple from the written values and returns its native pointer.
* All values must have been written. This method is called automatically by
* the trigger handler and should not be called in any other way.
*
* @return The Tuple reflecting the current row values.
* @throws SQLException
*/
public long getTuple()
throws SQLException
{
if(m_tuple != null)
return m_tuple.getNativePointer();
if(m_index < m_values.length)
throw new SQLException("Too few values have been written");
m_tuple = m_tupleDesc.formTuple(m_values);
return m_tuple.getNativePointer();
}
public void writeArray(Array value) throws SQLException
{
this.writeValue(value);
}
public void writeAsciiStream(InputStream value) throws SQLException
{
try
{
Reader rdr = new BufferedReader(new InputStreamReader(value, "US-ASCII"));
this.writeClob(new ClobValue(rdr, ClobValue.getReaderLength(rdr)));
}
catch(UnsupportedEncodingException e)
{
throw new SQLException(e.toString());
}
}
public void writeBigDecimal(BigDecimal value) throws SQLException
{
this.writeValue(value);
}
public void writeBinaryStream(InputStream value) throws SQLException
{
if(!value.markSupported())
value = new BufferedInputStream(value);
this.writeBlob(new BlobValue(value, BlobValue.getStreamLength(value)));
}
public void writeBlob(Blob value) throws SQLException
{
this.writeValue(value);
}
public void writeBoolean(boolean value) throws SQLException
{
this.writeValue(value ? Boolean.TRUE : Boolean.FALSE);
}
public void writeByte(byte value) throws SQLException
{
this.writeValue(new Byte(value));
}
public void writeBytes(byte[] value) throws SQLException
{
this.writeValue(value);
}
public void writeCharacterStream(Reader value) throws SQLException
{
if(!value.markSupported())
value = new BufferedReader(value);
this.writeClob(new ClobValue(value, ClobValue.getReaderLength(value)));
}
public void writeClob(Clob value) throws SQLException
{
this.writeValue(value);
}
public void writeDate(Date value) throws SQLException
{
this.writeValue(value);
}
public void writeDouble(double value) throws SQLException
{
this.writeValue(new Double(value));
}
public void writeFloat(float value) throws SQLException
{
this.writeValue(new Float(value));
}
public void writeInt(int value) throws SQLException
{
this.writeValue(new Integer(value));
}
public void writeLong(long value) throws SQLException
{
this.writeValue(new Long(value));
}
public void writeObject(SQLData value) throws SQLException
{
this.writeValue(value);
}
public void writeRef(Ref value) throws SQLException
{
this.writeValue(value);
}
public void writeShort(short value) throws SQLException
{
this.writeValue(new Short(value));
}
public void writeString(String value) throws SQLException
{
this.writeValue(value);
}
public void writeStruct(Struct value) throws SQLException
{
this.writeValue(value);
}
public void writeTime(Time value) throws SQLException
{
this.writeValue(value);
}
public void writeTimestamp(Timestamp value) throws SQLException
{
this.writeValue(value);
}
public void writeURL(URL value) throws SQLException
{
this.writeValue(value.toString());
}
private void writeValue(Object value) throws SQLException
{
if(m_index >= m_values.length)
throw new SQLException("Tuple cannot take more values");
m_values[m_index++] = value;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SQLInputFromTuple.java 0000664 0000767 0000770 00000011244 10630554503 030330 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.SQLInput;
import java.sql.Time;
import java.sql.Timestamp;
import org.postgresql.pljava.internal.Backend;
import org.postgresql.pljava.internal.JavaWrapper;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A single row, updateable ResultSet specially made for triggers. The
* changes made to this ResultSet are remembered and converted to a
* SPI_modify_tuple call prior to function return.
*
* @author Thomas Hallgren
*/
public class SQLInputFromTuple extends JavaWrapper implements SQLInput
{
private int m_index;
private final TupleDesc m_tupleDesc;
private boolean m_wasNull;
public SQLInputFromTuple(long heapTupleHeaderPointer, TupleDesc tupleDesc)
throws SQLException
{
super(heapTupleHeaderPointer);
m_tupleDesc = tupleDesc;
m_index = 0;
m_wasNull = false;
}
public Array readArray() throws SQLException
{
return (Array)this.readValue(Array.class);
}
public InputStream readAsciiStream() throws SQLException
{
Clob c = this.readClob();
return (c == null) ? null : c.getAsciiStream();
}
public BigDecimal readBigDecimal() throws SQLException
{
return (BigDecimal)this.readValue(BigDecimal.class);
}
public InputStream readBinaryStream() throws SQLException
{
Blob b = this.readBlob();
return (b == null) ? null : b.getBinaryStream();
}
public Blob readBlob() throws SQLException
{
byte[] bytes = this.readBytes();
return (bytes == null) ? null : new BlobValue(bytes);
}
public boolean readBoolean() throws SQLException
{
Boolean b = (Boolean)this.readValue(Boolean.class);
return (b == null) ? false : b.booleanValue();
}
public byte readByte() throws SQLException
{
Number b = this.readNumber(byte.class);
return (b == null) ? 0 : b.byteValue();
}
public byte[] readBytes() throws SQLException
{
return (byte[])this.readValue(byte[].class);
}
public Reader readCharacterStream() throws SQLException
{
Clob c = this.readClob();
return (c == null) ? null : c.getCharacterStream();
}
public Clob readClob() throws SQLException
{
String str = this.readString();
return (str == null) ? null : new ClobValue(str);
}
public Date readDate() throws SQLException
{
return (Date)this.readValue(Date.class);
}
public double readDouble() throws SQLException
{
Number d = this.readNumber(double.class);
return (d == null) ? 0 : d.doubleValue();
}
public float readFloat() throws SQLException
{
Number f = this.readNumber(float.class);
return (f == null) ? 0 : f.floatValue();
}
public int readInt() throws SQLException
{
Number i = this.readNumber(int.class);
return (i == null) ? 0 : i.intValue();
}
public long readLong() throws SQLException
{
Number l = this.readNumber(long.class);
return (l == null) ? 0 : l.longValue();
}
public Object readObject() throws SQLException
{
if(m_index < m_tupleDesc.size())
{
Object v;
synchronized(Backend.THREADLOCK)
{
v = _getObject(this.getNativePointer(), m_tupleDesc.getNativePointer(), ++m_index);
}
m_wasNull = v == null;
return v;
}
throw new SQLException("Tuple has no more columns");
}
public Ref readRef() throws SQLException
{
return (Ref)this.readValue(Ref.class);
}
public short readShort() throws SQLException
{
Number s = this.readNumber(short.class);
return (s == null) ? 0 : s.shortValue();
}
public String readString() throws SQLException
{
return (String)this.readValue(String.class);
}
public Time readTime() throws SQLException
{
return (Time)this.readValue(Time.class);
}
public Timestamp readTimestamp() throws SQLException
{
return (Timestamp)this.readValue(Timestamp.class);
}
public URL readURL() throws SQLException
{
return (URL)this.readValue(URL.class);
}
public boolean wasNull() throws SQLException
{
return m_wasNull;
}
private Number readNumber(Class numberClass) throws SQLException
{
return SPIConnection.basicNumericCoersion(numberClass, this.readObject());
}
private Object readValue(Class valueClass) throws SQLException
{
return SPIConnection.basicCoersion(valueClass, this.readObject());
}
protected native void _free(long pointer);
private static native Object _getObject(long pointer, long tupleDescPointer, int index)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIDriver.java 0000664 0000767 0000770 00000003415 10630554503 026623 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.util.Properties;
/**
*
* @author Thomas Hallgren
*/
public class SPIDriver implements Driver
{
private static final String s_defaultURL = "jdbc:default:connection";
private static final int s_defaultURLLen = s_defaultURL.length();
private static final Connection s_defaultConn = new SPIConnection();
private static final DriverPropertyInfo[] s_noInfo = new DriverPropertyInfo[0];
static
{
try
{
DriverManager.registerDriver(new SPIDriver());
}
catch(SQLException e)
{
throw new ExceptionInInitializerError(e);
}
}
public Connection connect(String url, Properties info)
throws SQLException
{
return this.acceptsURL(url)
? s_defaultConn
: null;
}
public boolean acceptsURL(String url)
throws SQLException
{
if(url.startsWith(s_defaultURL))
{
// Accept extra info at end provided the defaultURL is
// delimited by a ':'
//
if(url.length() == s_defaultURLLen || url.charAt(s_defaultURLLen) == ':')
return true;
}
return false;
}
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
throws SQLException
{
return s_noInfo;
}
public int getMajorVersion()
{
return 1;
}
public int getMinorVersion()
{
return 0;
}
public boolean jdbcCompliant()
{
return false; // Not all functionality is supported at present.
}
static Connection getDefault()
{
return s_defaultConn;
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/BlobValue.java 0000664 0000767 0000770 00000012162 10630554503 026666 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.sql.Blob;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class BlobValue extends InputStream implements Blob
{
public static int getStreamLength(InputStream value) throws SQLException
{
try
{
value.mark(Integer.MAX_VALUE);
long length = value.skip(Long.MAX_VALUE);
if(length > Integer.MAX_VALUE)
throw new SQLException("stream content too large");
value.reset();
return (int)length;
}
catch(IOException e)
{
throw new SQLException(e.getMessage());
}
}
private long m_markPos;
private final long m_nBytes;
private final InputStream m_stream;
private long m_streamPos;
public BlobValue(byte[] bytes)
{
this(new ByteArrayInputStream(bytes), bytes.length);
}
public BlobValue(InputStream stream, long nBytes)
{
m_stream = stream;
m_nBytes = nBytes;
m_streamPos = 0L;
m_markPos = 0L;
}
//***************************************
// Implementation of java.io.InputStream
//***************************************
public int available()
throws IOException
{
return m_stream.available();
}
public InputStream getBinaryStream()
{
return this;
}
public byte[] getBytes(long pos, int length)
throws SQLException
{
if(pos < 0L || length < 0)
throw new IllegalArgumentException();
if(length == 0)
return new byte[0];
if(pos + length > m_nBytes)
throw new SQLException("Attempt to read beyond end of Blob data");
long skip = pos - m_streamPos;
if(skip < 0)
throw new SQLException("Cannot position Blob stream backwards");
try
{
if(skip > 0)
this.skip(skip);
byte[] buf = new byte[length];
this.read(buf);
return buf;
}
catch(IOException e)
{
throw new SQLException("Error reading Blob data: " + e.getMessage());
}
}
/**
* Called from within...
* @param buf a buffer that reflects the internally allocated bytea buffer.
* This size of this buffer will be exactly the size returned by a call to
* {@link #length()}.
* @throws IOException
*/
public void getContents(ByteBuffer buf)
throws IOException
{
int rs = 0;
if(buf.hasArray())
{
byte[] bytes = buf.array();
rs = m_stream.read(bytes);
}
else
{
byte[] trBuf = new byte[1024];
int br;
while((br = m_stream.read(trBuf)) > 0)
{
buf.put(trBuf, 0, br);
rs += br;
}
}
if(rs != m_nBytes)
throw new IOException("Not all bytes could be read");
m_streamPos += rs;
}
//***************************************
// Implementation of java.sql.Blob
//***************************************
public long length()
{
return m_nBytes;
}
public synchronized void mark(int readLimit)
{
m_stream.mark(readLimit);
m_markPos = m_streamPos;
}
public boolean markSupported()
{
return m_stream.markSupported();
}
/**
* Not supported.
*/
public long position(Blob pattern, long start)
{
throw new UnsupportedOperationException();
}
/**
* Not supported.
*/
public long position(byte[] pattern, long start)
{
throw new UnsupportedOperationException();
}
public synchronized int read()
throws IOException
{
int rs = m_stream.read();
m_streamPos++;
return rs;
}
public synchronized int read(byte[] b)
throws IOException
{
int rs = m_stream.read(b);
m_streamPos += rs;
return rs;
}
public synchronized int read(byte[] b, int off, int len)
throws IOException
{
int rs = m_stream.read(b, off, len);
m_streamPos += rs;
return rs;
}
public synchronized void reset()
throws IOException
{
m_stream.reset();
m_streamPos = m_markPos;
}
//*************************************************************************
// Implementation of java.sql.Blob JDK 1.4 methods
//
// Those method are intended to provide a channel to the underlying data
// storage as an alternatvie to the setBinaryStream
// on the preparedStatement and are not implemented by the BlobValue.
//
//*************************************************************************
/**
* In this method is not supported by BlobValue
*/
public OutputStream setBinaryStream(long pos)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by BlobValue
*/
public int setBytes(long pos, byte[] bytes)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by BlobValue
*/
public int setBytes(long pos, byte[] bytes, int offset, int len)
{
throw new UnsupportedOperationException();
}
public synchronized long skip(long nBytes)
throws IOException
{
long skipped = m_stream.skip(nBytes);
m_streamPos += skipped;
return skipped;
}
/**
* In this method is not supported by BlobValue
*/
public void truncate(long len)
{
throw new UnsupportedOperationException();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/Invocation.java 0000664 0000767 0000770 00000007355 10630554503 027134 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.logging.Logger;
import org.postgresql.pljava.internal.Backend;
import org.postgresql.pljava.internal.PgSavepoint;
/**
* @author Thomas Hallgren
*/
public class Invocation
{
/**
* The current "stack" of invocations.
*/
private static Invocation[] s_levels = new Invocation[10];
/**
* Nesting level for this invocation
*/
private final int m_nestingLevel;
/**
* Top level savepoint relative to this invocation.
*/
private PgSavepoint m_savepoint;
private Invocation(int level)
{
m_nestingLevel = level;
}
/**
* @return The nesting level of this invocation
*/
public int getNestingLevel()
{
return m_nestingLevel;
}
/**
* @return Returns the savePoint.
*/
final PgSavepoint getSavepoint()
{
return m_savepoint;
}
private ArrayList m_preparedStatements;
final void manageStatement(PreparedStatement statement)
{
if(m_preparedStatements == null)
m_preparedStatements = new ArrayList();
m_preparedStatements.add(statement);
}
final void forgetStatement(PreparedStatement statement)
{
if(m_preparedStatements == null)
return;
int idx = m_preparedStatements.size();
while(--idx >= 0)
if(m_preparedStatements.get(idx) == statement)
{
m_preparedStatements.remove(idx);
return;
}
}
/**
* @param savepoint The savepoint to set.
*/
final void setSavepoint(PgSavepoint savepoint)
{
m_savepoint = savepoint;
}
/**
* Called from the backend when the invokation exits. Should
* not be invoked any other way.
*/
public void onExit()
throws SQLException
{
try
{
if(m_savepoint != null)
m_savepoint.onInvocationExit(SPIDriver.getDefault());
if(m_preparedStatements != null)
{
int idx = m_preparedStatements.size();
if(idx > 0)
{
Logger w = Logger.getAnonymousLogger();
w.warning(
"Closing " + idx + " \"forgotten\" statement"
+ ((idx > 1) ? "s" : ""));
while(--idx >= 0)
{
PreparedStatement stmt = (PreparedStatement)m_preparedStatements.get(idx);
w.fine("Closed: " + stmt);
stmt.close();
}
}
}
}
finally
{
s_levels[m_nestingLevel] = null;
}
}
/**
* @return The current invocation
*/
public static Invocation current()
{
synchronized(Backend.THREADLOCK)
{
Invocation curr = _getCurrent();
if(curr != null)
return curr;
int level = _getNestingLevel();
int top = s_levels.length;
if(level < top)
{
curr = s_levels[level];
if(curr != null)
{
curr._register();
return curr;
}
}
else
{
int newSize = top;
do { newSize <<= 2; } while(newSize <= level);
Invocation[] levels = new Invocation[newSize];
System.arraycopy(s_levels, 0, levels, 0, top);
s_levels = levels;
}
curr = new Invocation(level);
s_levels[level] = curr;
curr._register();
return curr;
}
}
static void clearErrorCondition()
{
synchronized(Backend.THREADLOCK)
{
_clearErrorCondition();
}
}
/**
* Register this Invocation so that it receives the onExit callback
*/
private native void _register();
/**
* Returns the current invocation or null if no invocation has been
* registered yet.
*/
private native static Invocation _getCurrent();
/**
* Returns the current nesting level
*/
private native static int _getNestingLevel();
/**
* Clears the error condition set by elog(ERROR)
*/
private native static void _clearErrorCondition();
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SyntheticResultSetMetaData.java 0000664 0000767 0000770 00000007355 10630554503 032251 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import org.postgresql.pljava.internal.Oid;
/**
* Implementation of ResultSetMetaData for SyntheticResultSet
*
* @author Filip Hrbek
*/
public class SyntheticResultSetMetaData extends AbstractResultSetMetaData
{
private final ResultSetField[] m_fields;
/**
* Constructor.
* @param fields Array of ResultSetField
*/
public SyntheticResultSetMetaData(ResultSetField[] fields)
{
super();
m_fields = fields;
}
/**
* Returns the number of columns in this ResultSet object.
*
* @return the number of columns
* @exception SQLException if a database access error occurs
*/
public final int getColumnCount() throws SQLException
{
return m_fields.length;
}
/**
* Indicates whether the designated column is automatically numbered, thus read-only.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isAutoIncrement(int column) throws SQLException
{
checkColumnIndex(column);
//SyntheticResultSet has no autoincrement columns
return false;
}
/**
* Gets the designated column's suggested title for use in printouts and
* displays.
*
* @param column the first column is 1, the second is 2, ...
* @return the suggested column title
* @exception SQLException if a database access error occurs
*/
public final String getColumnLabel(int column) throws SQLException
{
checkColumnIndex(column);
return m_fields[column-1].getColumnLabel();
}
//--------------------------JDBC 2.0-----------------------------------
/**
* Returns the fully-qualified name of the Java class whose instances
* are manufactured if the method ResultSet.getObject
* is called to retrieve a value
* from the column. ResultSet.getObject may return a subclass of the
* class returned by this method.
*
* @param column the first column is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* ResultSet.getObject to retrieve the value in the specified
* column. This is the class name used for custom mapping.
* @exception SQLException if a database access error occurs
* @since 1.2
*/
public final String getColumnClassName(int column) throws SQLException
{
checkColumnIndex(column);
return m_fields[column-1].getJavaClass().getName();
}
/**
* Checks if the column index is valid.
*
* @param column the first column is 1, the second is 2, ...
* @exception SQLException if the column is out of index bounds
*/
protected final void checkColumnIndex(int column) throws SQLException
{
if (column < 1 || column > m_fields.length)
{
throw new SQLException("Invalid column index: " + column);
}
}
/**
* Gets column OID
* @param column Column index
* @return column OID
* @throws SQLException if an error occurs
*/
protected final Oid getOid(int column) throws SQLException
{
return m_fields[column-1].getOID();
}
/**
* Gets column length
* @param column Column index
* @return column length
* @throws SQLException if an error occurs
*/
protected final int getFieldLength(int column) throws SQLException
{
return m_fields[column-1].getLength();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ObjectResultSet.java 0000664 0000767 0000770 00000022753 10630554503 030103 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Time;
import java.sql.Timestamp;
import java.math.BigDecimal;
import java.net.URL;
import java.util.Calendar;
import java.util.Map;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
/**
* @author Thomas Hallgren
*/
public abstract class ObjectResultSet extends AbstractResultSet
{
private boolean m_wasNull = false;
/**
* This is a noop since warnings are not supported.
*/
public void clearWarnings()
throws SQLException
{
}
public Array getArray(int columnIndex)
throws SQLException
{
return (Array)this.getValue(columnIndex, Array.class);
}
public InputStream getAsciiStream(int columnIndex)
throws SQLException
{
Clob c = this.getClob(columnIndex);
return (c == null) ? null : c.getAsciiStream();
}
public BigDecimal getBigDecimal(int columnIndex)
throws SQLException
{
return (BigDecimal)this.getValue(columnIndex, BigDecimal.class);
}
/**
* @deprecated
*/
public BigDecimal getBigDecimal(int columnIndex, int scale)
throws SQLException
{
throw new UnsupportedFeatureException("getBigDecimal(int, int)");
}
public InputStream getBinaryStream(int columnIndex)
throws SQLException
{
Blob b = this.getBlob(columnIndex);
return (b == null) ? null : b.getBinaryStream();
}
public Blob getBlob(int columnIndex)
throws SQLException
{
byte[] bytes = this.getBytes(columnIndex);
return (bytes == null) ? null : new BlobValue(bytes);
}
public boolean getBoolean(int columnIndex)
throws SQLException
{
Boolean b = (Boolean)this.getValue(columnIndex, Boolean.class);
return (b == null) ? false : b.booleanValue();
}
public byte getByte(int columnIndex)
throws SQLException
{
Number b = this.getNumber(columnIndex, byte.class);
return (b == null) ? 0 : b.byteValue();
}
public byte[] getBytes(int columnIndex)
throws SQLException
{
return (byte[])this.getValue(columnIndex, byte[].class);
}
public Reader getCharacterStream(int columnIndex)
throws SQLException
{
Clob c = this.getClob(columnIndex);
return (c == null) ? null : c.getCharacterStream();
}
public Clob getClob(int columnIndex)
throws SQLException
{
String str = this.getString(columnIndex);
return (str == null) ? null : new ClobValue(str);
}
public Date getDate(int columnIndex)
throws SQLException
{
return (Date)this.getValue(columnIndex, Date.class);
}
public Date getDate(int columnIndex, Calendar cal)
throws SQLException
{
return (Date)this.getValue(columnIndex, Date.class, cal);
}
public double getDouble(int columnIndex)
throws SQLException
{
Number d = this.getNumber(columnIndex, double.class);
return (d == null) ? 0 : d.doubleValue();
}
public float getFloat(int columnIndex)
throws SQLException
{
Number f = this.getNumber(columnIndex, float.class);
return (f == null) ? 0 : f.floatValue();
}
public int getInt(int columnIndex)
throws SQLException
{
Number i = this.getNumber(columnIndex, int.class);
return (i == null) ? 0 : i.intValue();
}
public long getLong(int columnIndex)
throws SQLException
{
Number l = this.getNumber(columnIndex, long.class);
return (l == null) ? 0 : l.longValue();
}
/**
* ResultSetMetaData is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public ResultSetMetaData getMetaData()
throws SQLException
{
throw new UnsupportedFeatureException("ResultSet meta data is not yet implemented");
}
public final Object getObject(int columnIndex)
throws SQLException
{
Object value = this.getObjectValue(columnIndex);
m_wasNull = (value == null);
return value;
}
public final Object getObject(int columnIndex, Map map)
throws SQLException
{
Object value = this.getObjectValue(columnIndex, map);
m_wasNull = (value == null);
return value;
}
public Ref getRef(int columnIndex)
throws SQLException
{
return (Ref)this.getValue(columnIndex, Ref.class);
}
public short getShort(int columnIndex)
throws SQLException
{
Number s = this.getNumber(columnIndex, short.class);
return (s == null) ? 0 : s.shortValue();
}
public String getString(int columnIndex)
throws SQLException
{
return (String)this.getValue(columnIndex, String.class);
}
public Time getTime(int columnIndex)
throws SQLException
{
return (Time)this.getValue(columnIndex, Time.class);
}
public Time getTime(int columnIndex, Calendar cal)
throws SQLException
{
return (Time)this.getValue(columnIndex, Time.class, cal);
}
public Timestamp getTimestamp(int columnIndex)
throws SQLException
{
return (Timestamp)this.getValue(columnIndex, Timestamp.class);
}
public Timestamp getTimestamp(int columnIndex, Calendar cal)
throws SQLException
{
return (Timestamp)this.getValue(columnIndex, Timestamp.class, cal);
}
/**
* @deprecated
*/
public InputStream getUnicodeStream(int columnIndex)
throws SQLException
{
throw new UnsupportedFeatureException("ResultSet.getUnicodeStream");
}
public URL getURL(int columnIndex) throws SQLException
{
return (URL)this.getValue(columnIndex, URL.class);
}
public SQLWarning getWarnings()
throws SQLException
{
return null;
}
/**
* Refresh row is not yet implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public void refreshRow()
throws SQLException
{
throw new UnsupportedFeatureException("Refresh row");
}
public void updateArray(int columnIndex, Array x) throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateAsciiStream(int columnIndex, InputStream x, int length)
throws SQLException
{
try
{
this.updateObject(columnIndex,
new ClobValue(new InputStreamReader(x, "US-ASCII"), length));
}
catch(UnsupportedEncodingException e)
{
throw new SQLException("US-ASCII encoding is not supported by this JVM");
}
}
public void updateBigDecimal(int columnIndex, BigDecimal x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateBinaryStream(int columnIndex, InputStream x, int length)
throws SQLException
{
this.updateBlob(columnIndex, new BlobValue(x, length));
}
public void updateBlob(int columnIndex, Blob x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateBoolean(int columnIndex, boolean x)
throws SQLException
{
this.updateObject(columnIndex, x ? Boolean.TRUE : Boolean.FALSE);
}
public void updateByte(int columnIndex, byte x)
throws SQLException
{
this.updateObject(columnIndex, new Byte(x));
}
public void updateBytes(int columnIndex, byte[] x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateCharacterStream(int columnIndex, Reader x, int length)
throws SQLException
{
this.updateClob(columnIndex, new ClobValue(x, length));
}
public void updateClob(int columnIndex, Clob x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateDate(int columnIndex, Date x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateDouble(int columnIndex, double x)
throws SQLException
{
this.updateObject(columnIndex, new Double(x));
}
public void updateFloat(int columnIndex, float x)
throws SQLException
{
this.updateObject(columnIndex, new Float(x));
}
public void updateInt(int columnIndex, int x)
throws SQLException
{
this.updateObject(columnIndex, new Integer(x));
}
public void updateLong(int columnIndex, long x)
throws SQLException
{
this.updateObject(columnIndex, new Long(x));
}
public void updateNull(int columnIndex)
throws SQLException
{
this.updateObject(columnIndex, null);
}
public void updateRef(int columnIndex, Ref x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateShort(int columnIndex, short x)
throws SQLException
{
this.updateObject(columnIndex, new Short(x));
}
public void updateString(int columnIndex, String x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateTime(int columnIndex, Time x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void updateTimestamp(int columnIndex, Timestamp x)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public boolean wasNull()
{
return m_wasNull;
}
protected final Number getNumber(int columnIndex, Class cls)
throws SQLException
{
Object value = this.getObjectValue(columnIndex);
m_wasNull = (value == null);
return SPIConnection.basicNumericCoersion(cls, value);
}
protected final Object getValue(int columnIndex, Class cls)
throws SQLException
{
return SPIConnection.basicCoersion(cls, this.getObject(columnIndex));
}
protected Object getValue(int columnIndex, Class cls, Calendar cal)
throws SQLException
{
return SPIConnection.basicCalendricalCoersion(cls, this.getObject(columnIndex), cal);
}
protected Object getObjectValue(int columnIndex, Map typeMap)
throws SQLException
{
if(typeMap == null)
return this.getObjectValue(columnIndex);
throw new UnsupportedFeatureException("Obtaining values using explicit Map");
}
protected abstract Object getObjectValue(int columnIndex)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIResultSet.java 0000664 0000767 0000770 00000007743 10630554503 027332 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSetMetaData;
import org.postgresql.pljava.internal.Portal;
import org.postgresql.pljava.internal.SPI;
import org.postgresql.pljava.internal.TupleTable;
import org.postgresql.pljava.internal.Tuple;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A Read-only ResultSet that provides direct access to a {@link
* org.postgresql.pljava.internal.Portal Portal}. At present, only
* forward positioning is implemented. Attempts to use reverse or
* absolute positioning will fail.
*
* @author Thomas Hallgren
*/
public class SPIResultSet extends ResultSetBase
{
private final SPIStatement m_statement;
private final Portal m_portal;
private final TupleDesc m_tupleDesc;
private final int m_maxRows;
private Tuple m_currentRow;
private Tuple m_nextRow;
private TupleTable m_table;
private int m_tableRow;
SPIResultSet(SPIStatement statement, Portal portal, int maxRows)
throws SQLException
{
super(statement.getFetchSize());
m_statement = statement;
m_portal = portal;
m_maxRows = maxRows;
m_tupleDesc = portal.getTupleDesc();
m_tableRow = -1;
}
public int getFetchDirection()
throws SQLException
{
return FETCH_FORWARD;
}
public void close()
throws SQLException
{
if(m_portal.isValid())
{
m_portal.close();
m_statement.resultSetClosed(this);
m_table = null;
m_tableRow = -1;
m_currentRow = null;
m_nextRow = null;
super.close();
}
}
public boolean isLast() throws SQLException
{
return m_currentRow != null && this.peekNext() == null;
}
public boolean next()
throws SQLException
{
m_currentRow = this.peekNext();
m_nextRow = null;
boolean result = (m_currentRow != null);
this.setRow(result ? this.getRow() + 1 : -1);
return result;
}
public String getCursorName()
throws SQLException
{
return this.getPortal().getName();
}
public int findColumn(String columnName)
throws SQLException
{
return m_tupleDesc.getColumnIndex(columnName);
}
public Statement getStatement()
throws SQLException
{
return m_statement;
}
protected final Portal getPortal()
throws SQLException
{
if(!m_portal.isValid())
throw new SQLException("ResultSet is closed");
return m_portal;
}
protected final TupleTable getTupleTable()
throws SQLException
{
if(m_table == null)
{
Portal portal = this.getPortal();
if(portal.isAtEnd())
return null;
int mx;
int fetchSize = this.getFetchSize();
if(m_maxRows > 0)
{
mx = m_maxRows - portal.getPortalPos();
if(mx <= 0)
return null;
if(mx > fetchSize)
mx = fetchSize;
}
else
mx = fetchSize;
try
{
int result = portal.fetch(true, mx);
if(result > 0)
m_table = SPI.getTupTable(m_tupleDesc);
m_tableRow = -1;
}
finally
{
SPI.freeTupTable();
}
}
return m_table;
}
protected final Tuple getCurrentRow()
throws SQLException
{
if(m_currentRow == null)
throw new SQLException("ResultSet is not positioned on a valid row");
return m_currentRow;
}
protected final Tuple peekNext()
throws SQLException
{
if(m_nextRow != null)
return m_nextRow;
TupleTable table = this.getTupleTable();
if(table == null)
return null;
if(m_tableRow >= table.getCount() - 1)
{
// Current table is exhaused, get the next
// one.
//
m_table = null;
table = this.getTupleTable();
if(table == null)
return null;
}
m_nextRow = table.getSlot(++m_tableRow);
return m_nextRow;
}
protected Object getObjectValue(int columnIndex)
throws SQLException
{
return this.getCurrentRow().getObject(m_tupleDesc, columnIndex);
}
public ResultSetMetaData getMetaData()
throws SQLException
{
return new SPIResultSetMetaData(m_tupleDesc);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ClobValue.java 0000664 0000767 0000770 00000011152 10630554503 026665 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.BufferedInputStream;
import java.io.CharConversionException;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.Writer;
import java.sql.Clob;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class ClobValue extends Reader implements Clob
{
public static int getReaderLength(Reader value) throws SQLException
{
try
{
value.mark(Integer.MAX_VALUE);
long length = value.skip(Long.MAX_VALUE);
if(length > Integer.MAX_VALUE)
throw new SQLException("stream content too large");
value.reset();
return (int)length;
}
catch(IOException e)
{
throw new SQLException(e.getMessage());
}
}
private long m_markPos;
private final long m_nChars;
private final Reader m_reader;
private long m_readerPos;
public ClobValue(Reader reader, long nChars)
{
m_reader = reader;
m_nChars = nChars;
m_readerPos = 0L;
m_markPos = 0L;
}
public ClobValue(String value)
{
this(new StringReader(value), value.length());
}
public void close() throws IOException
{
m_reader.close();
m_readerPos = 0;
m_markPos = 0;
}
public InputStream getAsciiStream()
{
return new BufferedInputStream(new InputStream()
{
public int read() throws IOException
{
int nextChar = ClobValue.this.read();
if(nextChar > 127)
throw new CharConversionException(
"Non ascii character in Clob data");
return nextChar;
}
});
}
public Reader getCharacterStream()
{
return this;
}
public String getSubString(long pos, int length) throws SQLException
{
if(pos < 0L || length < 0)
throw new IllegalArgumentException();
if(length == 0)
return "";
if(pos + length > m_nChars)
throw new SQLException("Attempt to read beyond end of Clob data");
long skip = pos - m_readerPos;
if(skip < 0)
throw new SQLException("Cannot position Clob stream backwards");
try
{
if(skip > 0)
this.skip(skip);
char[] buf = new char[length];
int nr = this.read(buf);
if(nr < length)
throw new SQLException("Clob data read not fulfilled");
return new String(buf);
}
catch(IOException e)
{
throw new SQLException("Error reading Blob data: " + e.getMessage());
}
}
public long length()
{
return m_nChars;
}
public synchronized void mark(int readLimit) throws IOException
{
m_reader.mark(readLimit);
m_markPos = m_readerPos;
}
public boolean markSupported()
{
return m_reader.markSupported();
}
/**
* Not supported.
*/
public long position(Clob pattern, long start)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by ClobValue
*/
public long position(String pattern, long start)
{
throw new UnsupportedOperationException();
}
public synchronized int read() throws IOException
{
int rs = m_reader.read();
m_readerPos++;
return rs;
}
public synchronized int read(char[] b) throws IOException
{
int rs = m_reader.read(b);
m_readerPos += rs;
return rs;
}
public synchronized int read(char[] b, int off, int len) throws IOException
{
int rs = m_reader.read(b, off, len);
m_readerPos += rs;
return rs;
}
public synchronized boolean ready() throws IOException
{
return m_reader.ready();
}
public synchronized void reset() throws IOException
{
m_reader.reset();
m_readerPos = m_markPos;
}
/**
* In this method is not supported by ClobValue
*/
public OutputStream setAsciiStream(long pos)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by ClobValue
*/
public Writer setCharacterStream(long pos)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by ClobValue
*/
public int setString(long pos, String str)
{
throw new UnsupportedOperationException();
}
/**
* In this method is not supported by ClobValue
*/
public int setString(long pos, String str, int offset, int len)
{
throw new UnsupportedOperationException();
}
public synchronized long skip(long nBytes) throws IOException
{
long skipped = m_reader.skip(nBytes);
m_readerPos += skipped;
return skipped;
}
/**
* In this method is not supported by ClobValue
*/
public void truncate(long len)
{
throw new UnsupportedOperationException();
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/UnsupportedFeatureException.java 0000664 0000767 0000770 00000001314 10630554503 032533 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
/**
* @author Thomas Hallgren
*/
public class UnsupportedFeatureException extends SQLException
{
private static final long serialVersionUID = 7956037664745636982L;
public static final String FEATURE_NOT_SUPPORTED_EXCEPTION = "0A000";
public UnsupportedFeatureException(String feature)
{
super("Feature not supported: " + feature, FEATURE_NOT_SUPPORTED_EXCEPTION);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/AbstractResultSet.java 0000664 0000767 0000770 00000017675 10630554503 030447 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.InputStream;
import java.io.Reader;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.math.BigDecimal;
import java.net.URL;
import java.util.Calendar;
import java.util.Map;
/**
* The AbstractResultSet serves as a base class for implementations
* of the{@link java.sql.ResultSet} interface. All calls using columnNames are
* translated into the corresponding call with index position computed using
* a call to {@link java.sql.ResultSet#findColumn(String) findColumn}.
*
* @author Thomas Hallgren
*/
public abstract class AbstractResultSet implements ResultSet
{
public Array getArray(String columnName)
throws SQLException
{
return this.getArray(this.findColumn(columnName));
}
public InputStream getAsciiStream(String columnName)
throws SQLException
{
return this.getAsciiStream(this.findColumn(columnName));
}
public BigDecimal getBigDecimal(String columnName)
throws SQLException
{
return this.getBigDecimal(this.findColumn(columnName));
}
/**
* @deprecated
*/
public BigDecimal getBigDecimal(String columnName, int scale)
throws SQLException
{
return this.getBigDecimal(this.findColumn(columnName), scale);
}
public InputStream getBinaryStream(String columnName)
throws SQLException
{
return this.getBinaryStream(this.findColumn(columnName));
}
public Blob getBlob(String columnName)
throws SQLException
{
return this.getBlob(this.findColumn(columnName));
}
public boolean getBoolean(String columnName)
throws SQLException
{
return this.getBoolean(this.findColumn(columnName));
}
public byte getByte(String columnName)
throws SQLException
{
return this.getByte(this.findColumn(columnName));
}
public byte[] getBytes(String columnName)
throws SQLException
{
return this.getBytes(this.findColumn(columnName));
}
public Reader getCharacterStream(String columnName)
throws SQLException
{
return this.getCharacterStream(this.findColumn(columnName));
}
public Clob getClob(String columnName)
throws SQLException
{
return this.getClob(this.findColumn(columnName));
}
public String getCursorName()
throws SQLException
{
return null;
}
public Date getDate(String columnName)
throws SQLException
{
return this.getDate(this.findColumn(columnName));
}
public Date getDate(String columnName, Calendar cal)
throws SQLException
{
return this.getDate(this.findColumn(columnName), cal);
}
public double getDouble(String columnName)
throws SQLException
{
return this.getDouble(this.findColumn(columnName));
}
public float getFloat(String columnName)
throws SQLException
{
return this.getFloat(this.findColumn(columnName));
}
public int getInt(String columnName)
throws SQLException
{
return this.getInt(this.findColumn(columnName));
}
public long getLong(String columnName)
throws SQLException
{
return this.getLong(this.findColumn(columnName));
}
public Object getObject(String columnName)
throws SQLException
{
return this.getObject(this.findColumn(columnName));
}
public Object getObject(String columnName, Map map)
throws SQLException
{
return this.getObject(this.findColumn(columnName), map);
}
public Ref getRef(String columnName)
throws SQLException
{
return this.getRef(this.findColumn(columnName));
}
public short getShort(String columnName)
throws SQLException
{
return this.getShort(this.findColumn(columnName));
}
public Statement getStatement()
throws SQLException
{
return null;
}
public String getString(String columnName)
throws SQLException
{
return this.getString(this.findColumn(columnName));
}
public Time getTime(String columnName)
throws SQLException
{
return this.getTime(this.findColumn(columnName));
}
public Time getTime(String columnName, Calendar cal)
throws SQLException
{
return this.getTime(this.findColumn(columnName), cal);
}
public Timestamp getTimestamp(String columnName)
throws SQLException
{
return this.getTimestamp(this.findColumn(columnName));
}
public Timestamp getTimestamp(String columnName, Calendar cal)
throws SQLException
{
return this.getTimestamp(this.findColumn(columnName), cal);
}
/**
* @deprecated
*/
public InputStream getUnicodeStream(String columnName)
throws SQLException
{
return this.getUnicodeStream(this.findColumn(columnName));
}
public URL getURL(String columnName)
throws SQLException
{
return this.getURL(this.findColumn(columnName));
}
public void updateArray(String columnName, Array x)
throws SQLException
{
this.updateArray(this.findColumn(columnName), x);
}
public void updateAsciiStream(String columnName, InputStream x, int length)
throws SQLException
{
this.updateAsciiStream(this.findColumn(columnName), x, length);
}
public void updateBigDecimal(String columnName, BigDecimal x)
throws SQLException
{
this.updateBigDecimal(this.findColumn(columnName), x);
}
public void updateBinaryStream(String columnName, InputStream x, int length)
throws SQLException
{
this.updateBinaryStream(this.findColumn(columnName), x, length);
}
public void updateBlob(String columnName, Blob x)
throws SQLException
{
this.updateBlob(this.findColumn(columnName), x);
}
public void updateBoolean(String columnName, boolean x)
throws SQLException
{
this.updateBoolean(this.findColumn(columnName), x);
}
public void updateByte(String columnName, byte x)
throws SQLException
{
this.updateByte(this.findColumn(columnName), x);
}
public void updateBytes(String columnName, byte x[])
throws SQLException
{
this.updateBytes(this.findColumn(columnName), x);
}
public void updateCharacterStream(String columnName, Reader x, int length)
throws SQLException
{
this.updateCharacterStream(this.findColumn(columnName), x, length);
}
public void updateClob(String columnName, Clob x)
throws SQLException
{
this.updateClob(this.findColumn(columnName), x);
}
public void updateDate(String columnName, Date x)
throws SQLException
{
this.updateDate(this.findColumn(columnName), x);
}
public void updateDouble(String columnName, double x)
throws SQLException
{
this.updateDouble(this.findColumn(columnName), x);
}
public void updateFloat(String columnName, float x)
throws SQLException
{
this.updateFloat(this.findColumn(columnName), x);
}
public void updateInt(String columnName, int x)
throws SQLException
{
this.updateInt(this.findColumn(columnName), x);
}
public void updateLong(String columnName, long x)
throws SQLException
{
this.updateLong(this.findColumn(columnName), x);
}
public void updateNull(String columnName)
throws SQLException
{
this.updateNull(this.findColumn(columnName));
}
public void updateObject(String columnName, Object x)
throws SQLException
{
this.updateObject(this.findColumn(columnName), x);
}
public void updateObject(String columnName, Object x, int scale)
throws SQLException
{
this.updateObject(this.findColumn(columnName), x, scale);
}
public void updateRef(String columnName, Ref x)
throws SQLException
{
this.updateRef(this.findColumn(columnName), x);
}
public void updateShort(String columnName, short x)
throws SQLException
{
this.updateShort(this.findColumn(columnName), x);
}
public void updateString(String columnName, String x)
throws SQLException
{
this.updateString(this.findColumn(columnName), x);
}
public void updateTime(String columnName, Time x)
throws SQLException
{
this.updateTime(this.findColumn(columnName), x);
}
public void updateTimestamp(String columnName, Timestamp x)
throws SQLException
{
this.updateTimestamp(this.findColumn(columnName), x);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/AbstractResultSetMetaData.java 0000664 0000767 0000770 00000030171 10630554503 032032 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DriverManager;
import org.postgresql.pljava.internal.Oid;
/**
* Implementation of ResultSetMetaData for SyntheticResultSet
*
* @author Filip Hrbek
*/
public abstract class AbstractResultSetMetaData implements ResultSetMetaData
{
private Connection m_conn;
/**
* Constructor.
*/
public AbstractResultSetMetaData()
{
m_conn = null;
}
/**
* Returns the number of columns in this ResultSet object.
*
* @return the number of columns
* @exception SQLException if a database access error occurs
*/
public abstract int getColumnCount() throws SQLException;
/**
* Indicates whether the designated column is automatically numbered, thus read-only.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public abstract boolean isAutoIncrement(int column) throws SQLException;
/**
* Indicates whether a column's case matters.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isCaseSensitive(int column) throws SQLException
{
checkColumnIndex(column);
Oid oid = this.getOid(column);
return ( oid.equals(TypeOid.TEXT)
|| oid.equals(TypeOid.BYTEA)
|| oid.equals(TypeOid.VARCHAR)
|| oid.equals(TypeOid.BPCHAR));
}
/**
* Indicates whether the designated column can be used in a where clause.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isSearchable(int column) throws SQLException
{
checkColumnIndex(column);
return true;
}
/**
* Indicates whether the designated column is a cash value.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isCurrency(int column) throws SQLException
{
checkColumnIndex(column);
//For now it is false; it can be changed when TypeOid.java
//contains currency data types.
return false;
}
/**
* Indicates the nullability of values in the designated column.
*
* @param column the first column is 1, the second is 2, ...
* @return the nullability status of the given column; one of columnNoNulls,
* columnNullable or columnNullableUnknown
* @exception SQLException if a database access error occurs
*/
public final int isNullable(int column) throws SQLException
{
checkColumnIndex(column);
return columnNullableUnknown;
}
/**
* Indicates whether values in the designated column are signed numbers.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isSigned(int column) throws SQLException
{
checkColumnIndex(column);
Oid oid = this.getOid(column);
return ( oid.equals(TypeOid.INT2)
|| oid.equals(TypeOid.INT4)
|| oid.equals(TypeOid.INT8)
|| oid.equals(TypeOid.FLOAT4)
|| oid.equals(TypeOid.FLOAT8));
}
/**
* Indicates the designated column's normal maximum width in characters.
*
* @param column the first column is 1, the second is 2, ...
* @return the normal maximum number of characters allowed as the width
* of the designated column
* @exception SQLException if a database access error occurs
*/
public final int getColumnDisplaySize(int column) throws SQLException
{
checkColumnIndex(column);
Oid oid = this.getOid(column);
if(oid.equals(TypeOid.INT2))
return 6;
if(oid.equals(TypeOid.INT4)
|| oid.equals(TypeOid.FLOAT4))
return 11;
if(oid.equals(TypeOid.INT8)
|| oid.equals(TypeOid.NUMERIC)
|| oid.equals(TypeOid.FLOAT8)
|| oid.equals(TypeOid.OID))
return 20;
if(oid.equals(TypeOid.BOOL))
return 3;
if(oid.equals(TypeOid.DATE))
return 13;
if(oid.equals(TypeOid.TIME))
return 10;
if(oid.equals(TypeOid.TIMESTAMP)
|| oid.equals(TypeOid.TIMESTAMPTZ))
return 25;
return getFieldLength(column);
}
/**
* Gets the designated column's suggested title for use in printouts and
* displays.
*
* @param column the first column is 1, the second is 2, ...
* @return the suggested column title
* @exception SQLException if a database access error occurs
*/
public abstract String getColumnLabel(int column) throws SQLException;
/**
* Get the designated column's name.
*
* @param column the first column is 1, the second is 2, ...
* @return column name
* @exception SQLException if a database access error occurs
*/
public String getColumnName(int column) throws SQLException
{
checkColumnIndex(column);
return getColumnLabel(column);
}
/**
* Get the designated column's table's schema.
*
* @param column the first column is 1, the second is 2, ...
* @return schema name or "" if not applicable
* @exception SQLException if a database access error occurs
*/
public final String getSchemaName(int column) throws SQLException
{
checkColumnIndex(column);
return "";
}
/**
* Get the designated column's number of decimal digits.
*
* @param column the first column is 1, the second is 2, ...
* @return precision
* @exception SQLException if a database access error occurs
*/
public final int getPrecision(int column) throws SQLException
{
checkColumnIndex(column);
Oid oid = this.getOid(column);
if(oid.equals(TypeOid.INT2))
return 5;
if(oid.equals(TypeOid.INT4))
return 10;
if(oid.equals(TypeOid.INT8)
|| oid.equals(TypeOid.OID))
return 20;
if(oid.equals(TypeOid.FLOAT4))
return 8;
if(oid.equals(TypeOid.FLOAT8))
return 16;
if(oid.equals(TypeOid.BOOL))
return 1;
if(oid.equals(TypeOid.NUMERIC))
return -1;
return 0;
}
/**
* Gets the designated column's number of digits to right of the decimal point.
*
* @param column the first column is 1, the second is 2, ...
* @return scale
* @exception SQLException if a database access error occurs
*/
public final int getScale(int column) throws SQLException
{
checkColumnIndex(column);
Oid oid = this.getOid(column);
if(oid.equals(TypeOid.FLOAT4))
return 8;
if(oid.equals(TypeOid.FLOAT8))
return 16;
if(oid.equals(TypeOid.NUMERIC))
return -1;
return 0;
}
/**
* Gets the designated column's table name.
*
* @param column the first column is 1, the second is 2, ...
* @return table name or "" if not applicable
* @exception SQLException if a database access error occurs
*/
public final String getTableName(int column) throws SQLException
{
checkColumnIndex(column);
return "";
}
/**
* Gets the designated column's table's catalog name.
*
* @param column the first column is 1, the second is 2, ...
* @return the name of the catalog for the table in which the given column
* appears or "" if not applicable
* @exception SQLException if a database access error occurs
*/
public final String getCatalogName(int column) throws SQLException
{
checkColumnIndex(column);
return "";
}
/**
* Retrieves the designated column's SQL type.
*
* @param column the first column is 1, the second is 2, ...
* @return SQL type from {@link java.sql.Types}
* @exception SQLException if a database access error occurs
* @see java.sql.Types
*/
public final int getColumnType(int column) throws SQLException
{
checkColumnIndex(column);
return ((SPIConnection)getDefaultConnection()).getSQLType(getOid(column));
}
/**
* Retrieves the designated column's database-specific type name.
*
* @param column the first column is 1, the second is 2, ...
* @return type name used by the database. If the column type is
* a user-defined type, then a fully-qualified type name is returned.
* @exception SQLException if a database access error occurs
*/
public final String getColumnTypeName(int column) throws SQLException
{
checkColumnIndex(column);
return ((SPIConnection)getDefaultConnection()).getPGType(getOid(column));
}
/**
* Indicates whether the designated column is definitely not writable.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isReadOnly(int column) throws SQLException
{
checkColumnIndex(column);
return true;
}
/**
* Indicates whether it is possible for a write on the designated column to succeed.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isWritable(int column) throws SQLException
{
checkColumnIndex(column);
return false;
}
/**
* Indicates whether a write on the designated column will definitely succeed.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isDefinitelyWritable(int column) throws SQLException
{
checkColumnIndex(column);
return false;
}
//--------------------------JDBC 2.0-----------------------------------
/**
*
Returns the fully-qualified name of the Java class whose instances
* are manufactured if the method ResultSet.getObject
* is called to retrieve a value
* from the column. ResultSet.getObject may return a subclass of the
* class returned by this method.
*
* @param column the first column is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* ResultSet.getObject to retrieve the value in the specified
* column. This is the class name used for custom mapping.
* @exception SQLException if a database access error occurs
* @since 1.2
*/
public abstract String getColumnClassName(int column) throws SQLException;
/**
* Checks if the column index is valid.
*
* @param column the first column is 1, the second is 2, ...
* @exception SQLException if the column is out of index bounds
*/
protected abstract void checkColumnIndex(int column) throws SQLException;
/**
* Gets column OID
* @param column Column index
* @return column OID
* @throws SQLException if an error occurs
*/
protected abstract Oid getOid(int column) throws SQLException;
/**
* Gets column length
* @param column Column index
* @return column length
* @throws SQLException if an error occurs
*/
protected abstract int getFieldLength(int column) throws SQLException;
/**
* Obtains connection to the database if needed.
* Once called, it stores the connection reference to a private variable.
*/
private Connection getDefaultConnection() throws SQLException
{
if (m_conn == null)
{
m_conn = DriverManager.getConnection("jdbc:default:connection");
}
return m_conn;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SyntheticResultSet.java 0000664 0000767 0000770 00000005406 10630554503 030643 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.HashMap;
/**
* A Synthetic ResultSet that provides direct access to data stored
* in a {@link java.util.ArrayList}. This kind of ResultSet has nothing
* common with any statement.
*
* @author Filip Hrbek
*/
public class SyntheticResultSet extends ResultSetBase
{
private final ResultSetField[] m_fields;
private final ArrayList m_tuples;
private final HashMap m_fieldIndexes;
SyntheticResultSet(ResultSetField[] fields, ArrayList tuples)
throws SQLException
{
super(tuples.size());
m_fields = fields;
m_tuples = tuples;
m_fieldIndexes = new HashMap();
int i = m_fields.length;
while(--i >= 0)
m_fieldIndexes.put(m_fields[i].getColumnLabel(), new Integer(i+1));
Object[][] tupleTest = (Object[][]) m_tuples.toArray(new Object[0][]);
Object value;
for (i=0; i < tupleTest.length; i++)
{
int j = m_fields.length;
while(--j >= 0)
{
value = tupleTest[i][j];
if (value != null && !m_fields[j].canContain(value.getClass()))
{
throw new SQLException(
"Unable to store class " + value.getClass() +
" in ResultSetField '" + m_fields[j].getColumnLabel() + "'" +
" with OID " + m_fields[j].getOID() +
" (expected class: " + m_fields[j].getJavaClass() + ")");
}
}
}
}
public void close()
throws SQLException
{
m_tuples.clear();
super.close();
}
public int findColumn(String columnName)
throws SQLException
{
Integer idx = (Integer)m_fieldIndexes.get(columnName.toUpperCase());
if(idx != null)
{
return idx.intValue();
}
throw new SQLException("No such field: '" + columnName + "'");
}
protected Object getObjectValue(int columnIndex)
throws SQLException
{
return getCurrentRow()[columnIndex-1];
}
protected final Object[] getCurrentRow()
throws SQLException
{
int row = this.getRow();
if(row < 1 || row > m_tuples.size())
throw new SQLException("ResultSet is not positioned on a valid row");
return (Object[])m_tuples.get(row-1);
}
public boolean isLast() throws SQLException
{
return this.getRow() == m_tuples.size();
}
public boolean next() throws SQLException
{
int row = this.getRow();
if(row < m_tuples.size())
{
this.setRow(row+1);
return true;
}
return false;
}
public ResultSetMetaData getMetaData()
throws SQLException
{
return new SyntheticResultSetMetaData(m_fields);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SingleRowResultSet.java 0000664 0000767 0000770 00000013273 10630554503 030603 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A single row ResultSet
*
* @author Thomas Hallgren
*/
public abstract class SingleRowResultSet extends ObjectResultSet
{
public int getConcurrency()
throws SQLException
{
return CONCUR_UPDATABLE;
}
public int findColumn(String columnName)
throws SQLException
{
return this.getTupleDesc().getColumnIndex(columnName);
}
public int getFetchDirection()
throws SQLException
{
return FETCH_FORWARD;
}
public int getFetchSize()
throws SQLException
{
return 1;
}
/**
* Returns the metadata for this result set.
*/
public ResultSetMetaData getMetaData() throws SQLException
{
return new SPIResultSetMetaData(this.getTupleDesc());
}
public int getRow()
throws SQLException
{
return 1;
}
public int getType()
throws SQLException
{
return TYPE_FORWARD_ONLY;
}
/**
* Cursor positoning is not implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public void afterLast()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Cursor positoning is not implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public void beforeFirst()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Cursor positioning is not implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean first() throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Returns false.
*/
public boolean isAfterLast() throws SQLException
{
return false;
}
/**
* Will always return false since a SingleRowWriter
* starts on the one and only row.
*/
public boolean isBeforeFirst() throws SQLException
{
return false;
}
/**
* Returns true.
*/
public boolean isFirst() throws SQLException
{
return true;
}
/**
* Returns true.
*/
public boolean isLast() throws SQLException
{
return true;
}
/**
* Cursor positioning is not implemented.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean last()
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* This method will always return false but it will not change
* the state of the ResultSet.
*/
public boolean next()
throws SQLException
{
return false;
}
/**
* This method will always return false but it will not change
* the state of the ResultSet.
*/
public boolean previous()
throws SQLException
{
return false;
}
/**
* Only {@link java.sql.ResultSet#FETCH_FORWARD} is supported.
* @throws SQLException indicating that this feature is not supported
* for other values on direction.
*/
public void setFetchDirection(int direction)
throws SQLException
{
if(direction != FETCH_FORWARD)
throw new UnsupportedFeatureException("Non forward fetch direction");
}
/**
* Only permitted value for fetchSize is 1.
*/
public void setFetchSize(int fetchSize)
throws SQLException
{
if(fetchSize != 1)
throw new IllegalArgumentException("Illegal fetch size for single row set");
}
/**
* Cursor positioning is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean absolute(int row)
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* Cursor positioning is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean relative(int rows)
throws SQLException
{
throw new UnsupportedFeatureException("Cursor positioning");
}
/**
* This feature is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void deleteRow()
throws SQLException
{
throw new UnsupportedFeatureException("Deletes not supported on single row set");
}
/**
* This feature is not supported.
* @throws SQLException indicating that this feature is not supported.
*/
public void insertRow()
throws SQLException
{
throw new UnsupportedFeatureException("Inserts not supported on single row set");
}
/**
* This is a no-op since the moveToInsertRow() method is
* unsupported.
*/
public void moveToCurrentRow()
throws SQLException
{
}
/**
* This feature is not supported on a SingleRowWriter.
* @throws SQLException indicating that this feature is not supported.
*/
public void moveToInsertRow()
throws SQLException
{
throw new UnsupportedFeatureException("Inserts not supported on single row set");
}
/**
* This is a noop.
*/
public void updateRow()
throws SQLException
{
}
/**
* Will always return false.
*/
public boolean rowDeleted()
throws SQLException
{
return false;
}
/**
* Will always return false.
*/
public boolean rowInserted()
throws SQLException
{
return false;
}
/**
* The scale is not really supported. This method just strips it off and
* calls {@link #updateObject(int, Object)}
*/
public void updateObject(int columnIndex, Object x, int scale)
throws SQLException
{
// Simply drop the scale.
//
this.updateObject(columnIndex, x);
}
protected abstract TupleDesc getTupleDesc()
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SQLUtils.java 0000664 0000767 0000770 00000002004 10630554503 026465 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* Helpful utility commands when dealing with JDBC
* @author Thomas Hallgren
*/
public abstract class SQLUtils
{
public static Connection getDefaultConnection()
{
return SPIDriver.getDefault();
}
public static void close(Connection conn)
{
if(conn != null)
try
{
conn.close();
}
catch(SQLException e)
{ /* ignore */
}
}
public static void close(Statement stmt)
{
if(stmt != null)
try
{
stmt.close();
}
catch(SQLException e)
{ /* ignore */
}
}
public static void close(ResultSet rs)
{
if(rs != null)
try
{
rs.close();
}
catch(SQLException e)
{ /* ignore */
}
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIDatabaseMetaData.java 0000664 0000767 0000770 00000365432 10630554503 030507 0 ustar iwasakims iwasakims package org.postgresql.pljava.jdbc;
/**
* @author Filip Hrbek
*/
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import org.postgresql.pljava.internal.AclId;
import org.postgresql.pljava.internal.Backend;
import org.postgresql.pljava.internal.Oid;
public class SPIDatabaseMetaData implements DatabaseMetaData
{
public SPIDatabaseMetaData(SPIConnection conn)
{
m_connection = conn;
}
private static final String KEYWORDS = "abort,acl,add,aggregate,append,archive,"
+ "arch_store,backward,binary,boolean,change,cluster,"
+ "copy,database,delimiter,delimiters,do,extend,"
+ "explain,forward,heavy,index,inherits,isnull,"
+ "light,listen,load,merge,nothing,notify,"
+ "notnull,oids,purge,rename,replace,retrieve,"
+ "returns,rule,recipe,setof,stdin,stdout,store,"
+ "vacuum,verbose,version";
private final SPIConnection m_connection; // The connection association
private static final int VARHDRSZ = 4; // length for int4
private int NAMEDATALEN = 0; // length for name datatype
private int INDEX_MAX_KEYS = 0; // maximum number of keys in an index.
protected int getMaxIndexKeys() throws SQLException
{
if(INDEX_MAX_KEYS == 0)
INDEX_MAX_KEYS = Integer.parseInt(Backend.getConfigOption("max_index_keys"));
return INDEX_MAX_KEYS;
}
protected int getMaxNameLength() throws SQLException
{
if(NAMEDATALEN == 0)
{
String sql = "SELECT t.typlen FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n" +
" WHERE t.typnamespace=n.oid" +
" AND t.typname='name'" +
" AND n.nspname='pg_catalog'";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
if(!rs.next()){ throw new SQLException(
"Unable to find name datatype in the system catalogs."); }
NAMEDATALEN = rs.getInt("typlen");
rs.close();
}
return NAMEDATALEN - 1;
}
/*
* Can all the procedures returned by getProcedures be called by the current
* user? @return true if so @exception SQLException if a database access
* error occurs
*/
public boolean allProceduresAreCallable() throws SQLException
{
return true; // For now...
}
/*
* Can all the tables returned by getTable be SELECTed by the current user?
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean allTablesAreSelectable() throws SQLException
{
return true; // For now...
}
/*
* What is the URL for this database? @return the url or null if it cannott
* be generated @exception SQLException if a database access error occurs
*/
public String getURL() throws SQLException
{
return "jdbc:default:connection";
}
/*
* What is our user name as known to the database? @return our database user
* name @exception SQLException if a database access error occurs
*/
public String getUserName() throws SQLException
{
return AclId.getUser().getName();
}
/*
* Is the database in read-only mode? @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean isReadOnly() throws SQLException
{
return m_connection.isReadOnly();
}
/*
* Are NULL values sorted high? @return true if so @exception SQLException
* if a database access error occurs
*/
public boolean nullsAreSortedHigh() throws SQLException
{
return true;
}
/*
* Are NULL values sorted low? @return true if so @exception SQLException if
* a database access error occurs
*/
public boolean nullsAreSortedLow() throws SQLException
{
return false;
}
/*
* Are NULL values sorted at the start regardless of sort order? @return
* true if so @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedAtStart() throws SQLException
{
return false;
}
/*
* Are NULL values sorted at the end regardless of sort order? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedAtEnd() throws SQLException
{
return false;
}
/*
* What is the name of this database product - we hope that it is
* PostgreSQL, so we return that explicitly. @return the database product
* name @exception SQLException if a database access error occurs
*/
public String getDatabaseProductName() throws SQLException
{
return "PostgreSQL";
}
/*
* What is the version of this database product. @return the database
* version @exception SQLException if a database access error occurs
*/
public String getDatabaseProductVersion() throws SQLException
{
int[] ver = m_connection.getVersionNumber();
return ver[0] + "." + ver[1] + "." + ver[2];
}
/*
* What is the name of this JDBC driver? If we don't know this we are doing
* something wrong! @return the JDBC driver name @exception SQLException
* why?
*/
public String getDriverName() throws SQLException
{
return "PostgreSQL pljava SPI Driver";
}
/*
* What is the version string of this JDBC driver? Again, this is static.
* @return the JDBC driver name. @exception SQLException why?
*/
public String getDriverVersion() throws SQLException
{
SPIDriver d = new SPIDriver();
return d.getMajorVersion() + "." + d.getMinorVersion();
}
/*
* What is this JDBC driver's major version number? @return the JDBC driver
* major version
*/
public int getDriverMajorVersion()
{
return new SPIDriver().getMajorVersion();
}
/*
* What is this JDBC driver's minor version number? @return the JDBC driver
* minor version
*/
public int getDriverMinorVersion()
{
return new SPIDriver().getMinorVersion();
}
/*
* Does the database store tables in a local file? No - it stores them in a
* file on the server. @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean usesLocalFiles() throws SQLException
{
return false;
}
/*
* Does the database use a file for each table? Well, not really, since it
* doesnt use local files. @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean usesLocalFilePerTable() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as case
* sensitive and as a result store them in mixed case? A JDBC-Compliant
* driver will always return false. @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsMixedCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as case
* insensitive and store them in upper case? @return true if so
*/
public boolean storesUpperCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as case
* insensitive and store them in lower case? @return true if so
*/
public boolean storesLowerCaseIdentifiers() throws SQLException
{
return true;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as case
* insensitive and store them in mixed case? @return true if so
*/
public boolean storesMixedCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* sensitive and as a result store them in mixed case? A JDBC compliant
* driver will always return true. @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException
{
return true;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in upper case? @return true if so
*/
public boolean storesUpperCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in lower case? @return true if so
*/
public boolean storesLowerCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in mixed case? @return true if so
*/
public boolean storesMixedCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* What is the string used to quote SQL identifiers? This returns a space if
* identifier quoting isn't supported. A JDBC Compliant driver will always
* use a double quote character. @return the quoting string @exception
* SQLException if a database access error occurs
*/
public String getIdentifierQuoteString() throws SQLException
{
return "\"";
}
/*
* Get a comma separated list of all a database's SQL keywords that are NOT
* also SQL92 keywords.
Within PostgreSQL, the keywords are found in
* src/backend/parser/keywords.c
For SQL Keywords, I took the list
* provided at
* http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt which is for
* SQL3, not SQL-92, but it is close enough for this purpose. @return a
* comma separated list of keywords we use @exception SQLException if a
* database access error occurs
*/
public String getSQLKeywords() throws SQLException
{
return KEYWORDS;
}
/**
* get supported escaped numeric functions
*
* @return a comma separated list of function names
*/
public String getNumericFunctions() throws SQLException
{
return BuiltinFunctions.ABS + ',' + BuiltinFunctions.ACOS + ','
+ BuiltinFunctions.ASIN + ',' + BuiltinFunctions.ATAN + ','
+ BuiltinFunctions.ATAN2 + ',' + BuiltinFunctions.CEILING + ','
+ BuiltinFunctions.COS + ',' + BuiltinFunctions.COT + ','
+ BuiltinFunctions.DEGREES + ',' + BuiltinFunctions.EXP + ','
+ BuiltinFunctions.FLOOR + ',' + BuiltinFunctions.LOG + ','
+ BuiltinFunctions.LOG10 + ',' + BuiltinFunctions.MOD + ','
+ BuiltinFunctions.PI + ',' + BuiltinFunctions.POWER + ','
+ BuiltinFunctions.RADIANS + ',' + BuiltinFunctions.RAND + ','
+ BuiltinFunctions.ROUND + ',' + BuiltinFunctions.SIGN + ','
+ BuiltinFunctions.SIN + ',' + BuiltinFunctions.SQRT + ','
+ BuiltinFunctions.TAN + ',' + BuiltinFunctions.TRUNCATE;
}
public String getStringFunctions() throws SQLException
{
String funcs = BuiltinFunctions.ASCII + ',' + BuiltinFunctions.CHAR
+ ',' + BuiltinFunctions.CONCAT + ',' + BuiltinFunctions.LCASE
+ ',' + BuiltinFunctions.LEFT + ',' + BuiltinFunctions.LENGTH + ','
+ BuiltinFunctions.LTRIM + ',' + BuiltinFunctions.REPEAT + ','
+ BuiltinFunctions.RTRIM + ',' + BuiltinFunctions.SPACE + ','
+ BuiltinFunctions.SUBSTRING + ',' + BuiltinFunctions.UCASE + ','
+ BuiltinFunctions.REPLACE;
// Currently these don't work correctly with parameterized
// arguments, so leave them out. They reorder the arguments
// when rewriting the query, but no translation layer is provided,
// so a setObject(N, obj) will not go to the correct parameter.
// ','+BuiltinFunctions.INSERT+','+BuiltinFunctions.LOCATE+
// ','+BuiltinFunctions.RIGHT+
return funcs;
}
public String getSystemFunctions() throws SQLException
{
return BuiltinFunctions.DATABASE + ',' + BuiltinFunctions.IFNULL
+ ',' + BuiltinFunctions.USER;
}
public String getTimeDateFunctions() throws SQLException
{
return BuiltinFunctions.CURDATE + ',' + BuiltinFunctions.CURTIME + ','
+ BuiltinFunctions.DAYNAME + ',' + BuiltinFunctions.DAYOFMONTH
+ ',' + BuiltinFunctions.DAYOFWEEK + ','
+ BuiltinFunctions.DAYOFYEAR + ',' + BuiltinFunctions.HOUR + ','
+ BuiltinFunctions.MINUTE + ',' + BuiltinFunctions.MONTH + ','
+ BuiltinFunctions.MONTHNAME + ',' + BuiltinFunctions.NOW + ','
+ BuiltinFunctions.QUARTER + ',' + BuiltinFunctions.SECOND + ','
+ BuiltinFunctions.WEEK + ',' + BuiltinFunctions.YEAR;
}
/*
* This is the string that can be used to escape '_' and '%' in a search
* string pattern style catalog search parameters @return the string used to
* escape wildcard characters @exception SQLException if a database access
* error occurs
*/
public String getSearchStringEscape() throws SQLException
{
// Java's parse takes off two backslashes
// and then pg's input parser takes off another layer
// so we need many backslashes here.
//
// This would work differently if you used a PreparedStatement
// and " mycol LIKE ? " which using the V3 protocol would skip
// pg's input parser, but I don't know what we can do about that.
//
return "\\";
}
/*
* Get all the "extra" characters that can be used in unquoted identifier
* names (those beyond a-zA-Z0-9 and _)
From the file
* src/backend/parser/scan.l, an identifier is {letter}{letter_or_digit}
* which makes it just those listed above. @return a string containing the
* extra characters @exception SQLException if a database access error
* occurs
*/
public String getExtraNameCharacters() throws SQLException
{
return "";
}
/*
* Is "ALTER TABLE" with an add column supported? Yes for PostgreSQL 6.1
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean supportsAlterTableWithAddColumn() throws SQLException
{
return true;
}
/*
* Is "ALTER TABLE" with a drop column supported? @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsAlterTableWithDropColumn() throws SQLException
{
return true;
}
/*
* Is column aliasing supported?
If so, the SQL AS clause can be used to
* provide names for computed columns or to provide alias names for columns
* as required. A JDBC Compliant driver always returns true.
e.g.
* select count(C) as C_COUNT from T group by C;
should return a
* column named as C_COUNT instead of count(C) @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsColumnAliasing() throws SQLException
{
return true;
}
/*
* Are concatenations between NULL and non-NULL values NULL? A JDBC
* Compliant driver always returns true @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean nullPlusNonNullIsNull() throws SQLException
{
return true;
}
public boolean supportsConvert() throws SQLException
{
return false;
}
public boolean supportsConvert(int fromType, int toType)
throws SQLException
{
return false;
}
/*
* Are table correlation names supported? A JDBC Compliant driver always
* returns true. @return true if so; false otherwise @exception SQLException -
* if a database access error occurs
*/
public boolean supportsTableCorrelationNames() throws SQLException
{
return true;
}
/*
* If table correlation names are supported, are they restricted to be
* different from the names of the tables? @return true if so; false
* otherwise @exception SQLException - if a database access error occurs
*/
public boolean supportsDifferentTableCorrelationNames() throws SQLException
{
return false;
}
/*
* Are expressions in "ORDER BY" lists supported?
e.g. select * from t
* order by a + b; @return true if so @exception SQLException if a database
* access error occurs
*/
public boolean supportsExpressionsInOrderBy() throws SQLException
{
return true;
}
/*
* Can an "ORDER BY" clause use columns not in the SELECT? @return true if
* so @exception SQLException if a database access error occurs
*/
public boolean supportsOrderByUnrelated() throws SQLException
{
return true;
}
/*
* Is some form of "GROUP BY" clause supported? I checked it, and yes it is.
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean supportsGroupBy() throws SQLException
{
return true;
}
/*
* Can a "GROUP BY" clause use columns not in the SELECT? @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsGroupByUnrelated() throws SQLException
{
return true;
}
/*
* Can a "GROUP BY" clause add columns not in the SELECT provided it
* specifies all the columns in the SELECT? Does anyone actually understand
* what they mean here? (I think this is a subset of the previous function. --
* petere) @return true if so @exception SQLException if a database access
* error occurs
*/
public boolean supportsGroupByBeyondSelect() throws SQLException
{
return true;
}
/*
* Is the escape character in "LIKE" clauses supported? A JDBC compliant
* driver always returns true. @return true if so @exception SQLException if
* a database access error occurs
*/
public boolean supportsLikeEscapeClause() throws SQLException
{
return true;
}
/*
* Are multiple ResultSets from a single execute supported? Well, I
* implemented it, but I dont think this is possible from the back ends
* point of view. @return true if so @exception SQLException if a database
* access error occurs
*/
public boolean supportsMultipleResultSets() throws SQLException
{
return false;
}
/*
* Can we have multiple transactions open at once (on different
* connections?) I guess we can have, since Im relying on it. @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean supportsMultipleTransactions() throws SQLException
{
return true;
}
/*
* Can columns be defined as non-nullable. A JDBC Compliant driver always
* returns true. This changed from false to true in v6.2 of the driver,
* as this support was added to the backend. @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsNonNullableColumns() throws SQLException
{
return true;
}
/*
* Does this driver support the minimum ODBC SQL grammar. This grammar is
* defined at:
http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm
*
In Appendix C. From this description, we seem to support the ODBC
* minimal (Level 0) grammar. @return true if so @exception SQLException if
* a database access error occurs
*/
public boolean supportsMinimumSQLGrammar() throws SQLException
{
return true;
}
/*
* Does this driver support the Core ODBC SQL grammar. We need SQL-92
* conformance for this. @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean supportsCoreSQLGrammar() throws SQLException
{
return false;
}
/*
* Does this driver support the Extended (Level 2) ODBC SQL grammar. We
* don't conform to the Core (Level 1), so we can't conform to the Extended
* SQL Grammar. @return true if so @exception SQLException if a database
* access error occurs
*/
public boolean supportsExtendedSQLGrammar() throws SQLException
{
return false;
}
/*
* Does this driver support the ANSI-92 entry level SQL grammar? All JDBC
* Compliant drivers must return true. We currently report false until
* 'schema' support is added. Then this should be changed to return true,
* since we will be mostly compliant (probably more compliant than many
* other databases) And since this is a requirement for all JDBC drivers we
* need to get to the point where we can return true. @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsANSI92EntryLevelSQL() throws SQLException
{
return true;
}
/*
* Does this driver support the ANSI-92 intermediate level SQL grammar?
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean supportsANSI92IntermediateSQL() throws SQLException
{
return false;
}
/*
* Does this driver support the ANSI-92 full SQL grammar? @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsANSI92FullSQL() throws SQLException
{
return false;
}
/*
* Is the SQL Integrity Enhancement Facility supported? Our best guess is
* that this means support for constraints @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsIntegrityEnhancementFacility() throws SQLException
{
return true;
}
/*
* Is some form of outer join supported? @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsOuterJoins() throws SQLException
{
return true;
}
/*
* Are full nexted outer joins supported? @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsFullOuterJoins() throws SQLException
{
return true;
}
/*
* Is there limited support for outer joins? @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsLimitedOuterJoins() throws SQLException
{
return true;
}
/*
* What is the database vendor's preferred term for "schema"? PostgreSQL
* doesn't have schemas, but when it does, we'll use the term "schema".
* @return the vendor term @exception SQLException if a database access
* error occurs
*/
public String getSchemaTerm() throws SQLException
{
return "schema";
}
/*
* What is the database vendor's preferred term for "procedure"?
* Traditionally, "function" has been used. @return the vendor term
* @exception SQLException if a database access error occurs
*/
public String getProcedureTerm() throws SQLException
{
return "function";
}
/*
* What is the database vendor's preferred term for "catalog"? @return the
* vendor term @exception SQLException if a database access error occurs
*/
public String getCatalogTerm() throws SQLException
{
return "database";
}
/*
* Does a catalog appear at the start of a qualified table name? (Otherwise
* it appears at the end). @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean isCatalogAtStart() throws SQLException
{
// return true here; we return false for every other catalog function
// so it won't matter what we return here D.C.
return true;
}
/*
* What is the Catalog separator. @return the catalog separator string
* @exception SQLException if a database access error occurs
*/
public String getCatalogSeparator() throws SQLException
{
// Give them something to work with here
// everything else returns false so it won't matter what we return here
// D.C.
return ".";
}
/*
* Can a schema name be used in a data manipulation statement? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInDataManipulation() throws SQLException
{
return true;
}
/*
* Can a schema name be used in a procedure call statement? @return true if
* so @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInProcedureCalls() throws SQLException
{
return true;
}
/*
* Can a schema be used in a table definition statement? @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInTableDefinitions() throws SQLException
{
return true;
}
/*
* Can a schema name be used in an index definition statement? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInIndexDefinitions() throws SQLException
{
return true;
}
/*
* Can a schema name be used in a privilege definition statement? @return
* true if so @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException
{
return true;
}
/*
* Can a catalog name be used in a data manipulation statement? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInDataManipulation() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a procedure call statement? @return true if
* so @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInProcedureCalls() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a table definition statement? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInTableDefinitions() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in an index definition? @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInIndexDefinitions() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a privilege definition statement? @return
* true if so @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException
{
return false;
}
/*
* We support cursors for gets only it seems. I dont see a method to get a
* positioned delete. @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean supportsPositionedDelete() throws SQLException
{
return false; // For now...
}
/*
* Is positioned UPDATE supported? @return true if so @exception
* SQLException if a database access error occurs
*/
public boolean supportsPositionedUpdate() throws SQLException
{
return false; // For now...
}
/*
* Is SELECT for UPDATE supported? @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSelectForUpdate() throws SQLException
{
return true;
}
/*
* Are stored procedure calls using the stored procedure escape syntax
* supported? @return true if so; false otherwise @exception SQLException -
* if a database access error occurs
*/
public boolean supportsStoredProcedures() throws SQLException
{
return false;
}
/*
* Are subqueries in comparison expressions supported? A JDBC Compliant
* driver always returns true. @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInComparisons() throws SQLException
{
return true;
}
/*
* Are subqueries in 'exists' expressions supported? A JDBC Compliant driver
* always returns true. @return true if so; false otherwise @exception
* SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInExists() throws SQLException
{
return true;
}
/*
* Are subqueries in 'in' statements supported? A JDBC Compliant driver
* always returns true. @return true if so; false otherwise @exception
* SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInIns() throws SQLException
{
return true;
}
/*
* Are subqueries in quantified expressions supported? A JDBC Compliant
* driver always returns true. (No idea what this is, but we support a good
* deal of subquerying.) @return true if so; false otherwise @exception
* SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInQuantifieds() throws SQLException
{
return true;
}
/*
* Are correlated subqueries supported? A JDBC Compliant driver always
* returns true. (a.k.a. subselect in from?) @return true if so; false
* otherwise @exception SQLException - if a database access error occurs
*/
public boolean supportsCorrelatedSubqueries() throws SQLException
{
return true;
}
/*
* Is SQL UNION supported? @return true if so @exception SQLException if a
* database access error occurs
*/
public boolean supportsUnion() throws SQLException
{
return true;
}
/*
* Is SQL UNION ALL supported? @return true if so @exception SQLException if
* a database access error occurs
*/
public boolean supportsUnionAll() throws SQLException
{
return true;
}
/*
* In PostgreSQL, Cursors are only open within transactions. @return true if
* so @exception SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossCommit() throws SQLException
{
return false;
}
/*
* Do we support open cursors across multiple transactions? @return true if
* so @exception SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossRollback() throws SQLException
{
return false;
}
/*
* Can statements remain open across commits? They may, but this driver
* cannot guarentee that. In further reflection. we are talking a Statement
* object here, so the answer is yes, since the Statement is only a vehicle
* to ExecSQL() @return true if they always remain open; false otherwise
* @exception SQLException if a database access error occurs
*/
public boolean supportsOpenStatementsAcrossCommit() throws SQLException
{
return true;
}
/*
* Can statements remain open across rollbacks? They may, but this driver
* cannot guarentee that. In further contemplation, we are talking a
* Statement object here, so the answer is yes, since the Statement is only
* a vehicle to ExecSQL() in Connection @return true if they always remain
* open; false otherwise @exception SQLException if a database access error
* occurs
*/
public boolean supportsOpenStatementsAcrossRollback() throws SQLException
{
return true;
}
/*
* How many hex characters can you have in an inline binary literal @return
* the max literal length @exception SQLException if a database access error
* occurs
*/
public int getMaxBinaryLiteralLength() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum length for a character literal I suppose it is 8190
* (8192 - 2 for the quotes) @return the max literal length @exception
* SQLException if a database access error occurs
*/
public int getMaxCharLiteralLength() throws SQLException
{
return 0; // no limit
}
/*
* Whats the limit on column name length. @return the maximum column name
* length @exception SQLException if a database access error occurs
*/
public int getMaxColumnNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum number of columns in a "GROUP BY" clause? @return the
* max number of columns @exception SQLException if a database access error
* occurs
*/
public int getMaxColumnsInGroupBy() throws SQLException
{
return 0; // no limit
}
/*
* What's the maximum number of columns allowed in an index? @return max
* number of columns @exception SQLException if a database access error
* occurs
*/
public int getMaxColumnsInIndex() throws SQLException
{
return getMaxIndexKeys();
}
/*
* What's the maximum number of columns in an "ORDER BY clause? @return the
* max columns @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInOrderBy() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum number of columns in a "SELECT" list? @return the max
* columns @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInSelect() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum number of columns in a table? From the CREATE TABLE
* reference page...
"The new class is created as a heap with no initial
* data. A class can have no more than 1600 attributes (realistically, this
* is limited by the fact that tuple sizes must be less than 8192 bytes)..."
* @return the max columns @exception SQLException if a database access
* error occurs
*/
public int getMaxColumnsInTable() throws SQLException
{
return 1600;
}
/*
* How many active connection can we have at a time to this database? Well,
* since it depends on postmaster, which just does a listen() followed by an
* accept() and fork(), its basically very high. Unless the system runs out
* of processes, it can be 65535 (the number of aux. ports on a TCP/IP
* system). I will return 8192 since that is what even the largest system
* can realistically handle, @return the maximum number of connections
* @exception SQLException if a database access error occurs
*/
public int getMaxConnections() throws SQLException
{
return 8192;
}
/*
* What is the maximum cursor name length @return max cursor name length in
* bytes @exception SQLException if a database access error occurs
*/
public int getMaxCursorNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* Retrieves the maximum number of bytes for an index, including all of the
* parts of the index. @return max index length in bytes, which includes the
* composite of all the constituent parts of the index; a result of zero
* means that there is no limit or the limit is not known @exception
* SQLException if a database access error occurs
*/
public int getMaxIndexLength() throws SQLException
{
return 0; // no limit (larger than an int anyway)
}
public int getMaxSchemaNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum length of a procedure name @return the max name
* length in bytes @exception SQLException if a database access error occurs
*/
public int getMaxProcedureNameLength() throws SQLException
{
return getMaxNameLength();
}
public int getMaxCatalogNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum length of a single row? @return max row size in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxRowSize() throws SQLException
{
return 1073741824; // 1 GB
}
/*
* Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY blobs? We don't
* handle blobs yet @return true if so @exception SQLException if a database
* access error occurs
*/
public boolean doesMaxRowSizeIncludeBlobs() throws SQLException
{
return false;
}
/*
* What is the maximum length of a SQL statement? @return max length in
* bytes @exception SQLException if a database access error occurs
*/
public int getMaxStatementLength() throws SQLException
{
return 0; // actually whatever fits in size_t
}
/*
* How many active statements can we have open at one time to this database?
* Basically, since each Statement downloads the results as the query is
* executed, we can have many. However, we can only really have one
* statement per connection going at once (since they are executed serially) -
* so we return one. @return the maximum @exception SQLException if a
* database access error occurs
*/
public int getMaxStatements() throws SQLException
{
return 1;
}
/*
* What is the maximum length of a table name @return max name length in
* bytes @exception SQLException if a database access error occurs
*/
public int getMaxTableNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum number of tables that can be specified in a SELECT?
* @return the maximum @exception SQLException if a database access error
* occurs
*/
public int getMaxTablesInSelect() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum length of a user name @return the max name length in
* bytes @exception SQLException if a database access error occurs
*/
public int getMaxUserNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the database's default transaction isolation level? We do not
* support this, so all transactions are SERIALIZABLE. @return the default
* isolation level @exception SQLException if a database access error occurs
*
* @see Connection
*/
public int getDefaultTransactionIsolation() throws SQLException
{
return Connection.TRANSACTION_READ_COMMITTED;
}
/*
* Are transactions supported? If not, commit and rollback are noops and the
* isolation level is TRANSACTION_NONE. We do support transactions. @return
* true if transactions are supported @exception SQLException if a database
* access error occurs
*/
public boolean supportsTransactions() throws SQLException
{
return true;
}
/*
* Does the database support the given transaction isolation level? We only
* support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED @param
* level the values are defined in java.sql.Connection @return true if so
* @exception SQLException if a database access error occurs
*
* @see Connection
*/
public boolean supportsTransactionIsolationLevel(int level)
throws SQLException
{
if(level == Connection.TRANSACTION_SERIALIZABLE
|| level == Connection.TRANSACTION_READ_COMMITTED)
return true;
if(this.getDatabaseMajorVersion() >= 8
&& (level == Connection.TRANSACTION_READ_UNCOMMITTED || level == Connection.TRANSACTION_REPEATABLE_READ))
return true;
return false;
}
/*
* Are both data definition and data manipulation transactions supported?
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean supportsDataDefinitionAndDataManipulationTransactions()
throws SQLException
{
return true;
}
/*
* Are only data manipulation statements withing a transaction supported?
* @return true if so @exception SQLException if a database access error
* occurs
*/
public boolean supportsDataManipulationTransactionsOnly()
throws SQLException
{
return false;
}
/*
* Does a data definition statement within a transaction force the
* transaction to commit? I think this means something like:
* CREATE TABLE T (A INT); INSERT INTO T (A) VALUES (2); BEGIN; UPDATE T SET
* A = A + 1; CREATE TABLE X (A INT); SELECT A FROM T INTO X; COMMIT;
* does the CREATE TABLE call cause a commit? The answer is no. @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean dataDefinitionCausesTransactionCommit() throws SQLException
{
return false;
}
/*
* Is a data definition statement within a transaction ignored? @return true
* if so @exception SQLException if a database access error occurs
*/
public boolean dataDefinitionIgnoredInTransactions() throws SQLException
{
return false;
}
/**
* Escape single quotes with another single quote.
*/
private static String escapeQuotes(String s)
{
if (s == null)
{
return null;
}
StringBuffer sb = new StringBuffer();
int length = s.length();
char prevChar = ' ';
char prevPrevChar = ' ';
for(int i = 0; i < length; i++)
{
char c = s.charAt(i);
sb.append(c);
if(c == '\''
&& (prevChar != '\\' || (prevChar == '\\' && prevPrevChar == '\\')))
{
sb.append("'");
}
prevPrevChar = prevChar;
prevChar = c;
}
return sb.toString();
}
/**
* Creates a condition with the specified operator
* based on schema specification:
*
* - schema is specified => search in this schema only
* - schema is equal to "" => search in the 'public' schema
* - schema is null => search in all schemas
*
*/
private static String resolveSchemaConditionWithOperator(
String expr, String schema, String operator)
{
//schema is null => search in current_schemas(true)
if (schema == null)
{
//This means that only "visible" schemas are searched.
//It was approved to change to *all* schemas.
//return expr + " " + operator + " ANY (current_schemas(true))";
return "1=1";
}
//schema is specified => search in this schema
else if(!"".equals(schema))
{
return expr + " " + operator + " '" + escapeQuotes(schema) + "' ";
}
//schema is "" => search in the 'public' schema
else
{
return expr + " " + operator + " 'public' ";
}
}
/**
* Creates an equality condition based on schema specification:
*
* - schema is specified => search in this schema only
* - schema is equal to "" => search in the 'public' schema
* - schema is null => search in all schemas
*
*/
private static String resolveSchemaCondition(String expr, String schema)
{
return resolveSchemaConditionWithOperator(expr, schema, "=");
}
/**
* Creates a pattern condition based on schema specification:
*
* - schema is specified => search in this schema only
* - schema is equal to "" => search in the 'public' schema
* - schema is null => search in all schemas
*
*/
private static String resolveSchemaPatternCondition(
String expr, String schema)
{
return resolveSchemaConditionWithOperator(expr, schema, "LIKE");
}
/*
* Get a description of stored procedures available in a catalog Only
* procedure descriptions matching the schema and procedure name criteria
* are returned. They are ordered by PROCEDURE_SCHEM and PROCEDURE_NAME
Each
* procedure description has the following columns:
- PROCEDURE_CAT
* String => procedure catalog (may be null)
- PROCEDURE_SCHEM
* String => procedure schema (may be null)
- PROCEDURE_NAME
* String => procedure name
- ResultSetField 4 reserved (make it
* null)
- ResultSetField 5 reserved (make it null)
- ResultSetField
* 6 reserved (make it null)
- REMARKS String => explanatory
* comment on the procedure
- PROCEDURE_TYPE short => kind of
* procedure
- procedureResultUnknown - May return a result
-
* procedureNoResult - Does not return a result
- procedureReturnsResult -
* Returns a result
@param catalog - a catalog name; ""
* retrieves those without a catalog; null means drop catalog name from
* criteria @param schemaParrern - a schema name pattern; "" retrieves those
* without a schema - we ignore this parameter @param procedureNamePattern -
* a procedure name pattern @return ResultSet - each row is a procedure
* description @exception SQLException if a database access error occurs
*/
public java.sql.ResultSet getProcedures(String catalog,
String schemaPattern, String procedureNamePattern) throws SQLException
{
String sql = "SELECT NULL AS PROCEDURE_CAT, n.nspname AS PROCEDURE_SCHEM, p.proname AS PROCEDURE_NAME, NULL, NULL, NULL, d.description AS REMARKS, "
+ java.sql.DatabaseMetaData.procedureReturnsResult
+ " AS PROCEDURE_TYPE "
+ " FROM pg_catalog.pg_namespace n, pg_catalog.pg_proc p "
+ " LEFT JOIN pg_catalog.pg_description d ON (p.oid=d.objoid) "
+ " LEFT JOIN pg_catalog.pg_class c ON (d.classoid=c.oid AND c.relname='pg_proc') "
+ " LEFT JOIN pg_catalog.pg_namespace pn ON (c.relnamespace=pn.oid AND pn.nspname='pg_catalog') "
+ " WHERE p.pronamespace=n.oid "
+ " AND " + resolveSchemaPatternCondition(
"n.nspname", schemaPattern);
if(procedureNamePattern != null)
{
sql += " AND p.proname LIKE '"
+ escapeQuotes(procedureNamePattern) + "' ";
}
sql += " ORDER BY PROCEDURE_SCHEM, PROCEDURE_NAME ";
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get a description of a catalog's stored procedure parameters and result
* columns. Only descriptions matching the schema, procedure and
* parameter name criteria are returned. They are ordered by PROCEDURE_SCHEM
* and PROCEDURE_NAME. Within this, the return value, if any, is first. Next
* are the parameter descriptions in call order. The column descriptions
* follow in column number order.
Each row in the ResultSet is a
* parameter description or column description with the following fields:
*
- PROCEDURE_CAT String => procedure catalog (may be null)
*
- PROCEDURE_SCHEM String => procedure schema (may be null)
*
- PROCEDURE_NAME String => procedure name
- COLUMN_NAME
* String => column/parameter name
- COLUMN_TYPE Short => kind of
* column/parameter:
- procedureColumnUnknown - nobody knows
- procedureColumnIn -
* IN parameter
- procedureColumnInOut - INOUT parameter
- procedureColumnOut -
* OUT parameter
- procedureColumnReturn - procedure return value
- procedureColumnResult -
* result column in ResultSet
- DATA_TYPE short => SQL type
* from java.sql.Types
- TYPE_NAME String => Data source specific
* type name
- PRECISION int => precision
- LENGTH int =>
* length in bytes of data
- SCALE short => scale
- RADIX
* short => radix
- NULLABLE short => can it contain NULL?
- procedureNoNulls -
* does not allow NULL values
- procedureNullable - allows NULL values
*
- procedureNullableUnknown - nullability unknown
- REMARKS
* String => comment describing parameter/column
@param catalog This
* is ignored in org.postgresql, advise this is set to null @param
* schemaPattern @param procedureNamePattern a procedure name pattern @param
* columnNamePattern a column name pattern, this is currently ignored
* because postgresql does not name procedure parameters. @return each row
* is a stored procedure parameter or column description @exception
* SQLException if a database-access error occurs
*
* @see #getSearchStringEscape
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getProcedureColumns(String catalog,
String schemaPattern, String procedureNamePattern,
String columnNamePattern) throws SQLException
{
ResultSetField f[] = new ResultSetField[13];
ArrayList v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new ResultSetField("PROCEDURE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("PROCEDURE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("PROCEDURE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[3] = new ResultSetField("COLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("COLUMN_TYPE", TypeOid.INT2, 2);
f[5] = new ResultSetField("DATA_TYPE", TypeOid.INT2, 2);
f[6] = new ResultSetField("TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[7] = new ResultSetField("PRECISION", TypeOid.INT4, 4);
f[8] = new ResultSetField("LENGTH", TypeOid.INT4, 4);
f[9] = new ResultSetField("SCALE", TypeOid.INT2, 2);
f[10] = new ResultSetField("RADIX", TypeOid.INT2, 2);
f[11] = new ResultSetField("NULLABLE", TypeOid.INT2, 2);
f[12] = new ResultSetField("REMARKS", TypeOid.VARCHAR,
getMaxNameLength());
String sql = "SELECT n.nspname,p.proname,p.prorettype,p.proargtypes, t.typtype::varchar,t.typrelid "
+ " FROM pg_catalog.pg_proc p,pg_catalog.pg_namespace n, pg_catalog.pg_type t "
+ " WHERE p.pronamespace=n.oid AND p.prorettype=t.oid "
+ " AND " + resolveSchemaPatternCondition(
"n.nspname", schemaPattern);
if(procedureNamePattern != null)
{
sql += " AND p.proname LIKE '"
+ escapeQuotes(procedureNamePattern) + "' ";
}
sql += " ORDER BY n.nspname, p.proname ";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
String schema = null;
String procedureName = null;
Oid returnType = null;
String returnTypeType = null;
Oid returnTypeRelid = null;
Oid[] argTypes = null;
while(rs.next())
{
schema = rs.getString("nspname");
procedureName = rs.getString("proname");
returnType = (Oid)rs.getObject("prorettype");
returnTypeType = rs.getString("typtype");
returnTypeRelid = (Oid)rs.getObject("typrelid");
argTypes = (Oid[])rs.getObject("proargtypes");
// decide if we are returning a single column result.
if(!returnTypeType.equals("c"))
{
Object[] tuple = new Object[13];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = procedureName;
tuple[3] = "returnValue";
tuple[4] = new Short((short)java.sql.DatabaseMetaData.procedureColumnReturn);
tuple[5] = new Short((short)m_connection.getSQLType(returnType));
tuple[6] = m_connection.getPGType(returnType);
tuple[7] = null;
tuple[8] = null;
tuple[9] = null;
tuple[10] = null;
tuple[11] = new Short((short)java.sql.DatabaseMetaData.procedureNullableUnknown);
tuple[12] = null;
v.add(tuple);
}
// Add a row for each argument.
for(int i = 0; i < argTypes.length; i++)
{
Oid argOid = argTypes[i];
Object[] tuple = new Object[13];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = procedureName;
tuple[3] = "$" + (i + 1);
tuple[4] = new Short((short)java.sql.DatabaseMetaData.procedureColumnIn);
tuple[5] = new Short((short)m_connection.getSQLType(argOid));
tuple[6] = m_connection.getPGType(argOid);
tuple[7] = null;
tuple[8] = null;
tuple[9] = null;
tuple[10] = null;
tuple[11] = new Short((short)java.sql.DatabaseMetaData.procedureNullableUnknown);
tuple[12] = null;
v.add(tuple);
}
// if we are returning a multi-column result.
if(returnTypeType.equals("c"))
{
String columnsql = "SELECT a.attname,a.atttypid FROM pg_catalog.pg_attribute a WHERE a.attrelid = ? ORDER BY a.attnum ";
PreparedStatement stmt = m_connection.prepareStatement(columnsql);
stmt.setObject(1, returnTypeRelid);
ResultSet columnrs = stmt.executeQuery(columnsql);
while(columnrs.next())
{
Oid columnTypeOid = (Oid)columnrs.getObject("atttypid");
Object[] tuple = new Object[13];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = procedureName;
tuple[3] = columnrs.getString("attname");
tuple[4] = new Short((short)java.sql.DatabaseMetaData.procedureColumnResult);
tuple[5] = new Short((short)m_connection.getSQLType(columnTypeOid));
tuple[6] = m_connection.getPGType(columnTypeOid);
tuple[7] = null;
tuple[8] = null;
tuple[9] = null;
tuple[10] = null;
tuple[11] = new Short((short)java.sql.DatabaseMetaData.procedureNullableUnknown);
tuple[12] = null;
v.add(tuple);
}
columnrs.close();
stmt.close();
}
}
rs.close();
return createSyntheticResultSet(f, v);
}
/*
* Get a description of tables available in a catalog. Only table
* descriptions matching the catalog, schema, table name and type criteria
* are returned. They are ordered by TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.
*
Each table description has the following columns:
- TABLE_CAT
* String => table catalog (may be null)
- TABLE_SCHEM String =>
* table schema (may be null)
- TABLE_NAME String => table name
*
- TABLE_TYPE String => table type. Typical types are "TABLE",
* "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS",
* "SYNONYM".
- REMARKS String => explanatory comment on the
* table
The valid values for the types parameter are: "TABLE",
* "INDEX", "SEQUENCE", "VIEW", "SYSTEM TABLE", "SYSTEM INDEX", "SYSTEM
* VIEW", "SYSTEM TOAST TABLE", "SYSTEM TOAST INDEX", "TEMPORARY TABLE", and
* "TEMPORARY VIEW" @param catalog a catalog name; For org.postgresql, this
* is ignored, and should be set to null @param schemaPattern a schema name
* pattern @param tableNamePattern a table name pattern. For all tables this
* should be "%" @param types a list of table types to include; null returns
* all types @return each row is a table description @exception SQLException
* if a database-access error occurs.
*/
public java.sql.ResultSet getTables(String catalog, String schemaPattern,
String tableNamePattern, String types[]) throws SQLException
{
String useSchemas = "SCHEMAS";
String select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, c.relname AS TABLE_NAME, "
+ " CASE n.nspname LIKE 'pg!_%' ESCAPE '!' OR n.nspname = 'information_schema' "
+ " WHEN true THEN CASE "
+ " WHEN n.nspname = 'pg_catalog' OR n.nspname = 'information_schema' THEN CASE c.relkind "
+ " WHEN 'r' THEN 'SYSTEM TABLE' "
+ " WHEN 'v' THEN 'SYSTEM VIEW' "
+ " WHEN 'i' THEN 'SYSTEM INDEX' "
+ " ELSE NULL "
+ " END "
+ " WHEN n.nspname = 'pg_toast' THEN CASE c.relkind "
+ " WHEN 'r' THEN 'SYSTEM TOAST TABLE' "
+ " WHEN 'i' THEN 'SYSTEM TOAST INDEX' "
+ " ELSE NULL "
+ " END "
+ " ELSE CASE c.relkind "
+ " WHEN 'r' THEN 'TEMPORARY TABLE' "
+ " WHEN 'i' THEN 'TEMPORARY INDEX' "
+ " ELSE NULL "
+ " END "
+ " END "
+ " WHEN false THEN CASE c.relkind "
+ " WHEN 'r' THEN 'TABLE' "
+ " WHEN 'i' THEN 'INDEX' "
+ " WHEN 'S' THEN 'SEQUENCE' "
+ " WHEN 'v' THEN 'VIEW' "
+ " ELSE NULL "
+ " END "
+ " ELSE NULL "
+ " END "
+ " AS TABLE_TYPE, d.description AS REMARKS "
+ " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c "
+ " LEFT JOIN pg_catalog.pg_description d ON (c.oid = d.objoid AND d.objsubid = 0) "
+ " LEFT JOIN pg_catalog.pg_class dc ON (d.classoid=dc.oid AND dc.relname='pg_class') "
+ " LEFT JOIN pg_catalog.pg_namespace dn ON (dn.oid=dc.relnamespace AND dn.nspname='pg_catalog') "
+ " WHERE c.relnamespace = n.oid "
+ " AND " + resolveSchemaPatternCondition(
"n.nspname", schemaPattern);
String orderby = " ORDER BY TABLE_TYPE,TABLE_SCHEM,TABLE_NAME ";
if(types == null)
{
types = s_defaultTableTypes;
}
if(tableNamePattern != null)
{
select += " AND c.relname LIKE '" + escapeQuotes(tableNamePattern)
+ "' ";
}
String sql = select;
sql += " AND (false ";
for(int i = 0; i < types.length; i++)
{
HashMap clauses = (HashMap)s_tableTypeClauses.get(types[i]);
if(clauses != null)
{
String clause = (String)clauses.get(useSchemas);
sql += " OR ( " + clause + " ) ";
}
}
sql += ") ";
sql += orderby;
return createMetaDataStatement().executeQuery(sql);
}
private static final HashMap s_tableTypeClauses;
static
{
s_tableTypeClauses = new HashMap();
HashMap ht = new HashMap();
s_tableTypeClauses.put("TABLE", ht);
ht.put("SCHEMAS",
"c.relkind = 'r' AND n.nspname NOT LIKE 'pg!_%' ESCAPE '!' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS",
"c.relkind = 'r' AND c.relname NOT LIKE 'pg!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("VIEW", ht);
ht.put("SCHEMAS",
"c.relkind = 'v' AND n.nspname <> 'pg_catalog' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS",
"c.relkind = 'v' AND c.relname NOT LIKE 'pg!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("INDEX", ht);
ht.put("SCHEMAS",
"c.relkind = 'i' AND n.nspname NOT LIKE 'pg!_%' ESCAPE '!' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS",
"c.relkind = 'i' AND c.relname NOT LIKE 'pg!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("SEQUENCE", ht);
ht.put("SCHEMAS", "c.relkind = 'S'");
ht.put("NOSCHEMAS", "c.relkind = 'S'");
ht = new HashMap();
s_tableTypeClauses.put("SYSTEM TABLE", ht);
ht.put("SCHEMAS",
"c.relkind = 'r' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema')");
ht.put("NOSCHEMAS",
"c.relkind = 'r' AND c.relname LIKE 'pg!_%' ESCAPE '!' AND c.relname NOT LIKE 'pgLIKE 'pg!_toast!_%' ESCAPE '!'toast!_%' ESCAPE '!' AND c.relname NOT LIKE 'pg!_temp!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("SYSTEM TOAST TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'r' AND n.nspname = 'pg_toast'");
ht.put("NOSCHEMAS",
"c.relkind = 'r' AND c.relname LIKE 'pg!_toast!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("SYSTEM TOAST INDEX", ht);
ht.put("SCHEMAS", "c.relkind = 'i' AND n.nspname = 'pg_toast'");
ht.put("NOSCHEMAS",
"c.relkind = 'i' AND c.relname LIKE 'pg!_toast!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("SYSTEM VIEW", ht);
ht.put("SCHEMAS",
"c.relkind = 'v' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema') ");
ht.put("NOSCHEMAS", "c.relkind = 'v' AND c.relname LIKE 'pg!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("SYSTEM INDEX", ht);
ht.put("SCHEMAS",
"c.relkind = 'i' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema') ");
ht.put("NOSCHEMAS",
"c.relkind = 'v' AND c.relname LIKE 'pg!_%' ESCAPE '!' AND c.relname NOT LIKE 'pg!_toast!_%' ESCAPE '!' AND c.relname NOT LIKE 'pg!_temp!_%' ESCAPE '!'");
ht = new HashMap();
s_tableTypeClauses.put("TEMPORARY TABLE", ht);
ht.put("SCHEMAS",
"c.relkind = 'r' AND n.nspname LIKE 'pg!_temp!_%' ESCAPE '!' ");
ht.put("NOSCHEMAS",
"c.relkind = 'r' AND c.relname LIKE 'pg!_temp!_%' ESCAPE '!' ");
ht = new HashMap();
s_tableTypeClauses.put("TEMPORARY INDEX", ht);
ht.put("SCHEMAS",
"c.relkind = 'i' AND n.nspname LIKE 'pg!_temp!_%' ESCAPE '!' ");
ht.put("NOSCHEMAS",
"c.relkind = 'i' AND c.relname LIKE 'pg!_temp!_%' ESCAPE '!' ");
}
// These are the default tables, used when NULL is passed to getTables
// The choice of these provide the same behaviour as psql's \d
private static final String s_defaultTableTypes[] = { "TABLE", "VIEW",
"INDEX", "SEQUENCE", "TEMPORARY TABLE" };
/*
* Get the schema names available in this database. The results are ordered
* by schema name.
The schema column is:
- TABLE_SCHEM
* String => schema name
@return ResultSet each row has a single
* String column that is a schema name
*/
public java.sql.ResultSet getSchemas() throws SQLException
{
String sql = "SELECT nspname AS TABLE_SCHEM FROM pg_catalog.pg_namespace WHERE nspname <> 'pg_toast' AND nspname NOT LIKE 'pg!_temp!_%' ESCAPE '!' ORDER BY TABLE_SCHEM";
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get the catalog names available in this database. The results are ordered
* by catalog name. The catalog column is:
- TABLE_CAT
* String => catalog name
@return ResultSet each row has a single
* String column that is a catalog name
*/
public java.sql.ResultSet getCatalogs() throws SQLException
{
String sql = "SELECT datname AS TABLE_CAT FROM pg_catalog.pg_database ORDER BY TABLE_CAT";
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get the table types available in this database. The results are ordered
* by table type. The table type is:
- TABLE_TYPE String =>
* table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL
* TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
@return
* ResultSet each row has a single String column that is a table type
*/
public java.sql.ResultSet getTableTypes() throws SQLException
{
String types[] = (String[])s_tableTypeClauses.keySet().toArray(new String[s_tableTypeClauses.size()]);
sortStringArray(types);
ResultSetField f[] = new ResultSetField[1];
ArrayList v = new ArrayList();
f[0] = new ResultSetField(new String("TABLE_TYPE"), TypeOid.VARCHAR,
getMaxNameLength());
for(int i = 0; i < types.length; i++)
{
Object[] tuple = new Object[1];
tuple[0] = types[i];
v.add(tuple);
}
return createSyntheticResultSet(f, v);
}
/*
* Get a description of table columns available in a catalog. Only
* column descriptions matching the catalog, schema, table and column name
* criteria are returned. They are ordered by TABLE_SCHEM, TABLE_NAME and
* ORDINAL_POSITION.
Each column description has the following columns:
*
- TABLE_CAT String => table catalog (may be null)
- TABLE_SCHEM
* String => table schema (may be null)
- TABLE_NAME String =>
* table name
- COLUMN_NAME String => column name
- DATA_TYPE
* short => SQL type from java.sql.Types
- TYPE_NAME String =>
* Data source dependent type name
- COLUMN_SIZE int => column
* size. For char or date types this is the maximum number of characters,
* for numeric or decimal types this is precision.
- BUFFER_LENGTH
* is not used.
- DECIMAL_DIGITS int => the number of fractional
* digits
- NUM_PREC_RADIX int => Radix (typically either 10 or
* 2)
- NULLABLE int => is NULL allowed?
- columnNoNulls -
* might not allow NULL values
- columnNullable - definitely allows NULL
* values
- columnNullableUnknown - nullability unknown
- REMARKS
* String => comment describing column (may be null)
- COLUMN_DEF
* String => default value (may be null)
- SQL_DATA_TYPE int =>
* unused
- SQL_DATETIME_SUB int => unused
- CHAR_OCTET_LENGTH
* int => for char types the maximum number of bytes in the column
- ORDINAL_POSITION
* int => index of column in table (starting at 1)
- IS_NULLABLE
* String => "NO" means column definitely does not allow NULL values; "YES"
* means the column might allow NULL values. An empty string means nobody
* knows.
@param catalog a catalog name; "" retrieves those without a
* catalog @param schemaPattern a schema name pattern; "" retrieves those
* without a schema @param tableNamePattern a table name pattern @param
* columnNamePattern a column name pattern @return ResultSet each row is a
* column description
*
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getColumns(String catalog, String schemaPattern,
String tableNamePattern, String columnNamePattern) throws SQLException
{
ArrayList v = new ArrayList(); // The new ResultSet tuple stuff
ResultSetField f[] = new ResultSetField[18]; // The field descriptors
// for the new ResultSet
f[0] = new ResultSetField("TABLE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("TABLE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("TABLE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[3] = new ResultSetField("COLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("DATA_TYPE", TypeOid.INT2, 2);
f[5] = new ResultSetField("TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[6] = new ResultSetField("COLUMN_SIZE", TypeOid.INT4, 4);
f[7] = new ResultSetField("BUFFER_LENGTH", TypeOid.VARCHAR,
getMaxNameLength());
f[8] = new ResultSetField("DECIMAL_DIGITS", TypeOid.INT4, 4);
f[9] = new ResultSetField("NUM_PREC_RADIX", TypeOid.INT4, 4);
f[10] = new ResultSetField("NULLABLE", TypeOid.INT4, 4);
f[11] = new ResultSetField("REMARKS", TypeOid.VARCHAR,
getMaxNameLength());
f[12] = new ResultSetField("COLUMN_DEF", TypeOid.VARCHAR,
getMaxNameLength());
f[13] = new ResultSetField("SQL_DATA_TYPE", TypeOid.INT4, 4);
f[14] = new ResultSetField("SQL_DATETIME_SUB", TypeOid.INT4, 4);
f[15] = new ResultSetField("CHAR_OCTET_LENGTH", TypeOid.INT4, 4);
f[16] = new ResultSetField("ORDINAL_POSITION", TypeOid.INT4, 4);
f[17] = new ResultSetField("IS_NULLABLE", TypeOid.VARCHAR,
getMaxNameLength());
String sql = "SELECT n.nspname,c.relname,a.attname,"
+ " a.atttypid as atttypid,a.attnotnull,a.atttypmod,"
+ " a.attlen::int4 as attlen,a.attnum,def.adsrc,dsc.description "
+ " FROM pg_catalog.pg_namespace n "
+ " JOIN pg_catalog.pg_class c ON (c.relnamespace = n.oid) "
+ " JOIN pg_catalog.pg_attribute a ON (a.attrelid=c.oid) "
+ " LEFT JOIN pg_catalog.pg_attrdef def ON (a.attrelid=def.adrelid AND a.attnum = def.adnum) "
+ " LEFT JOIN pg_catalog.pg_description dsc ON (c.oid=dsc.objoid AND a.attnum = dsc.objsubid) "
+ " LEFT JOIN pg_catalog.pg_class dc ON (dc.oid=dsc.classoid AND dc.relname='pg_class') "
+ " LEFT JOIN pg_catalog.pg_namespace dn ON (dc.relnamespace=dn.oid AND dn.nspname='pg_catalog') "
+ " WHERE a.attnum > 0 AND NOT a.attisdropped "
+ " AND " + resolveSchemaPatternCondition(
"n.nspname", schemaPattern);
if(tableNamePattern != null && !"".equals(tableNamePattern))
{
sql += " AND c.relname LIKE '" + escapeQuotes(tableNamePattern)
+ "' ";
}
if(columnNamePattern != null && !"".equals(columnNamePattern))
{
sql += " AND a.attname LIKE '" + escapeQuotes(columnNamePattern)
+ "' ";
}
sql += " ORDER BY nspname,relname,attnum ";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
while(rs.next())
{
Object[] tuple = new Object[18];
Oid typeOid = (Oid)rs.getObject("atttypid");
tuple[0] = null; // Catalog name, not supported
tuple[1] = rs.getString("nspname"); // Schema
tuple[2] = rs.getString("relname"); // Table name
tuple[3] = rs.getString("attname"); // Column name
tuple[4] = new Short((short)m_connection.getSQLType(typeOid));
String pgType = m_connection.getPGType(typeOid);
tuple[5] = m_connection.getPGType(typeOid); // Type name
String defval = rs.getString("adsrc");
if(defval != null)
{
if(pgType.equals("int4"))
{
if(defval.indexOf("nextval(") != -1)
tuple[5] = "serial"; // Type name ==
// serial
}
else if(pgType.equals("int8"))
{
if(defval.indexOf("nextval(") != -1)
tuple[5] = "bigserial"; // Type name ==
// bigserial
}
}
// by default no decimal_digits
// if the type is numeric or decimal we will
// overwrite later.
tuple[8] = new Integer(0);
if(pgType.equals("bpchar") || pgType.equals("varchar"))
{
int atttypmod = rs.getInt("atttypmod");
tuple[6] = new Integer(atttypmod != -1
? atttypmod - VARHDRSZ
: 0);
}
else if(pgType.equals("numeric") || pgType.equals("decimal"))
{
int attypmod = rs.getInt("atttypmod") - VARHDRSZ;
tuple[6] = new Integer ((attypmod >> 16) & 0xffff);
tuple[8] = new Integer (attypmod & 0xffff);
tuple[9] = new Integer(10);
}
else if(pgType.equals("bit") || pgType.equals("varbit"))
{
tuple[6] = rs.getObject("atttypmod");
tuple[9] = new Integer(2);
}
else
{
tuple[6] = rs.getObject("attlen");
tuple[9] = new Integer(10);
}
tuple[7] = null; // Buffer length
tuple[10] = new Integer(rs
.getBoolean("attnotnull")
? java.sql.DatabaseMetaData.columnNoNulls
: java.sql.DatabaseMetaData.columnNullable); // Nullable
tuple[11] = rs.getString("description"); // Description (if any)
tuple[12] = rs.getString("adsrc"); // Column default
tuple[13] = null; // sql data type (unused)
tuple[14] = null; // sql datetime sub (unused)
tuple[15] = tuple[6]; // char octet length
tuple[16] = new Integer(rs.getInt("attnum")); // ordinal position
tuple[17] = rs.getBoolean("attnotnull") ? "NO" : "YES"; // Is
// nullable
v.add(tuple);
}
rs.close();
return createSyntheticResultSet(f, v);
}
/*
* Get a description of the access rights for a table's columns. Only
* privileges matching the column name criteria are returned. They are
* ordered by COLUMN_NAME and PRIVILEGE.
Each privilige description has
* the following columns:
- TABLE_CAT String => table
* catalog (may be null)
- TABLE_SCHEM String => table schema
* (may be null)
- TABLE_NAME String => table name
- COLUMN_NAME
* String => column name
- GRANTOR => grantor of access (may be
* null)
- GRANTEE String => grantee of access
- PRIVILEGE
* String => name of access (SELECT, INSERT, UPDATE, REFRENCES, ...)
- IS_GRANTABLE
* String => "YES" if grantee is permitted to grant to others; "NO" if not;
* null if unknown
@param catalog a catalog name; "" retrieves those
* without a catalog @param schema a schema name; "" retrieves those without
* a schema @param table a table name @param columnNamePattern a column name
* pattern @return ResultSet each row is a column privilege description
*
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getColumnPrivileges(String catalog,
String schema, String table, String columnNamePattern)
throws SQLException
{
ResultSetField f[] = new ResultSetField[8];
ArrayList v = new ArrayList();
if(table == null)
table = "%";
if(columnNamePattern == null)
columnNamePattern = "%";
f[0] = new ResultSetField("TABLE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("TABLE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("TABLE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[3] = new ResultSetField("COLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("GRANTOR", TypeOid.VARCHAR,
getMaxNameLength());
f[5] = new ResultSetField("GRANTEE", TypeOid.VARCHAR,
getMaxNameLength());
f[6] = new ResultSetField("PRIVILEGE", TypeOid.VARCHAR,
getMaxNameLength());
f[7] = new ResultSetField("IS_GRANTABLE", TypeOid.VARCHAR,
getMaxNameLength());
String sql = "SELECT n.nspname,c.relname,u.usename,c.relacl,a.attname "
+ " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_user u, pg_catalog.pg_attribute a "
+ " WHERE c.relnamespace = n.oid "
+ " AND u.usesysid = c.relowner " + " AND c.oid = a.attrelid "
+ " AND c.relkind = 'r' "
+ " AND a.attnum > 0 AND NOT a.attisdropped "
+ " AND " + resolveSchemaCondition(
"n.nspname", schema);
sql += " AND c.relname = '" + escapeQuotes(table) + "' ";
if(columnNamePattern != null && !"".equals(columnNamePattern))
{
sql += " AND a.attname LIKE '" + escapeQuotes(columnNamePattern)
+ "' ";
}
sql += " ORDER BY attname ";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
String schemaName = null;
String tableName = null;
String column = null;
String owner = null;
String[] acls = null;
HashMap permissions = null;
String permNames[] = null;
while(rs.next())
{
schemaName = rs.getString("nspname");
tableName = rs.getString("relname");
column = rs.getString("attname");
owner = rs.getString("usename");
acls = (String[])rs.getObject("relacl");
permissions = parseACL(acls, owner);
permNames = (String[])permissions.keySet().toArray(new String[permissions.size()]);
sortStringArray(permNames);
for(int i = 0; i < permNames.length; i++)
{
ArrayList grantees = (ArrayList)permissions.get(permNames[i]);
for(int j = 0; j < grantees.size(); j++)
{
String grantee = (String)grantees.get(j);
String grantable = owner.equals(grantee) ? "YES" : "NO";
Object[] tuple = new Object[8];
tuple[0] = null;
tuple[1] = schemaName;
tuple[2] = tableName;
tuple[3] = column;
tuple[4] = owner;
tuple[5] = grantee;
tuple[6] = permNames[i];
tuple[7] = grantable;
v.add(tuple);
}
}
}
rs.close();
return createSyntheticResultSet(f, v);
}
/*
* Get a description of the access rights for each table available in a
* catalog. This method is currently unimplemented. Only privileges
* matching the schema and table name criteria are returned. They are
* ordered by TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
Each privilige
* description has the following columns:
- TABLE_CAT String =>
* table catalog (may be null)
- TABLE_SCHEM String => table
* schema (may be null)
- TABLE_NAME String => table name
- GRANTOR =>
* grantor of access (may be null)
- GRANTEE String => grantee of
* access
- PRIVILEGE String => name of access (SELECT, INSERT,
* UPDATE, REFRENCES, ...)
- IS_GRANTABLE String => "YES" if
* grantee is permitted to grant to others; "NO" if not; null if unknown
*
@param catalog a catalog name; "" retrieves those without a catalog
* @param schemaPattern a schema name pattern; "" retrieves those without a
* schema @param tableNamePattern a table name pattern @return ResultSet
* each row is a table privilege description
*
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getTablePrivileges(String catalog,
String schemaPattern, String tableNamePattern) throws SQLException
{
ResultSetField f[] = new ResultSetField[7];
ArrayList v = new ArrayList();
f[0] = new ResultSetField("TABLE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("TABLE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("TABLE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[3] = new ResultSetField("GRANTOR", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("GRANTEE", TypeOid.VARCHAR,
getMaxNameLength());
f[5] = new ResultSetField("PRIVILEGE", TypeOid.VARCHAR,
getMaxNameLength());
f[6] = new ResultSetField("IS_GRANTABLE", TypeOid.VARCHAR,
getMaxNameLength());
String sql = "SELECT n.nspname,c.relname,u.usename,c.relacl "
+ " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_user u "
+ " WHERE c.relnamespace = n.oid "
+ " AND u.usesysid = c.relowner " + " AND c.relkind = 'r' "
+ " AND " + resolveSchemaPatternCondition(
"n.nspname", schemaPattern);
if(tableNamePattern != null && !"".equals(tableNamePattern))
{
sql += " AND c.relname LIKE '" + escapeQuotes(tableNamePattern)
+ "' ";
}
sql += " ORDER BY nspname, relname ";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
String schema = null;
String table = null;
String owner = null;
String[] acls = null;
HashMap permissions = null;
String permNames[] = null;
while(rs.next())
{
schema = rs.getString("nspname");
table = rs.getString("relname");
owner = rs.getString("usename");
acls = (String[])rs.getObject("relacl");
permissions = parseACL(acls, owner);
permNames = (String[])permissions.keySet().toArray(new String[permissions.size()]);
sortStringArray(permNames);
for(int i = 0; i < permNames.length; i++)
{
ArrayList grantees = (ArrayList)permissions.get(permNames[i]);
for(int j = 0; j < grantees.size(); j++)
{
String grantee = (String)grantees.get(j);
String grantable = owner.equals(grantee) ? "YES" : "NO";
Object[] tuple = new Object[7];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = table;
tuple[3] = owner;
tuple[4] = grantee;
tuple[5] = permNames[i];
tuple[6] = grantable;
v.add(tuple);
}
}
}
rs.close();
return createSyntheticResultSet(f, v);
}
private static void sortStringArray(String s[])
{
for(int i = 0; i < s.length - 1; i++)
{
for(int j = i + 1; j < s.length; j++)
{
if(s[i].compareTo(s[j]) > 0)
{
String tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
}
}
}
/**
* Add the user described by the given acl to the ArrayLists of users with the
* privileges described by the acl.
*/
private void addACLPrivileges(String acl, HashMap privileges)
{
int equalIndex = acl.lastIndexOf("=");
String name = acl.substring(0, equalIndex);
if(name.length() == 0)
{
name = "PUBLIC";
}
String privs = acl.substring(equalIndex + 1);
for(int i = 0; i < privs.length(); i++)
{
char c = privs.charAt(i);
String sqlpriv;
switch(c)
{
case 'a':
sqlpriv = "INSERT";
break;
case 'r':
sqlpriv = "SELECT";
break;
case 'w':
sqlpriv = "UPDATE";
break;
case 'd':
sqlpriv = "DELETE";
break;
case 'R':
sqlpriv = "RULE";
break;
case 'x':
sqlpriv = "REFERENCES";
break;
case 't':
sqlpriv = "TRIGGER";
break;
// the folloowing can't be granted to a table, but
// we'll keep them for completeness.
case 'X':
sqlpriv = "EXECUTE";
break;
case 'U':
sqlpriv = "USAGE";
break;
case 'C':
sqlpriv = "CREATE";
break;
case 'T':
sqlpriv = "CREATE TEMP";
break;
default:
sqlpriv = "UNKNOWN";
}
ArrayList usersWithPermission = (ArrayList)privileges.get(sqlpriv);
if(usersWithPermission == null)
{
usersWithPermission = new ArrayList();
privileges.put(sqlpriv, usersWithPermission);
}
usersWithPermission.add(name);
}
}
/**
* Take the a String representing an array of ACLs and return a HashMap
* mapping the SQL permission name to a ArrayList of usernames who have that
* permission.
*/
protected HashMap parseACL(String[] aclArray, String owner)
{
if(aclArray == null || aclArray.length == 0)
{
// null acl is a shortcut for owner having full privs
aclArray = new String[] { owner + "=arwdRxt" };
}
HashMap privileges = new HashMap();
for(int i = 0; i < aclArray.length; i++)
{
String acl = aclArray[i];
addACLPrivileges(acl, privileges);
}
return privileges;
}
/*
* Get a description of a table's optimal set of columns that uniquely
* identifies a row. They are ordered by SCOPE. Each column description
* has the following columns:
- SCOPE short => actual scope
* of result
- bestRowTemporary - very temporary, while using row
*
- bestRowTransaction - valid for remainder of current transaction
-
* bestRowSession - valid for remainder of current session
- COLUMN_NAME
* String => column name
- DATA_TYPE short => SQL data type from
* java.sql.Types
- TYPE_NAME String => Data source dependent
* type name
- COLUMN_SIZE int => precision
- BUFFER_LENGTH
* int => not used
- DECIMAL_DIGITS short => scale
- PSEUDO_COLUMN
* short => is this a pseudo column like an Oracle ROWID
-
* bestRowUnknown - may or may not be pseudo column
- bestRowNotPseudo -
* is NOT a pseudo column
- bestRowPseudo - is a pseudo column
*
@param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name; "" retrieves those without a schema @param
* table a table name @param scope the scope of interest; use same values as
* SCOPE @param nullable include columns that are nullable? @return
* ResultSet each row is a column description
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getBestRowIdentifier(String catalog,
String schema, String table, int scope, boolean nullable)
throws SQLException
{
ResultSetField f[] = new ResultSetField[8];
ArrayList v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new ResultSetField("SCOPE", TypeOid.INT2, 2);
f[1] = new ResultSetField("COLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("DATA_TYPE", TypeOid.INT2, 2);
f[3] = new ResultSetField("TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("COLUMN_SIZE", TypeOid.INT4, 4);
f[5] = new ResultSetField("BUFFER_LENGTH", TypeOid.INT4, 4);
f[6] = new ResultSetField("DECIMAL_DIGITS", TypeOid.INT2, 2);
f[7] = new ResultSetField("PSEUDO_COLUMN", TypeOid.INT2, 2);
/*
* At the moment this simply returns a table's primary key, if there is
* one. I believe other unique indexes, ctid, and oid should also be
* considered. -KJ
*/
String where = "";
String from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_index i ";
where = " AND ct.relnamespace = n.oid "
+ " AND " + resolveSchemaCondition(
"n.nspname", schema);
String sql = "SELECT a.attname, a.atttypid as atttypid " + from
+ " WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid "
+ " AND a.attrelid=ci.oid AND i.indisprimary "
+ " AND ct.relname = '" + escapeQuotes(table) + "' " + where
+ " ORDER BY a.attnum ";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
while(rs.next())
{
Object[] tuple = new Object[8];
Oid columnTypeOid = (Oid)rs.getObject("atttypid");
tuple[0] = new Short((short)scope);
tuple[1] = rs.getString("attname");
tuple[2] = new Short((short)m_connection.getSQLType(columnTypeOid));
tuple[3] = m_connection.getPGType(columnTypeOid);
tuple[4] = null;
tuple[5] = null;
tuple[6] = null;
tuple[7] = new Short((short)java.sql.DatabaseMetaData.bestRowNotPseudo);
v.add(tuple);
}
return createSyntheticResultSet(f, v);
}
/*
* Get a description of a table's columns that are automatically updated
* when any value in a row is updated. They are unordered. Each column
* description has the following columns:
- SCOPE short =>
* is not used
- COLUMN_NAME String => column name
- DATA_TYPE
* short => SQL data type from java.sql.Types
- TYPE_NAME String =>
* Data source dependent type name
- COLUMN_SIZE int => precision
*
- BUFFER_LENGTH int => length of column value in bytes
- DECIMAL_DIGITS
* short => scale
- PSEUDO_COLUMN short => is this a pseudo
* column like an Oracle ROWID
- versionColumnUnknown - may or may
* not be pseudo column
- versionColumnNotPseudo - is NOT a pseudo column
*
- versionColumnPseudo - is a pseudo column
@param catalog
* a catalog name; "" retrieves those without a catalog @param schema a
* schema name; "" retrieves those without a schema @param table a table
* name @return ResultSet each row is a column description
*/
public java.sql.ResultSet getVersionColumns(String catalog, String schema,
String table) throws SQLException
{
ResultSetField f[] = new ResultSetField[8];
ArrayList v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new ResultSetField("SCOPE", TypeOid.INT2, 2);
f[1] = new ResultSetField("COLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("DATA_TYPE", TypeOid.INT2, 2);
f[3] = new ResultSetField("TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("COLUMN_SIZE", TypeOid.INT4, 4);
f[5] = new ResultSetField("BUFFER_LENGTH", TypeOid.INT4, 4);
f[6] = new ResultSetField("DECIMAL_DIGITS", TypeOid.INT2, 2);
f[7] = new ResultSetField("PSEUDO_COLUMN", TypeOid.INT2, 2);
Object[] tuple = new Object[8];
/*
* Postgresql does not have any column types that are automatically
* updated like some databases' timestamp type. We can't tell what rules
* or triggers might be doing, so we are left with the system columns
* that change on an update. An update may change all of the following
* system columns: ctid, xmax, xmin, cmax, and cmin. Depending on if we
* are in a transaction and wether we roll it back or not the only
* guaranteed change is to ctid. -KJ
*/
tuple[0] = null;
tuple[1] = "ctid";
tuple[2] = new Short((short)m_connection.getSQLType("tid"));
tuple[3] = "tid";
tuple[4] = null;
tuple[5] = null;
tuple[6] = null;
tuple[7] = new Short((short)java.sql.DatabaseMetaData.versionColumnPseudo);
v.add(tuple);
/*
* Perhaps we should check that the given catalog.schema.table actually
* exists. -KJ
*/
return createSyntheticResultSet(f, v);
}
/*
* Get a description of a table's primary key columns. They are ordered by
* COLUMN_NAME. Each column description has the following columns:
* - TABLE_CAT String => table catalog (may be null)
- TABLE_SCHEM
* String => table schema (may be null)
- TABLE_NAME String =>
* table name
- COLUMN_NAME String => column name
- KEY_SEQ
* short => sequence number within primary key
- PK_NAME String =>
* primary key name (may be null)
@param catalog a catalog name; ""
* retrieves those without a catalog @param schema a schema name pattern; ""
* retrieves those without a schema @param table a table name @return
* ResultSet each row is a primary key column description
*/
public java.sql.ResultSet getPrimaryKeys(String catalog, String schema,
String table) throws SQLException
{
String from;
String where = "";
String select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, ";
from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_index i ";
where = " AND ct.relnamespace = n.oid AND " +
resolveSchemaCondition("n.nspname", schema);
String sql = select + " ct.relname AS TABLE_NAME, "
+ " a.attname AS COLUMN_NAME, " + " a.attnum::int2 AS KEY_SEQ, "
+ " ci.relname AS PK_NAME " + from
+ " WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid "
+ " AND a.attrelid=ci.oid AND i.indisprimary ";
if(table != null && !"".equals(table))
{
sql += " AND ct.relname = '" + escapeQuotes(table) + "' ";
}
sql += where + " ORDER BY table_name, pk_name, key_seq";
return createMetaDataStatement().executeQuery(sql);
}
/**
* @param primaryCatalog
* @param primarySchema
* @param primaryTable if provided will get the keys exported by this table
* @param foreignTable if provided will get the keys imported by this table
* @return ResultSet
* @throws SQLException
*/
protected java.sql.ResultSet getImportedExportedKeys(String primaryCatalog,
String primarySchema, String primaryTable, String foreignCatalog,
String foreignSchema, String foreignTable) throws SQLException
{
ResultSetField f[] = new ResultSetField[14];
f[0] = new ResultSetField("PKTABLE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("PKTABLE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[2] = new ResultSetField("PKTABLE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[3] = new ResultSetField("PKCOLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("FKTABLE_CAT", TypeOid.VARCHAR,
getMaxNameLength());
f[5] = new ResultSetField("FKTABLE_SCHEM", TypeOid.VARCHAR,
getMaxNameLength());
f[6] = new ResultSetField("FKTABLE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[7] = new ResultSetField("FKCOLUMN_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[8] = new ResultSetField("KEY_SEQ", TypeOid.INT2, 2);
f[9] = new ResultSetField("UPDATE_RULE", TypeOid.INT2, 2);
f[10] = new ResultSetField("DELETE_RULE", TypeOid.INT2, 2);
f[11] = new ResultSetField("FK_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[12] = new ResultSetField("PK_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[13] = new ResultSetField("DEFERRABILITY", TypeOid.INT2, 2);
/*
* The addition of the pg_constraint in 7.3 table should have really
* helped us out here, but it comes up just a bit short. - The conkey,
* confkey columns aren't really useful without contrib/array unless we
* want to issues separate queries. - Unique indexes that can support
* foreign keys are not necessarily added to pg_constraint. Also
* multiple unique indexes covering the same keys can be created which
* make it difficult to determine the PK_NAME field.
*/
String sql = "SELECT NULL::text AS PKTABLE_CAT, pkn.nspname AS PKTABLE_SCHEM, pkc.relname AS PKTABLE_NAME, pka.attname AS PKCOLUMN_NAME, "
+ "NULL::text AS FKTABLE_CAT, fkn.nspname AS FKTABLE_SCHEM, fkc.relname AS FKTABLE_NAME, fka.attname AS FKCOLUMN_NAME, "
+ "pos.n::int2 AS KEY_SEQ, "
+ "CASE con.confupdtype "
+ " WHEN 'c' THEN "
+ DatabaseMetaData.importedKeyCascade
+ " WHEN 'n' THEN "
+ DatabaseMetaData.importedKeySetNull
+ " WHEN 'd' THEN "
+ DatabaseMetaData.importedKeySetDefault
+ " WHEN 'r' THEN "
+ DatabaseMetaData.importedKeyRestrict
+ " WHEN 'a' THEN "
+ DatabaseMetaData.importedKeyNoAction
+ " ELSE NULL END::int2 AS UPDATE_RULE, "
+ "CASE con.confdeltype "
+ " WHEN 'c' THEN "
+ DatabaseMetaData.importedKeyCascade
+ " WHEN 'n' THEN "
+ DatabaseMetaData.importedKeySetNull
+ " WHEN 'd' THEN "
+ DatabaseMetaData.importedKeySetDefault
+ " WHEN 'r' THEN "
+ DatabaseMetaData.importedKeyRestrict
+ " WHEN 'a' THEN "
+ DatabaseMetaData.importedKeyNoAction
+ " ELSE NULL END::int2 AS DELETE_RULE, "
+ "con.conname AS FK_NAME, pkic.relname AS PK_NAME, "
+ "CASE "
+ " WHEN con.condeferrable AND con.condeferred THEN "
+ DatabaseMetaData.importedKeyInitiallyDeferred
+ " WHEN con.condeferrable THEN "
+ DatabaseMetaData.importedKeyInitiallyImmediate
+ " ELSE "
+ DatabaseMetaData.importedKeyNotDeferrable
+ " END::int2 AS DEFERRABILITY "
+ " FROM "
+ " pg_catalog.pg_namespace pkn, pg_catalog.pg_class pkc, pg_catalog.pg_attribute pka, "
+ " pg_catalog.pg_namespace fkn, pg_catalog.pg_class fkc, pg_catalog.pg_attribute fka, "
+ " pg_catalog.pg_constraint con, "
+ " pg_catalog.generate_series(1, " + getMaxIndexKeys() + ") pos(n), "
+ " pg_catalog.pg_depend dep, pg_catalog.pg_class pkic "
+ " WHERE pkn.oid = pkc.relnamespace AND pkc.oid = pka.attrelid AND pka.attnum = con.confkey[pos.n] AND con.confrelid = pkc.oid "
+ " AND fkn.oid = fkc.relnamespace AND fkc.oid = fka.attrelid AND fka.attnum = con.conkey[pos.n] AND con.conrelid = fkc.oid "
+ " AND con.contype = 'f' AND con.oid = dep.objid AND pkic.oid = dep.refobjid AND pkic.relkind = 'i' AND dep.classid = 'pg_constraint'::regclass::oid AND dep.refclassid = 'pg_class'::regclass::oid " +
" AND " + resolveSchemaCondition("pkn.nspname", primarySchema) +
" AND " + resolveSchemaCondition("fkn.nspname", foreignSchema);
if(primaryTable != null && !"".equals(primaryTable))
{
sql += " AND pkc.relname = '" + escapeQuotes(primaryTable)
+ "' ";
}
if(foreignTable != null && !"".equals(foreignTable))
{
sql += " AND fkc.relname = '" + escapeQuotes(foreignTable)
+ "' ";
}
if(primaryTable != null)
{
sql += " ORDER BY fkn.nspname,fkc.relname,pos.n";
}
else
{
sql += " ORDER BY pkn.nspname,pkc.relname,pos.n";
}
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get a description of the primary key columns that are referenced by a
* table's foreign key columns (the primary keys imported by a table). They
* are ordered by PKTABLE_CAT, PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. Each
* primary key column description has the following columns:
- PKTABLE_CAT
* String => primary key table catalog being imported (may be null)
- PKTABLE_SCHEM
* String => primary key table schema being imported (may be null)
- PKTABLE_NAME
* String => primary key table name being imported
- PKCOLUMN_NAME
* String => primary key column name being imported
- FKTABLE_CAT
* String => foreign key table catalog (may be null)
- FKTABLE_SCHEM
* String => foreign key table schema (may be null)
- FKTABLE_NAME
* String => foreign key table name
- FKCOLUMN_NAME String =>
* foreign key column name
- KEY_SEQ short => sequence number
* within foreign key
- UPDATE_RULE short => What happens to
* foreign key when primary is updated:
- importedKeyCascade -
* change imported key to agree with primary key update
-
* importedKeyRestrict - do not allow update of primary key if it has been
* imported
- importedKeySetNull - change imported key to NULL if its
* primary key has been updated
- DELETE_RULE short => What
* happens to the foreign key when primary is deleted.
-
* importedKeyCascade - delete rows that import a deleted key
-
* importedKeyRestrict - do not allow delete of primary key if it has been
* imported
- importedKeySetNull - change imported key to NULL if its
* primary key has been deleted
- FK_NAME String => foreign
* key name (may be null)
- PK_NAME String => primary key name
* (may be null)
@param catalog a catalog name; "" retrieves those
* without a catalog @param schema a schema name pattern; "" retrieves those
* without a schema @param table a table name @return ResultSet each row is
* a primary key column description
*
* @see #getExportedKeys
*/
public java.sql.ResultSet getImportedKeys(String catalog, String schema,
String table) throws SQLException
{
return getImportedExportedKeys(null, null, null, catalog, schema, table);
}
/*
* Get a description of a foreign key columns that reference a table's
* primary key columns (the foreign keys exported by a table). They are
* ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and KEY_SEQ. This
* method is currently unimplemented. Each foreign key column
* description has the following columns:
- PKTABLE_CAT
* String => primary key table catalog (may be null)
- PKTABLE_SCHEM
* String => primary key table schema (may be null)
- PKTABLE_NAME
* String => primary key table name
- PKCOLUMN_NAME String =>
* primary key column name
- FKTABLE_CAT String => foreign key
* table catalog (may be null) being exported (may be null)
- FKTABLE_SCHEM
* String => foreign key table schema (may be null) being exported (may be
* null)
- FKTABLE_NAME String => foreign key table name being
* exported
- FKCOLUMN_NAME String => foreign key column name
* being exported
- KEY_SEQ short => sequence number within
* foreign key
- UPDATE_RULE short => What happens to foreign key
* when primary is updated:
- importedKeyCascade - change imported
* key to agree with primary key update
- importedKeyRestrict - do not
* allow update of primary key if it has been imported
-
* importedKeySetNull - change imported key to NULL if its primary key has
* been updated
- DELETE_RULE short => What happens to the
* foreign key when primary is deleted.
- importedKeyCascade -
* delete rows that import a deleted key
- importedKeyRestrict - do not
* allow delete of primary key if it has been imported
-
* importedKeySetNull - change imported key to NULL if its primary key has
* been deleted
- FK_NAME String => foreign key identifier
* (may be null)
- PK_NAME String => primary key identifier (may
* be null)
@param catalog a catalog name; "" retrieves those without
* a catalog @param schema a schema name pattern; "" retrieves those without
* a schema @param table a table name @return ResultSet each row is a
* foreign key column description
*
* @see #getImportedKeys
*/
public java.sql.ResultSet getExportedKeys(String catalog, String schema,
String table) throws SQLException
{
return getImportedExportedKeys(catalog, schema, table, null, null, null);
}
/*
* Get a description of the foreign key columns in the foreign key table
* that reference the primary key columns of the primary key table (describe
* how one table imports another's key.) This should normally return a
* single foreign key/primary key pair (most tables only import a foreign
* key from a table once.) They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
* FKTABLE_NAME, and KEY_SEQ. This method is currently unimplemented. Each
* foreign key column description has the following columns:
- PKTABLE_CAT
* String => primary key table catalog (may be null)
- PKTABLE_SCHEM
* String => primary key table schema (may be null)
- PKTABLE_NAME
* String => primary key table name
- PKCOLUMN_NAME String =>
* primary key column name
- FKTABLE_CAT String => foreign key
* table catalog (may be null) being exported (may be null)
- FKTABLE_SCHEM
* String => foreign key table schema (may be null) being exported (may be
* null)
- FKTABLE_NAME String => foreign key table name being
* exported
- FKCOLUMN_NAME String => foreign key column name
* being exported
- KEY_SEQ short => sequence number within
* foreign key
- UPDATE_RULE short => What happens to foreign key
* when primary is updated:
- importedKeyCascade - change imported
* key to agree with primary key update
- importedKeyRestrict - do not
* allow update of primary key if it has been imported
-
* importedKeySetNull - change imported key to NULL if its primary key has
* been updated
- DELETE_RULE short => What happens to the
* foreign key when primary is deleted.
- importedKeyCascade -
* delete rows that import a deleted key
- importedKeyRestrict - do not
* allow delete of primary key if it has been imported
-
* importedKeySetNull - change imported key to NULL if its primary key has
* been deleted
- FK_NAME String => foreign key identifier
* (may be null)
- PK_NAME String => primary key identifier (may
* be null)
@param catalog a catalog name; "" retrieves those without
* a catalog @param schema a schema name pattern; "" retrieves those without
* a schema @param table a table name @return ResultSet each row is a
* foreign key column description
*
* @see #getImportedKeys
*/
public java.sql.ResultSet getCrossReference(String primaryCatalog,
String primarySchema, String primaryTable, String foreignCatalog,
String foreignSchema, String foreignTable) throws SQLException
{
return getImportedExportedKeys(primaryCatalog, primarySchema,
primaryTable, foreignCatalog, foreignSchema, foreignTable);
}
/*
* Get a description of all the standard SQL types supported by this
* database. They are ordered by DATA_TYPE and then by how closely the data
* type maps to the corresponding JDBC SQL type. Each type description
* has the following columns:
- TYPE_NAME String => Type
* name
- DATA_TYPE short => SQL data type from java.sql.Types
*
- PRECISION int => maximum precision
- LITERAL_PREFIX
* String => prefix used to quote a literal (may be null)
- LITERAL_SUFFIX
* String => suffix used to quote a literal (may be null)
- CREATE_PARAMS
* String => parameters used in creating the type (may be null)
- NULLABLE
* short => can you use NULL for this type?
- typeNoNulls - does not
* allow NULL values
- typeNullable - allows NULL values
-
* typeNullableUnknown - nullability unknown
- CASE_SENSITIVE
* boolean=> is it case sensitive?
- SEARCHABLE short => can you
* use "WHERE" based on this type:
- typePredNone - No support
-
* typePredChar - Only supported with WHERE .. LIKE
- typePredBasic -
* Supported except for WHERE .. LIKE
- typeSearchable - Supported for
* all WHERE ..
- UNSIGNED_ATTRIBUTE boolean => is it
* unsigned?
- FIXED_PREC_SCALE boolean => can it be a money
* value?
- AUTO_INCREMENT boolean => can it be used for an
* auto-increment value?
- LOCAL_TYPE_NAME String => localized
* version of type name (may be null)
- MINIMUM_SCALE short =>
* minimum scale supported
- MAXIMUM_SCALE short => maximum scale
* supported
- SQL_DATA_TYPE int => unused
- SQL_DATETIME_SUB
* int => unused
- NUM_PREC_RADIX int => usually 2 or 10
* @return ResultSet each row is a SQL type description
*/
public java.sql.ResultSet getTypeInfo() throws SQLException
{
ResultSetField f[] = new ResultSetField[18];
ArrayList v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new ResultSetField("TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[1] = new ResultSetField("DATA_TYPE", TypeOid.INT2, 2);
f[2] = new ResultSetField("PRECISION", TypeOid.INT4, 4);
f[3] = new ResultSetField("LITERAL_PREFIX", TypeOid.VARCHAR,
getMaxNameLength());
f[4] = new ResultSetField("LITERAL_SUFFIX", TypeOid.VARCHAR,
getMaxNameLength());
f[5] = new ResultSetField("CREATE_PARAMS", TypeOid.VARCHAR,
getMaxNameLength());
f[6] = new ResultSetField("NULLABLE", TypeOid.INT2, 2);
f[7] = new ResultSetField("CASE_SENSITIVE", TypeOid.BOOL, 1);
f[8] = new ResultSetField("SEARCHABLE", TypeOid.INT2, 2);
f[9] = new ResultSetField("UNSIGNED_ATTRIBUTE", TypeOid.BOOL, 1);
f[10] = new ResultSetField("FIXED_PREC_SCALE", TypeOid.BOOL, 1);
f[11] = new ResultSetField("AUTO_INCREMENT", TypeOid.BOOL, 1);
f[12] = new ResultSetField("LOCAL_TYPE_NAME", TypeOid.VARCHAR,
getMaxNameLength());
f[13] = new ResultSetField("MINIMUM_SCALE", TypeOid.INT2, 2);
f[14] = new ResultSetField("MAXIMUM_SCALE", TypeOid.INT2, 2);
f[15] = new ResultSetField("SQL_DATA_TYPE", TypeOid.INT4, 4);
f[16] = new ResultSetField("SQL_DATETIME_SUB", TypeOid.INT4, 4);
f[17] = new ResultSetField("NUM_PREC_RADIX", TypeOid.INT4, 4);
String sql = "SELECT typname FROM pg_catalog.pg_type where typrelid = 0";
ResultSet rs = m_connection.createStatement().executeQuery(sql);
// cache some results, this will keep memory useage down, and speed
// things up a little.
Integer i9 = new Integer(9);
Integer i10 = new Integer(10);
Short nn = new Short((short)java.sql.DatabaseMetaData.typeNoNulls);
Short ts = new Short((short)java.sql.DatabaseMetaData.typeSearchable);
String typname = null;
while(rs.next())
{
Object[] tuple = new Object[18];
typname = rs.getString(1);
tuple[0] = typname;
tuple[1] = new Short((short)m_connection.getSQLType(typname));
tuple[2] = i9; // for now
tuple[6] = nn; // for now
tuple[7] = Boolean.FALSE; // false for now - not case sensitive
tuple[8] = ts;
tuple[9] = Boolean.FALSE; // false for now - it's signed
tuple[10] = Boolean.FALSE; // false for now - must handle money
tuple[11] = Boolean.FALSE; // false - it isn't autoincrement
// 12 - LOCAL_TYPE_NAME is null
// 13 & 14 ?
// 15 & 16 are unused so we return null
tuple[17] = i10; // everything is base 10
v.add(tuple);
// add pseudo-type serial, bigserial
if(typname.equals("int4"))
{
Object[] tuple1 = (Object[])tuple.clone();
tuple1[0] = "serial";
tuple1[11] = Boolean.TRUE;
v.add(tuple1);
}
else if(typname.equals("int8"))
{
Object[] tuple1 = (Object[])tuple.clone();
tuple1[0] = "bigserial";
tuple1[11] = Boolean.TRUE;
v.add(tuple1);
}
}
rs.close();
return createSyntheticResultSet(f, v);
}
/*
* Get a description of a table's indices and statistics. They are ordered
* by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. Each index
* column description has the following columns:
- TABLE_CAT
* String => table catalog (may be null)
- TABLE_SCHEM String =>
* table schema (may be null)
- TABLE_NAME String => table name
*
- NON_UNIQUE boolean => Can index values be non-unique? false
* when TYPE is tableIndexStatistic
- INDEX_QUALIFIER String =>
* index catalog (may be null); null when TYPE is tableIndexStatistic
- INDEX_NAME
* String => index name; null when TYPE is tableIndexStatistic
- TYPE
* short => index type:
- tableIndexStatistic - this identifies
* table statistics that are returned in conjuction with a table's index
* descriptions
- tableIndexClustered - this is a clustered index
-
* tableIndexHashed - this is a hashed index
- tableIndexOther - this is
* some other style of index
- ORDINAL_POSITION short =>
* column sequence number within index; zero when TYPE is
* tableIndexStatistic
- COLUMN_NAME String => column name; null
* when TYPE is tableIndexStatistic
- ASC_OR_DESC String =>
* column sort sequence, "A" => ascending "D" => descending, may be null if
* sort sequence is not supported; null when TYPE is tableIndexStatistic
*
- CARDINALITY int => When TYPE is tableIndexStatisic then this
* is the number of rows in the table; otherwise it is the number of unique
* values in the index.
- PAGES int => When TYPE is
* tableIndexStatisic then this is the number of pages used for the table,
* otherwise it is the number of pages used for the current index.
- FILTER_CONDITION
* String => Filter condition, if any. (may be null)
@param catalog a
* catalog name; "" retrieves those without a catalog @param schema a schema
* name pattern; "" retrieves those without a schema @param table a table
* name @param unique when true, return only indices for unique values; when
* false, return indices regardless of whether unique or not @param
* approximate when true, result is allowed to reflect approximate or out of
* data values; when false, results are requested to be accurate @return
* ResultSet each row is an index column description
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getIndexInfo(String catalog, String schema,
String tableName, boolean unique, boolean approximate)
throws SQLException
{
String select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, ";
String from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_index i, pg_catalog.pg_attribute a, pg_catalog.pg_am am ";
String where =
" AND n.oid = ct.relnamespace " +
" AND " + resolveSchemaCondition("n.nspname", schema);
String sql = select
+ " ct.relname AS TABLE_NAME, NOT i.indisunique AS NON_UNIQUE, NULL AS INDEX_QUALIFIER, ci.relname AS INDEX_NAME, "
+ " CASE i.indisclustered "
+ " WHEN true THEN "
+ java.sql.DatabaseMetaData.tableIndexClustered
+ " ELSE CASE am.amname "
+ " WHEN 'hash' THEN "
+ java.sql.DatabaseMetaData.tableIndexHashed
+ " ELSE "
+ java.sql.DatabaseMetaData.tableIndexOther
+ " END "
+ " END::int2 AS TYPE, "
+ " a.attnum::int2 AS ORDINAL_POSITION, "
+ " a.attname AS COLUMN_NAME, "
+ " NULL AS ASC_OR_DESC, "
+ " ci.reltuples AS CARDINALITY, "
+ " ci.relpages AS PAGES, "
+ " NULL AS FILTER_CONDITION "
+ from
+ " WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid AND a.attrelid=ci.oid AND ci.relam=am.oid "
+ where + " AND ct.relname = '" + escapeQuotes(tableName) + "' ";
if(unique)
{
sql += " AND i.indisunique ";
}
sql += " ORDER BY NON_UNIQUE, TYPE, INDEX_NAME, ORDINAL_POSITION ";
return createMetaDataStatement().executeQuery(sql);
}
// ** JDBC 2 Extensions **
/*
* Does the database support the given result set type? @param type -
* defined in java.sql.ResultSet @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsResultSetType(int type) throws SQLException
{
// The only type we support
return type == java.sql.ResultSet.TYPE_FORWARD_ONLY;
}
/*
* Does the database support the concurrency type in combination with the
* given result set type? @param type - defined in java.sql.ResultSet @param
* concurrency - type defined in java.sql.ResultSet @return true if so;
* false otherwise @exception SQLException - if a database access error
* occurs
*/
public boolean supportsResultSetConcurrency(int type, int concurrency)
throws SQLException
{
// These combinations are not supported!
if(type != java.sql.ResultSet.TYPE_FORWARD_ONLY)
return false;
// We support only Concur Read Only
if(concurrency != java.sql.ResultSet.CONCUR_READ_ONLY)
return false;
// Everything else we do
return true;
}
/* lots of unsupported stuff... */
public boolean ownUpdatesAreVisible(int type) throws SQLException
{
return true;
}
public boolean ownDeletesAreVisible(int type) throws SQLException
{
return true;
}
public boolean ownInsertsAreVisible(int type) throws SQLException
{
// indicates that
return true;
}
public boolean othersUpdatesAreVisible(int type) throws SQLException
{
return false;
}
public boolean othersDeletesAreVisible(int i) throws SQLException
{
return false;
}
public boolean othersInsertsAreVisible(int type) throws SQLException
{
return false;
}
public boolean updatesAreDetected(int type) throws SQLException
{
return false;
}
public boolean deletesAreDetected(int i) throws SQLException
{
return false;
}
public boolean insertsAreDetected(int type) throws SQLException
{
return false;
}
/*
* Indicates whether the driver supports batch updates.
*/
public boolean supportsBatchUpdates() throws SQLException
{
return true;
}
/**
* @param catalog String
* @param schemaPattern String
* @param typeNamePattern String
* @param types int[]
* @throws SQLException
* @return ResultSet
*/
public java.sql.ResultSet getUDTs(String catalog, String schemaPattern,
String typeNamePattern, int[] types) throws SQLException
{
String sql = "select "
+ "null as type_cat, n.nspname as type_schem, t.typname as type_name, null as class_name, "
+ "CASE WHEN t.typtype='c' then "
+ java.sql.Types.STRUCT
+ " else "
+ java.sql.Types.DISTINCT
+ " end as data_type, pg_catalog.obj_description(t.oid, 'pg_type') "
+ "as remarks, CASE WHEN t.typtype = 'd' then (select CASE";
for(int i = 0; i < SPIConnection.JDBC3_TYPE_NAMES.length; i++)
{
sql += " when typname = '" + SPIConnection.JDBC_TYPE_NUMBERS[i]
+ "' then " + SPIConnection.JDBC_TYPE_NUMBERS[i];
}
sql += " else "
+ java.sql.Types.OTHER
+ " end from pg_type where oid=t.typbasetype) "
+ "else null end as base_type "
+ "from pg_catalog.pg_type t, pg_catalog.pg_namespace n where t.typnamespace = n.oid and n.nspname != 'pg_catalog' and n.nspname != 'pg_toast'";
String toAdd = "";
if(types != null)
{
toAdd += " and (false ";
for(int i = 0; i < types.length; i++)
{
switch(types[i])
{
case java.sql.Types.STRUCT:
toAdd += " or t.typtype = 'c'";
break;
case java.sql.Types.DISTINCT:
toAdd += " or t.typtype = 'd'";
break;
}
}
toAdd += " ) ";
}
else
{
toAdd += " and t.typtype IN ('c','d') ";
}
// spec says that if typeNamePattern is a fully qualified name
// then the schema and catalog are ignored
if(typeNamePattern != null)
{
// search for qualifier
int firstQualifier = typeNamePattern.indexOf('.');
int secondQualifier = typeNamePattern.lastIndexOf('.');
if(firstQualifier != -1) // if one of them is -1 they both will
// be
{
if(firstQualifier != secondQualifier)
{
// we have a catalog.schema.typename, ignore catalog
schemaPattern = typeNamePattern.substring(
firstQualifier + 1, secondQualifier);
}
else
{
// we just have a schema.typename
schemaPattern = typeNamePattern
.substring(0, firstQualifier);
}
// strip out just the typeName
typeNamePattern = typeNamePattern
.substring(secondQualifier + 1);
}
toAdd += " and t.typname like '" + escapeQuotes(typeNamePattern)
+ "'";
}
// schemaPattern may have been modified above
if(schemaPattern != null)
{
toAdd += " and n.nspname like '" + escapeQuotes(schemaPattern)
+ "'";
}
sql += toAdd;
sql += " order by data_type, type_schem, type_name";
java.sql.ResultSet rs = createMetaDataStatement().executeQuery(sql);
return rs;
}
/*
* Retrieves the connection that produced this metadata object. @return the
* connection that produced this metadata object
*/
public Connection getConnection() throws SQLException
{
return m_connection;
}
/* I don't find these in the spec!?! */
public boolean rowChangesAreDetected(int type) throws SQLException
{
return false;
}
public boolean rowChangesAreVisible(int type) throws SQLException
{
return false;
}
private Statement createMetaDataStatement() throws SQLException
{
return m_connection.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
}
/**
* Retrieves whether this database supports savepoints.
*
* @return true if savepoints are supported;
* false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsSavepoints() throws SQLException
{
return this.getDatabaseMajorVersion() >= 8;
}
/**
* Retrieves whether this database supports named parameters to callable
* statements.
*
* @return true if named parameters are supported;
* false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsNamedParameters() throws SQLException
{
return false;
}
/**
* Retrieves whether it is possible to have multiple ResultSet
* objects returned from a CallableStatement object
* simultaneously.
*
* @return true if a CallableStatement object
* can return multiple ResultSet objects
* simultaneously; false otherwise
* @exception SQLException if a datanase access error occurs
* @since 1.4
*/
public boolean supportsMultipleOpenResults() throws SQLException
{
return false;
}
/**
* Retrieves whether auto-generated keys can be retrieved after a statement
* has been executed.
*
* @return true if auto-generated keys can be retrieved after
* a statement has executed; false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsGetGeneratedKeys() throws SQLException
{
return false;
}
/**
* Retrieves a description of the user-defined type (UDT) hierarchies
* defined in a particular schema in this database. Only the immediate super
* type/ sub type relationship is modeled.
*
* Only supertype information for UDTs matching the catalog, schema, and
* type name is returned. The type name parameter may be a fully-qualified
* name. When the UDT name supplied is a fully-qualified name, the catalog
* and schemaPattern parameters are ignored.
*
* If a UDT does not have a direct super type, it is not listed here. A row
* of the ResultSet object returned by this method describes
* the designated UDT and a direct supertype. A row has the following
* columns:
*
* - TYPE_CAT String => the UDT's catalog (may be
*
null)
* - TYPE_SCHEM String => UDT's schema (may be
null)
* - TYPE_NAME String => type name of the UDT
*
- SUPERTYPE_CAT String => the direct super type's catalog (may
* be
null)
* - SUPERTYPE_SCHEM String => the direct super type's schema
* (may be
null)
* - SUPERTYPE_NAME String => the direct super type's name
*
*
* Note: If the driver does not support type hierarchies, an empty
* result set is returned.
*
* @param catalog a catalog name; "" retrieves those without a catalog;
* null means drop catalog name from the selection
* criteria
* @param schemaPattern a schema name pattern; "" retrieves those without a
* schema
* @param typeNamePattern a UDT name pattern; may be a fully-qualified name
* @return a ResultSet object in which a row gives
* information about the designated UDT
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getSuperTypes(String catalog, String schemaPattern,
String typeNamePattern) throws SQLException
{
throw new UnsupportedFeatureException("DatabaseMetaData.getSuperTypes");
}
/**
* Retrieves a description of the table hierarchies defined in a particular
* schema in this database.
*
* Only supertable information for tables matching the catalog, schema and
* table name are returned. The table name parameter may be a fully-
* qualified name, in which case, the catalog and schemaPattern parameters
* are ignored. If a table does not have a super table, it is not listed
* here. Supertables have to be defined in the same catalog and schema as
* the sub tables. Therefore, the type description does not need to include
* this information for the supertable.
*
* Each type description has the following columns:
*
* - TABLE_CAT String => the type's catalog (may be
*
null)
* - TABLE_SCHEM String => type's schema (may be
*
null)
* - TABLE_NAME String => type name
*
- SUPERTABLE_NAME String => the direct super type's name
*
*
* Note: If the driver does not support type hierarchies, an empty
* result set is returned.
*
* @param catalog a catalog name; "" retrieves those without a catalog;
* null means drop catalog name from the selection
* criteria
* @param schemaPattern a schema name pattern; "" retrieves those without a
* schema
* @param tableNamePattern a table name pattern; may be a fully-qualified
* name
* @return a ResultSet object in which each row is a type
* description
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getSuperTables(String catalog, String schemaPattern,
String tableNamePattern) throws SQLException
{
throw new UnsupportedFeatureException("DatabaseMetaData.getSuperTables");
}
/**
* Retrieves a description of the given attribute of the given type for a
* user-defined type (UDT) that is available in the given schema and
* catalog.
*
* Descriptions are returned only for attributes of UDTs matching the
* catalog, schema, type, and attribute name criteria. They are ordered by
* TYPE_SCHEM, TYPE_NAME and ORDINAL_POSITION. This description does not
* contain inherited attributes.
*
* The ResultSet object that is returned has the following
* columns:
*
* - TYPE_CAT String => type catalog (may be
null)
* - TYPE_SCHEM String => type schema (may be
null)
* - TYPE_NAME String => type name
*
- ATTR_NAME String => attribute name
*
- DATA_TYPE short => attribute type SQL type from
* java.sql.Types
*
- ATTR_TYPE_NAME String => Data source dependent type name.
* For a UDT, the type name is fully qualified. For a REF, the type name is
* fully qualified and represents the target type of the reference type.
*
- ATTR_SIZE int => column size. For char or date types this is
* the maximum number of characters; for numeric or decimal types this is
* precision.
*
- DECIMAL_DIGITS int => the number of fractional digits
*
- NUM_PREC_RADIX int => Radix (typically either 10 or 2)
*
- NULLABLE int => whether NULL is allowed
*
* - attributeNoNulls - might not allow NULL values
*
- attributeNullable - definitely allows NULL values
*
- attributeNullableUnknown - nullability unknown
*
* - REMARKS String => comment describing column (may be
*
null)
* - ATTR_DEF String => default value (may be
null)
* - SQL_DATA_TYPE int => unused
*
- SQL_DATETIME_SUB int => unused
*
- CHAR_OCTET_LENGTH int => for char types the maximum number
* of bytes in the column
*
- ORDINAL_POSITION int => index of column in table (starting
* at 1)
*
- IS_NULLABLE String => "NO" means column definitely does not
* allow NULL values; "YES" means the column might allow NULL values. An
* empty string means unknown.
*
- SCOPE_CATALOG String => catalog of table that is the scope
* of a reference attribute (
null if DATA_TYPE isn't REF)
* - SCOPE_SCHEMA String => schema of table that is the scope of
* a reference attribute (
null if DATA_TYPE isn't REF)
* - SCOPE_TABLE String => table name that is the scope of a
* reference attribute (
null if the DATA_TYPE isn't REF)
* - SOURCE_DATA_TYPE short => source type of a distinct type or
* user-generated Ref type,SQL type from java.sql.Types (
null
* if DATA_TYPE isn't DISTINCT or user-generated REF)
*
*
* @param catalog a catalog name; must match the catalog name as it is
* stored in the database; "" retrieves those without a catalog;
* null means that the catalog name should not be
* used to narrow the search
* @param schemaPattern a schema name pattern; must match the schema name as
* it is stored in the database; "" retrieves those without a
* schema; null means that the schema name should
* not be used to narrow the search
* @param typeNamePattern a type name pattern; must match the type name as
* it is stored in the database
* @param attributeNamePattern an attribute name pattern; must match the
* attribute name as it is declared in the database
* @return a ResultSet object in which each row is an
* attribute description
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getAttributes(String catalog, String schemaPattern,
String typeNamePattern, String attributeNamePattern)
throws SQLException
{
throw new UnsupportedFeatureException("getAttributes");
}
/**
* Retrieves whether this database supports the given result set
* holdability.
*
* @param holdability one of the following constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
* @see Connection
* @since 1.4
*/
public boolean supportsResultSetHoldability(int holdability)
throws SQLException
{
return true;
}
/**
* Retrieves the default holdability of this ResultSet
* object.
*
* @return the default holdability; either
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getResultSetHoldability() throws SQLException
{
return ResultSet.HOLD_CURSORS_OVER_COMMIT;
}
/**
* Retrieves the major version number of the underlying database.
*
* @return the underlying database's major version
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getDatabaseMajorVersion() throws SQLException
{
return m_connection.getVersionNumber()[0];
}
/**
* Retrieves the minor version number of the underlying database.
*
* @return underlying database's minor version
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getDatabaseMinorVersion() throws SQLException
{
return m_connection.getVersionNumber()[1];
}
/**
* Retrieves the major JDBC version number for this driver.
*
* @return JDBC version major number
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getJDBCMajorVersion() throws SQLException
{
return 3; // This class implements JDBC 3.0
}
/**
* Retrieves the minor JDBC version number for this driver.
*
* @return JDBC version minor number
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getJDBCMinorVersion() throws SQLException
{
return 0; // This class implements JDBC 3.0
}
/**
* Indicates whether the SQLSTATEs returned by
* SQLException.getSQLState is X/Open (now known as Open
* Group) SQL CLI or SQL99.
*
* @return the type of SQLSTATEs, one of: sqlStateXOpen or sqlStateSQL99
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public int getSQLStateType() throws SQLException
{
return DatabaseMetaData.sqlStateSQL99;
}
/**
* Indicates whether updates made to a LOB are made on a copy or directly to
* the LOB.
*
* @return true if updates are made to a copy of the LOB;
* false if updates are made directly to the LOB
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public boolean locatorsUpdateCopy() throws SQLException
{
/*
* Currently LOB's aren't updateable at all, so it doesn't matter what
* we return. We don't throw the notImplemented Exception because the
* 1.5 JDK's CachedRowSet calls this method regardless of wether large
* objects are used.
*/
return true;
}
/**
* Retrieves weather this database supports statement pooling.
*
* @return true is so; false otherwise
* @throws SQLExcpetion if a database access error occurs
* @since 1.4
*/
public boolean supportsStatementPooling() throws SQLException
{
return false;
}
/**
* This method creates a ResultSet which is not associated with any
* statement.
*/
private ResultSet createSyntheticResultSet(ResultSetField[] f, ArrayList tuples)
throws SQLException
{
return new SyntheticResultSet(f, tuples);
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ResultSetField.java 0000664 0000767 0000770 00000004277 10630554503 027721 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import org.postgresql.pljava.internal.Oid;
/**
*
* @author Filip Hrbek
*/
public class ResultSetField
{
private final String m_name;
private final Oid m_oid;
private final int m_len;
private final int m_mod;
/*
* Construct a field based on the information fed to it.
*
* @param name the name (column name and label) of the field
* @param oid the OID of the field
* @param len the length of the field
*/
public ResultSetField(String name, Oid oid, int len, int mod)
throws SQLException
{
m_name = name.toUpperCase();
m_oid = oid;
m_len = len;
m_mod = mod;
}
/*
* Constructor without mod parameter.
*
* @param name the name (column name and label) of the field
* @param oid the OID of the field
* @param len the length of the field
*/
public ResultSetField(String name, Oid oid, int len)
throws SQLException
{
this(name, oid, len, 0);
}
/*
* @return the oid of this Field's data type
*/
public final Oid getOID()
{
return m_oid;
}
/*
* @return the Java class for oid of this Field's data type
*/
public final Class getJavaClass()
throws SQLException
{
return m_oid.getJavaClass();
}
/*
* @return true if the field can contain a value of specified class
*/
public final boolean canContain(Class cls)
throws SQLException
{
return this.getJavaClass().isAssignableFrom(cls);
}
/*
* @return the mod of this Field's data type
*/
public final int getMod()
{
return m_mod;
}
/*
* @return the column label of this Field's data type
*/
public final String getColumnLabel()
{
return m_name;
}
/*
* @return the length of this Field's data type
*/
public final int getLength()
{
return m_len;
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SingleRowReader.java 0000664 0000767 0000770 00000006711 10630554503 030052 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.postgresql.pljava.internal.Backend;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A single row, read-only ResultSet, specially made for functions and
* procedures that takes complex types as arguments (PostgreSQL 7.5
* and later).
*
* @author Thomas Hallgren
*/
public class SingleRowReader extends SingleRowResultSet
{
private final TupleDesc m_tupleDesc;
private final long m_pointer;
public SingleRowReader(long pointer, TupleDesc tupleDesc)
throws SQLException
{
m_pointer = pointer;
m_tupleDesc = tupleDesc;
}
public void close()
{
}
public void finalize()
{
synchronized(Backend.THREADLOCK)
{
_free(m_pointer);
}
}
protected Object getObjectValue(int columnIndex)
throws SQLException
{
synchronized(Backend.THREADLOCK)
{
return _getObject(m_pointer, m_tupleDesc.getNativePointer(), columnIndex);
}
}
/**
* Returns {@link ResultSet#CONCUR_READ_ONLY}.
*/
public int getConcurrency()
throws SQLException
{
return ResultSet.CONCUR_READ_ONLY;
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void cancelRowUpdates()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void deleteRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void insertRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void moveToInsertRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateRow()
throws SQLException
{
throw readOnlyException();
}
/**
* Always returns false.
*/
public boolean rowUpdated()
throws SQLException
{
return false;
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateObject(int columnIndex, Object x) throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateObject(int columnIndex, Object x, int scale)
throws SQLException
{
throw readOnlyException();
}
private static SQLException readOnlyException()
{
return new UnsupportedFeatureException("ResultSet is read-only");
}
protected final TupleDesc getTupleDesc()
{
return m_tupleDesc;
}
protected native void _free(long pointer);
private static native Object _getObject(long pointer, long tupleDescPointer, int index)
throws SQLException;
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/ReadOnlyResultSet.java 0000664 0000767 0000770 00000005762 10630554503 030413 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* The ReadOnlyResultSet implements all methods that changes the ResultSet
* in any way as methods that yield an {@link UnsupportedFeatureException}.
*
* @author Thomas Hallgren
*/
public abstract class ReadOnlyResultSet extends ObjectResultSet
{
/**
* Returns {@link ResultSet#CONCUR_READ_ONLY}.
*/
public int getConcurrency()
throws SQLException
{
return ResultSet.CONCUR_READ_ONLY;
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void cancelRowUpdates()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void deleteRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void insertRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This is a no-op since the moveToInsertRow() method is
* unsupported.
*/
public void moveToCurrentRow()
throws SQLException
{
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void moveToInsertRow()
throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateRow()
throws SQLException
{
throw readOnlyException();
}
/**
* Always returns false.
*/
public boolean rowDeleted()
throws SQLException
{
return false;
}
/**
* Always returns false.
*/
public boolean rowInserted()
throws SQLException
{
return false;
}
/**
* Always returns false.
*/
public boolean rowUpdated()
throws SQLException
{
return false;
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateObject(int columnIndex, Object x) throws SQLException
{
throw readOnlyException();
}
/**
* This feature is not supported on a ReadOnlyResultSet.
* @throws SQLException indicating that this feature is not supported.
*/
public void updateObject(int columnIndex, Object x, int scale)
throws SQLException
{
throw readOnlyException();
}
private static SQLException readOnlyException()
{
return new UnsupportedFeatureException("ResultSet is read-only");
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SQLOutputToChunk.java 0000664 0000767 0000770 00000014132 10630554503 030166 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.SQLData;
import java.sql.SQLException;
import java.sql.SQLOutput;
import java.sql.Struct;
import java.sql.Time;
import java.sql.Timestamp;
import org.postgresql.pljava.internal.Backend;
/**
* The SQLOutputToChunk uses JNI to build a PostgreSQL StringInfo buffer in
* memory. A user should never make an attempt to create an instance of this
* class. Only internal JNI routines can do that. An instance is propagated
* in a call from the internal JNI layer to the Java layer will only survive
* during that single call. The handle of the instance will be invalidated when
* the call returns and subsequent use of the instance will yield a
* SQLException with the message "Stream is closed".
*
* @author Thomas Hallgren
*/
public class SQLOutputToChunk implements SQLOutput
{
private static final byte[] s_byteBuffer = new byte[8];
private long m_handle;
public SQLOutputToChunk(long handle)
{
m_handle = handle;
}
public void writeArray(Array value) throws SQLException
{
throw new UnsupportedOperationException("writeArray");
}
public void writeAsciiStream(InputStream value) throws SQLException
{
throw new UnsupportedOperationException("writeAsciiStream");
}
public void writeBigDecimal(BigDecimal value) throws SQLException
{
this.writeString(value.toString());
}
public void writeBinaryStream(InputStream value) throws SQLException
{
byte[] buf = new byte[1024];
ByteArrayOutputStream bld = new ByteArrayOutputStream();
int count;
try
{
while((count = value.read(buf)) > 0)
bld.write(buf, 0, count);
this.writeBytes(bld.toByteArray());
}
catch(IOException e)
{
throw new SQLException(e.getMessage());
}
}
public void writeBlob(Blob value) throws SQLException
{
throw new UnsupportedOperationException("writeBlob");
}
public void writeBoolean(boolean value) throws SQLException
{
this.write(value ? 1 : 0);
}
public void writeByte(byte value) throws SQLException
{
this.write(value);
}
public void writeBytes(byte[] buffer) throws SQLException
{
int len = buffer.length;
if(len > 0)
{
if(len > 65535)
throw new SQLException("Byte buffer exceeds maximum size of 65535 bytes");
synchronized(Backend.THREADLOCK)
{
if(m_handle == 0)
throw new SQLException("Stream is closed");
s_byteBuffer[0] = (byte)((len >> 8) & 0xff);
s_byteBuffer[1] = (byte)(len & 0xff);
_writeBytes(m_handle, s_byteBuffer, 2);
_writeBytes(m_handle, buffer, len);
}
}
}
public void writeCharacterStream(Reader value) throws SQLException
{
char[] buf = new char[1024];
StringWriter bld = new StringWriter();
int count;
try
{
while((count = value.read(buf)) > 0)
bld.write(buf, 0, count);
this.writeString(bld.toString());
}
catch(IOException e)
{
throw new SQLException(e.getMessage());
}
}
public void writeClob(Clob value) throws SQLException
{
throw new UnsupportedOperationException("writeClob");
}
public void writeDate(Date value) throws SQLException
{
this.writeLong(value.getTime());
}
public void writeDouble(double value) throws SQLException
{
this.writeLong(Double.doubleToLongBits(value));
}
public void writeFloat(float value) throws SQLException
{
this.writeInt(Float.floatToIntBits(value));
}
public void writeInt(int value) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
s_byteBuffer[0] = (byte)(value >>> 24);
s_byteBuffer[1] = (byte)(value >>> 16);
s_byteBuffer[2] = (byte)(value >>> 8);
s_byteBuffer[3] = (byte)(value >>> 0);
_writeBytes(m_handle, s_byteBuffer, 4);
}
}
public void writeLong(long value) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
s_byteBuffer[0] = (byte)(value >>> 56);
s_byteBuffer[1] = (byte)(value >>> 48);
s_byteBuffer[2] = (byte)(value >>> 40);
s_byteBuffer[3] = (byte)(value >>> 32);
s_byteBuffer[4] = (byte)(value >>> 24);
s_byteBuffer[5] = (byte)(value >>> 16);
s_byteBuffer[6] = (byte)(value >>> 8);
s_byteBuffer[7] = (byte)(value >>> 0);
_writeBytes(m_handle, s_byteBuffer, 8);
}
}
public void writeObject(SQLData value) throws SQLException
{
throw new UnsupportedOperationException("writeObject");
}
public void writeRef(Ref value) throws SQLException
{
throw new UnsupportedOperationException("writeRef");
}
public void writeShort(short value) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
s_byteBuffer[0] = (byte)(value >>> 8);
s_byteBuffer[1] = (byte)(value >>> 0);
_writeBytes(m_handle, s_byteBuffer, 2);
}
}
public void writeString(String value) throws SQLException
{
try
{
this.writeBytes(value.getBytes("UTF8"));
}
catch(UnsupportedEncodingException e)
{
throw new SQLException("UTF8 encoding not supported by JVM");
}
}
public void writeStruct(Struct value) throws SQLException
{
throw new UnsupportedOperationException("writeStruct");
}
public void writeTime(Time value) throws SQLException
{
this.writeLong(value.getTime());
}
public void writeTimestamp(Timestamp value) throws SQLException
{
this.writeLong(value.getTime());
}
public void writeURL(URL value) throws SQLException
{
this.writeString(value.toString());
}
void close()
{
m_handle = 0;
}
private void write(int b) throws SQLException
{
synchronized(Backend.THREADLOCK)
{
if(m_handle == 0)
throw new SQLException("Stream is closed");
_writeByte(m_handle, b);
}
}
private static native void _writeByte(long handle, int theByte);
private static native void _writeBytes(long handle, byte[] src, int len);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIResultSetMetaData.java 0000664 0000767 0000770 00000007707 10630554503 030733 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.SQLException;
import org.postgresql.pljava.internal.Oid;
import org.postgresql.pljava.internal.TupleDesc;
/**
* Implementation of ResultSetMetaData for SPIResultSet
*
* @author Filip Hrbek
*/
public class SPIResultSetMetaData extends AbstractResultSetMetaData
{
private final TupleDesc m_tupleDesc;
/**
* Constructor.
* @param tupleDesc The descriptor for the ResultSet tuples
*/
public SPIResultSetMetaData(TupleDesc tupleDesc)
{
super();
m_tupleDesc = tupleDesc;
}
/**
* Returns the number of columns in this ResultSet object.
*
* @return the number of columns
* @exception SQLException if a database access error occurs
*/
public final int getColumnCount() throws SQLException
{
return m_tupleDesc.size();
}
/**
* Indicates whether the designated column is automatically numbered, thus read-only.
*
* @param column the first column is 1, the second is 2, ...
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
*/
public final boolean isAutoIncrement(int column) throws SQLException
{
checkColumnIndex(column);
//Could SPIResultSet detect autoincrement columns???
return false;
}
/**
* Gets the designated column's suggested title for use in printouts and
* displays.
*
* @param column the first column is 1, the second is 2, ...
* @return the suggested column title
* @exception SQLException if a database access error occurs
*/
public final String getColumnLabel(int column) throws SQLException
{
checkColumnIndex(column);
return m_tupleDesc.getColumnName(column).toUpperCase();
}
//--------------------------JDBC 2.0-----------------------------------
/**
* Returns the fully-qualified name of the Java class whose instances
* are manufactured if the method ResultSet.getObject
* is called to retrieve a value
* from the column. ResultSet.getObject may return a subclass of the
* class returned by this method.
*
* @param column the first column is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* ResultSet.getObject to retrieve the value in the specified
* column. This is the class name used for custom mapping.
* @exception SQLException if a database access error occurs
* @since 1.2
*/
public final String getColumnClassName(int column) throws SQLException
{
checkColumnIndex(column);
return this.getOid(column).getJavaClass().getName();
}
/**
* Checks if the column index is valid.
*
* @param column the first column is 1, the second is 2, ...
* @exception SQLException if the column is out of index bounds
*/
protected final void checkColumnIndex(int column) throws SQLException
{
if (column < 1 || column > m_tupleDesc.size())
{
throw new SQLException("Invalid column index: " + column);
}
}
/**
* Gets column OID
* @param column Column index
* @return column OID
* @throws SQLException if an error occurs
*/
protected final Oid getOid(int column) throws SQLException
{
return m_tupleDesc.getOid(column);
}
/**
* Gets column length. This method is called if the AbstractResultSet does not
* know how to get column length according to type OID.
* We retutn 0 because we don't know the proper length either.
* @param column Column index
* @return column length
* @throws SQLException if an error occurs
*/
protected final int getFieldLength(int column) throws SQLException
{
return 0;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SingleRowWriter.java 0000664 0000767 0000770 00000007036 10630554503 030125 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.Calendar;
import org.postgresql.pljava.internal.Tuple;
import org.postgresql.pljava.internal.TupleDesc;
/**
* A single row, updateable ResultSet, specially made for functions and
* procedures that returns complex types or sets.
*
* @author Thomas Hallgren
*/
public class SingleRowWriter extends SingleRowResultSet
{
private final TupleDesc m_tupleDesc;
private final Object[] m_values;
private Tuple m_tuple;
public SingleRowWriter(TupleDesc tupleDesc)
throws SQLException
{
m_tupleDesc = tupleDesc;
m_values = new Object[tupleDesc.size()];
}
protected Object getObjectValue(int columnIndex)
throws SQLException
{
if(columnIndex < 1)
throw new SQLException("System columns cannot be obtained from this type of ResultSet");
return m_values[columnIndex - 1];
}
/**
* Returns true if the row contains any non null
* values since all values of the row are null initially.
*/
public boolean rowUpdated()
throws SQLException
{
int top = m_values.length;
while(--top >= 0)
if(m_values[top] != null)
return true;
return false;
}
public void updateObject(int columnIndex, Object x)
throws SQLException
{
if(columnIndex < 1)
throw new SQLException("System columns cannot be updated");
if(x == null)
m_values[columnIndex-1] = x;
Class c = m_tupleDesc.getColumnClass(columnIndex);
if(!c.isInstance(x)
&& !(c == byte[].class && (x instanceof BlobValue)))
{
if(Number.class.isAssignableFrom(c))
x = SPIConnection.basicNumericCoersion(c, x);
else
if(Time.class.isAssignableFrom(c)
|| Date.class.isAssignableFrom(c)
|| Timestamp.class.isAssignableFrom(c))
x = SPIConnection.basicCalendricalCoersion(c, x, Calendar.getInstance());
else
x = SPIConnection.basicCoersion(c, x);
}
m_values[columnIndex-1] = x;
}
public void cancelRowUpdates()
throws SQLException
{
Arrays.fill(m_values, null);
}
/**
* Cancels all changes but doesn't really close the set.
*/
public void close()
throws SQLException
{
Arrays.fill(m_values, null);
m_tuple = null; // Feel free to garbage collect...
}
public void copyRowFrom(ResultSet rs)
throws SQLException
{
int top = m_values.length;
for(int idx = 0; idx < top; ++idx)
m_values[idx] = rs.getObject(idx+1);
}
/**
* Creates a tuple from the current row values and then cancel all row
* updates to prepare for a new row. This method is called automatically by
* the trigger handler and should not be called in any other way.
*
* @return The native pointer of the Tuple reflecting the current row
* values.
* @throws SQLException
*/
public long getTupleAndClear()
throws SQLException
{
// We hold on to the tuple as an instance variable so that it doesn't
// get garbage collected until this result set is closed or we create
// another tuple. This behavior is connected to the internal behavior
// of Set Returning Functions (SRF) in the backend.
//
m_tuple = this.getTupleDesc().formTuple(m_values);
Arrays.fill(m_values, null);
return m_tuple.getNativePointer();
}
protected final TupleDesc getTupleDesc()
{
return m_tupleDesc;
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SQLInputFromChunk.java 0000664 0000767 0000770 00000014544 10630554503 030315 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root directory of this distribution or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.SQLInput;
import java.sql.Time;
import java.sql.Timestamp;
import org.postgresql.pljava.internal.Backend;
/**
* The SQLInputToChunk uses JNI to read from memory that has been allocated by
* the PostgreSQL backend. A user should never make an attempt to create an
* instance of this class. Only internal JNI routines can do that. An instance
* is propagated in a call from the internal JNI layer to the Java layer will
* only survive during that single call. The handle of the instance will be
* invalidated when the call returns and subsequent use of the instance will
* yield a SQLException with the message "Stream is closed".
*
* @author Thomas Hallgren
*/
public class SQLInputFromChunk implements SQLInput
{
private static final byte[] s_byteBuffer = new byte[8];
private final int m_chunkSize;
private int m_position;
private long m_handle;
public SQLInputFromChunk(long handle, int chunkSize)
{
m_handle = handle;
m_chunkSize = chunkSize;
m_position = 0;
}
public Array readArray() throws SQLException
{
throw new UnsupportedOperationException("readArray");
}
public InputStream readAsciiStream() throws SQLException
{
throw new UnsupportedOperationException("readAsciiStream");
}
public BigDecimal readBigDecimal() throws SQLException
{
return new BigDecimal(this.readString());
}
public InputStream readBinaryStream() throws SQLException
{
return new ByteArrayInputStream(this.readBytes());
}
public Blob readBlob() throws SQLException
{
throw new UnsupportedOperationException("readBlob");
}
public boolean readBoolean() throws SQLException
{
int c = this.read();
if(c < 0)
throw new SQLException("Unexpected EOF on data input");
return c != 0;
}
public byte readByte() throws SQLException
{
int c = this.read();
if(c < 0)
throw new SQLException("Unexpected EOF on data input");
return (byte)c;
}
public byte[] readBytes() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
if(m_handle == 0)
throw new SQLException("Stream is closed");
if(m_chunkSize - m_position < 2)
throw new SQLException("Unexpected EOF on data input");
_readBytes(m_handle, m_position, s_byteBuffer, 2);
m_position += 2;
int len = ((s_byteBuffer[0] & 0xff) << 8) | (s_byteBuffer[1] & 0xff);
byte[] buffer = new byte[len];
if(len > 0)
{
_readBytes(m_handle, m_position, buffer, len);
m_position += len;
}
return buffer;
}
}
public Reader readCharacterStream() throws SQLException
{
return new StringReader(this.readString());
}
public Clob readClob() throws SQLException
{
throw new UnsupportedOperationException("readClob");
}
public Date readDate() throws SQLException
{
return new Date(this.readLong());
}
public double readDouble() throws SQLException
{
return Double.longBitsToDouble(this.readLong());
}
public float readFloat() throws SQLException
{
return Float.intBitsToFloat(readInt());
}
public int readInt() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
if(m_chunkSize - m_position < 4)
throw new SQLException("Unexpected EOF on data input");
_readBytes(m_handle, m_position, s_byteBuffer, 4);
m_position += 4;
return ((s_byteBuffer[0] & 0xff) << 24) |
((s_byteBuffer[1] & 0xff) << 16) |
((s_byteBuffer[2] & 0xff) << 8) |
(s_byteBuffer[3] & 0xff);
}
}
public long readLong() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
if(m_chunkSize - m_position < 8)
throw new SQLException("Unexpected EOF on data input");
_readBytes(m_handle, m_position, s_byteBuffer, 8);
m_position += 8;
return ((long)(s_byteBuffer[0] & 0xff) << 56) |
((long)(s_byteBuffer[1] & 0xff) << 48) |
((long)(s_byteBuffer[2] & 0xff) << 40) |
((long)(s_byteBuffer[3] & 0xff) << 32) |
((long)(s_byteBuffer[4] & 0xff) << 24) |
((s_byteBuffer[5] & 0xff) << 16) |
((s_byteBuffer[6] & 0xff) << 8) |
(s_byteBuffer[7] & 0xff);
}
}
public Object readObject() throws SQLException
{
throw new UnsupportedOperationException("readObject");
}
public Ref readRef() throws SQLException
{
throw new UnsupportedOperationException("readRef");
}
public short readShort() throws SQLException
{
synchronized(Backend.THREADLOCK)
{
if(m_chunkSize - m_position < 2)
throw new SQLException("Unexpected EOF on data input");
_readBytes(m_handle, m_position, s_byteBuffer, 2);
m_position += 2;
return (short)(((s_byteBuffer[0] & 0xff) << 8) | (s_byteBuffer[1] & 0xff));
}
}
public String readString() throws SQLException
{
try
{
return new String(this.readBytes(), "UTF8");
}
catch(UnsupportedEncodingException e)
{
throw new SQLException("UTF8 encoding not supported by JVM");
}
}
public Time readTime() throws SQLException
{
return new Time(this.readLong());
}
public Timestamp readTimestamp() throws SQLException
{
return new Timestamp(this.readLong());
}
public URL readURL() throws SQLException
{
try
{
return new URL(this.readString());
}
catch(MalformedURLException e)
{
throw new SQLException(e.getMessage());
}
}
public boolean wasNull() throws SQLException
{
return false;
}
void close()
{
m_handle = 0;
}
private int read() throws SQLException
{
if(m_position < m_chunkSize)
{
synchronized(Backend.THREADLOCK)
{
if(m_handle == 0)
throw new SQLException("Stream is closed");
return _readByte(m_handle, m_position++);
}
}
return -1;
}
private static native int _readByte(long handle, int position);
private static native void _readBytes(long handle, int position, byte[] dest, int len);
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/BuiltinFunctions.java 0000664 0000767 0000770 00000007136 10630554503 030317 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
/**
* PostgreSQL builtin functions
* @author Filip Hrbek
*/
public class BuiltinFunctions {
// numeric functions names
public final static String ABS="abs";
public final static String ACOS="acos";
public final static String ASIN="asin";
public final static String ATAN="atan";
public final static String ATAN2="atan2";
public final static String CEILING="ceiling";
public final static String COS="cos";
public final static String COT="cot";
public final static String DEGREES="degrees";
public final static String EXP="exp";
public final static String FLOOR="floor";
public final static String LOG="log";
public final static String LOG10="log10";
public final static String MOD="mod";
public final static String PI="pi";
public final static String POWER="power";
public final static String RADIANS="radians";
public final static String RAND="rand";
public final static String ROUND="round";
public final static String SIGN="sign";
public final static String SIN="sin";
public final static String SQRT="sqrt";
public final static String TAN="tan";
public final static String TRUNCATE="truncate";
// string function names
public final static String ASCII="ascii";
public final static String CHAR="char";
public final static String CONCAT="concat";
public final static String INSERT="insert"; // change arguments order
public final static String LCASE="lcase";
public final static String LEFT="left";
public final static String LENGTH="length";
public final static String LOCATE="locate"; // the 3 args version duplicate args
public final static String LTRIM="ltrim";
public final static String REPEAT="repeat";
public final static String REPLACE="replace";
public final static String RIGHT="right"; // duplicate args
public final static String RTRIM="rtrim";
public final static String SPACE="space";
public final static String SUBSTRING="substring";
public final static String UCASE="ucase";
// soundex is implemented on the server side by
// the contrib/fuzzystrmatch module. We provide a translation
// for this in the driver, but since we don't want to bother with run
// time detection of this module's installation we don't report this
// method as supported in DatabaseMetaData.
// difference is currently unsupported entirely.
// date time function names
public final static String CURDATE="curdate";
public final static String CURTIME="curtime";
public final static String DAYNAME="dayname";
public final static String DAYOFMONTH="dayofmonth";
public final static String DAYOFWEEK="dayofweek";
public final static String DAYOFYEAR="dayofyear";
public final static String HOUR="hour";
public final static String MINUTE="minute";
public final static String MONTH="month";
public final static String MONTHNAME="monthname";
public final static String NOW="now";
public final static String QUARTER="quarter";
public final static String SECOND="second";
public final static String WEEK="week";
public final static String YEAR="year";
// TODO : timestampadd and timestampdiff
// system functions
public final static String DATABASE="database";
public final static String IFNULL="ifnull";
public final static String USER="user";
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIStatement.java 0000664 0000767 0000770 00000020366 10630554503 027340 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.util.ArrayList;
import org.postgresql.pljava.internal.ExecutionPlan;
import org.postgresql.pljava.internal.Portal;
import org.postgresql.pljava.internal.SPI;
import org.postgresql.pljava.internal.SPIException;
/**
*
* @author Thomas Hallgren
*/
public class SPIStatement implements Statement
{
private final SPIConnection m_connection;
// Default settings.
//
private String m_cursorName = null;
private int m_fetchSize = 1000;
private int m_maxRows = 0;
private ResultSet m_resultSet = null;
private int m_updateCount = 0;
private ArrayList m_batch = null;
private boolean m_closed = false;
public SPIStatement(SPIConnection conn)
{
m_connection = conn;
}
public void addBatch(String statement)
throws SQLException
{
// Statements are converted to native SQL once they
// are executed.
//
this.internalAddBatch(statement);
}
public void cancel()
throws SQLException
{
}
public void clearBatch()
throws SQLException
{
m_batch = null;
}
public void clearWarnings()
throws SQLException
{
}
public void close()
throws SQLException
{
if(m_resultSet != null)
//
// The close will call back to the resultSetClosed method
// and set the m_resultSet to null.
//
m_resultSet.close();
m_updateCount = -1;
m_cursorName = null;
m_batch = null;
m_closed = true;
}
public boolean execute(String statement)
throws SQLException
{
// Ensure that the statement is closed before we re-execute
//
this.close();
ExecutionPlan plan = ExecutionPlan.prepare(
m_connection.nativeSQL(statement), null);
int result = SPI.getResult();
if(plan == null)
throw new SPIException(result);
try
{
return this.executePlan(plan, null);
}
finally
{
try { plan.close(); } catch(Exception e) {}
}
}
protected boolean executePlan(ExecutionPlan plan, Object[] paramValues)
throws SQLException
{
m_updateCount = -1;
m_resultSet = null;
boolean isResultSet = plan.isCursorPlan();
if(isResultSet)
{
Portal portal = plan.cursorOpen(m_cursorName, paramValues);
m_resultSet = new SPIResultSet(this, portal, m_maxRows);
}
else
{
try
{
plan.execute(paramValues, m_maxRows);
m_updateCount = SPI.getProcessed();
}
finally
{
SPI.freeTupTable();
}
}
return isResultSet;
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean execute(String statement, int autoGeneratedKeys)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.execute(String,int)");
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean execute(String statement, int[] columnIndexes)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.execute(String,int[])");
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public boolean execute(String statement, String[] columnNames)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.execute(String,String[])");
}
public int[] executeBatch()
throws SQLException
{
int numBatches = (m_batch == null) ? 0 : m_batch.size();
int[] result = new int[numBatches];
for(int idx = 0; idx < numBatches; ++idx)
result[idx] = this.executeBatchEntry(m_batch.get(idx));
return result;
}
public ResultSet executeQuery(String statement)
throws SQLException
{
this.execute(statement);
return this.getResultSet();
}
public int executeUpdate(String statement)
throws SQLException
{
this.execute(statement);
return this.getUpdateCount();
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public int executeUpdate(String statement, int autoGeneratedKeys)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public int executeUpdate(String statement, int[] columnIndexes)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
/**
* Return of auto generated keys is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public int executeUpdate(String statement, String[] columnNames)
throws SQLException
{
throw new UnsupportedFeatureException("Auto generated key support not yet implemented");
}
/**
* Returns the Connection from that created this statement.
* @throws SQLException if the statement is closed.
*/
public Connection getConnection()
throws SQLException
{
if(m_connection == null)
throw new StatementClosedException();
return m_connection;
}
public int getFetchDirection()
throws SQLException
{
return ResultSet.FETCH_FORWARD;
}
public int getFetchSize()
throws SQLException
{
return m_fetchSize;
}
public ResultSet getGeneratedKeys()
throws SQLException
{
throw new SQLException("JDK 1.4 functionality not yet implemented");
}
public int getMaxFieldSize()
throws SQLException
{
return Integer.MAX_VALUE;
}
public int getMaxRows()
throws SQLException
{
return m_maxRows;
}
public boolean getMoreResults()
throws SQLException
{
return false;
}
public boolean getMoreResults(int current)
throws SQLException
{
return false;
}
public int getQueryTimeout()
throws SQLException
{
return 0;
}
public ResultSet getResultSet()
throws SQLException
{
return m_resultSet;
}
public int getResultSetConcurrency()
{
return ResultSet.CONCUR_READ_ONLY;
}
public int getResultSetHoldability()
throws SQLException
{
throw new SQLException("JDK 1.4 functionality not yet implemented");
}
public int getResultSetType()
{
return ResultSet.TYPE_FORWARD_ONLY;
}
public int getUpdateCount()
throws SQLException
{
return m_updateCount;
}
public SQLWarning getWarnings()
throws SQLException
{
if (m_closed) {
throw new SQLException("getWarnings: Statement is closed");
}
return null;
}
public void setCursorName(String cursorName)
throws SQLException
{
m_cursorName = cursorName;
}
public void setEscapeProcessing(boolean enable)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.setEscapeProcessing");
}
/**
* Only {@link ResultSet#FETCH_FORWARD} is supported.
* @throws SQLException indicating that this feature is not supported
* for other values on direction.
*/
public void setFetchDirection(int direction)
throws SQLException
{
if(direction != ResultSet.FETCH_FORWARD)
throw new UnsupportedFeatureException("Non forward fetch direction");
}
public void setFetchSize(int size)
throws SQLException
{
m_fetchSize = size;
}
public void setMaxFieldSize(int size)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.setMaxFieldSize");
}
public void setMaxRows(int rows)
throws SQLException
{
m_maxRows = rows;
}
public void setQueryTimeout(int seconds)
throws SQLException
{
throw new UnsupportedFeatureException("Statement.setQueryTimeout");
}
protected void internalAddBatch(Object batch)
throws SQLException
{
if(m_batch == null)
m_batch = new ArrayList();
m_batch.add(batch);
}
protected int executeBatchEntry(Object batchEntry)
throws SQLException
{
int ret = SUCCESS_NO_INFO;
if(this.execute(m_connection.nativeSQL((String)batchEntry)))
this.getResultSet().close();
else if(m_updateCount >= 0)
ret = m_updateCount;
return ret;
}
void resultSetClosed(ResultSet rs)
{
if(rs == m_resultSet)
m_resultSet = null;
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/jdbc/SPIParameterMetaData.java 0000664 0000767 0000770 00000004103 10630554503 030704 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.jdbc;
import java.sql.ParameterMetaData;
import java.sql.SQLException;
/**
*
* @author Thomas Hallgren
*/
public class SPIParameterMetaData implements ParameterMetaData
{
private final int[] m_sqlTypes;
SPIParameterMetaData(int[] sqlTypes)
{
m_sqlTypes = sqlTypes;
}
public int getParameterCount()
throws SQLException
{
return m_sqlTypes == null ? 0 : m_sqlTypes.length;
}
public int isNullable(int arg0)
throws SQLException
{
return parameterNullableUnknown;
}
public boolean isSigned(int arg0)
throws SQLException
{
return true;
}
public int getPrecision(int arg0)
throws SQLException
{
return 0;
}
public int getScale(int arg0)
throws SQLException
{
return 0;
}
public int getParameterType(int paramIndex)
throws SQLException
{
if(paramIndex < 1 || paramIndex > this.getParameterCount())
throw new SQLException("Parameter index out of range");
return m_sqlTypes[paramIndex-1];
}
/**
* This feature is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public String getParameterTypeName(int arg0)
throws SQLException
{
throw new UnsupportedFeatureException("Parameter type name support not yet implemented");
}
/**
* This feature is not yet supported.
* @throws SQLException indicating that this feature is not supported.
*/
public String getParameterClassName(int arg0)
throws SQLException
{
throw new UnsupportedFeatureException("Parameter class name support not yet implemented");
}
/**
* Returns {@link ParameterMetaData#parameterModeIn} always since this
* is the only supported type at this time.
*/
public int getParameterMode(int paramIndex) throws SQLException
{
if(paramIndex < 1 || paramIndex > this.getParameterCount())
throw new SQLException("Parameter index out of range");
return parameterModeIn;
}
} pljava-20070604/src/java/pljava/org/postgresql/pljava/sqlj/ 0000775 0000767 0000770 00000000000 10630554503 024215 5 ustar iwasakims iwasakims pljava-20070604/src/java/pljava/org/postgresql/pljava/sqlj/EntryStreamHandler.java 0000664 0000767 0000770 00000005751 10630554503 030643 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.sqlj;
import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.postgresql.pljava.jdbc.SQLUtils;
/**
* @author Thomas Hallgren
*/
class EntryStreamHandler extends URLStreamHandler
{
private static EntryStreamHandler s_instance;
protected URLConnection openConnection(URL u)
throws IOException
{
return new EntryConnection(u);
}
/**
* Creates an EntryStreamHandler on the first invocation. This handler is
* then cached and returned on subsequent invocations.
* @return the one and only handler.
*/
static URLStreamHandler getInstance()
{
if(s_instance == null)
s_instance = new EntryStreamHandler();
return s_instance;
}
class EntryConnection extends URLConnection
{
private final int m_entryId;
private String m_entryName;
private byte[] m_image;
protected EntryConnection(URL entryURL)
{
super(entryURL);
m_entryId = Integer.parseInt(url.getPath().substring(1));
}
/**
* Executes the prepared statement that will fetch an image based on
* the entryId denoted by the URL of this connection.
* If connect has been called already, subsequent calls are ignored.
*/
public void connect()
throws IOException
{
if(connected)
return;
PreparedStatement stmt = null;
ResultSet rs = null;
try
{
stmt = SQLUtils.getDefaultConnection().prepareStatement(
"SELECT entryName, entryImage FROM sqlj.jar_entry WHERE entryId = ?");
stmt.setInt(1, m_entryId);
rs = stmt.executeQuery();
if(rs.next())
{
m_entryName = rs.getString(1);
m_image = rs.getBytes(2);
connected = true;
}
else
throw new FileNotFoundException("jarId = " + m_entryId);
}
catch(SQLException e)
{
throw new IOException(e.getMessage());
}
finally
{
SQLUtils.close(rs);
SQLUtils.close(stmt);
}
}
/**
* Creates a new {@link java.io.ByteArrayInputStream} for the image that
* was obtained during {@link #connect}.
* @return the created input stream.
*/
public InputStream getInputStream()
throws IOException
{
this.connect();
return new ByteArrayInputStream(m_image);
}
/**
* Consults the current {@link java.net.FileNameMap FileNameMap} to obtain
* the MIME type for the file name extension for the entry handled by this
* connection.
* @return the content type based on the file name extension.
*/
public String getContentType()
{
return getFileNameMap().getContentTypeFor(m_entryName);
}
}
}
pljava-20070604/src/java/pljava/org/postgresql/pljava/sqlj/Loader.java 0000664 0000767 0000770 00000021525 10630554503 026273 0 ustar iwasakims iwasakims /*
* Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
* Distributed under the terms shown in the file COPYRIGHT
* found in the root folder of this project or at
* http://eng.tada.se/osprojects/COPYRIGHT.html
*/
package org.postgresql.pljava.sqlj;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.postgresql.pljava.internal.Backend;
import org.postgresql.pljava.internal.Oid;
import org.postgresql.pljava.jdbc.SQLUtils;
/**
* @author Thomas Hallgren
*/
public class Loader extends ClassLoader
{
private final static Logger s_logger = Logger.getLogger(Loader.class.getName());
static class EntryEnumeration implements Enumeration
{
private final int[] m_entryIds;
private int m_top = 0;
EntryEnumeration(int[] entryIds)
{
m_entryIds = entryIds;
}
public boolean hasMoreElements()
{
return (m_top < m_entryIds.length);
}
public Object nextElement()
throws NoSuchElementException
{
if (m_top >= m_entryIds.length)
throw new NoSuchElementException();
return entryURL(m_entryIds[m_top++]);
}
}
private static final String PUBLIC_SCHEMA = "public";
private static final Map s_schemaLoaders = new HashMap();
private static final Map s_typeMap = new HashMap();
/**
* Removes all cached schema loaders, functions, and type maps. This
* method is called by the utility functions that manipulate the
* data that has been cached. It is not intended to be called
* from user code.
*/
public static void clearSchemaLoaders()
{
s_schemaLoaders.clear();
s_typeMap.clear();
Backend.clearFunctionCache();
}
/**
* Obtains the loader that is in effect for the current schema (i.e. the
* schema that is first in the search path).
* @return A loader
* @throws SQLException
*/
public static ClassLoader getCurrentLoader()
throws SQLException
{
String schema;
Statement stmt = SQLUtils.getDefaultConnection().createStatement();
ResultSet rs = null;
try
{
rs = stmt.executeQuery("SELECT current_schema()");
if(!rs.next())
throw new SQLException("Unable to determine current schema");
schema = rs.getString(1);
}
finally
{
SQLUtils.close(rs);
SQLUtils.close(stmt);
}
return getSchemaLoader(schema);
}
/**
* Obtain a loader that has been configured for the class path of the
* schema named schemaName. Class paths are defined using the
* SQL procedure sqlj.set_classpath.
* @param schemaName The name of the schema.
* @return A loader.
*/
public static ClassLoader getSchemaLoader(String schemaName)
throws SQLException
{
if(schemaName == null || schemaName.length() == 0)
schemaName = PUBLIC_SCHEMA;
else
schemaName = schemaName.toLowerCase();
ClassLoader loader = (ClassLoader)s_schemaLoaders.get(schemaName);
if(loader != null)
return loader;
Map classImages = new HashMap();
Connection conn = SQLUtils.getDefaultConnection();
PreparedStatement outer = null;
PreparedStatement inner = null;
try
{
// Read the entries so that the one with highest prio is read last.
//
outer = conn.prepareStatement(
"SELECT r.jarId" +
" FROM sqlj.jar_repository r INNER JOIN sqlj.classpath_entry c ON r.jarId = c.jarId" +
" WHERE c.schemaName = ? ORDER BY c.ordinal DESC");
inner = conn.prepareStatement(
"SELECT entryId, entryName FROM sqlj.jar_entry WHERE jarId = ?");
outer.setString(1, schemaName);
ResultSet rs = outer.executeQuery();
try
{
while(rs.next())
{
inner.setInt(1, rs.getInt(1));
ResultSet rs2 = inner.executeQuery();
try
{
while(rs2.next())
{
int entryId = rs2.getInt(1);
String entryName = rs2.getString(2);
int[] oldEntry = (int[])classImages.get(entryName);
if(oldEntry == null)
classImages.put(entryName, new int[] { entryId });
else
{
int last = oldEntry.length;
int[] newEntry = new int[last + 1];
newEntry[0] = entryId;
System.arraycopy(oldEntry, 0, newEntry, 1, last);
classImages.put(entryName, newEntry);
}
}
}
finally
{
SQLUtils.close(rs2);
}
}
}
finally
{
SQLUtils.close(rs);
}
}
finally
{
SQLUtils.close(outer);
SQLUtils.close(inner);
}
ClassLoader parent = ClassLoader.getSystemClassLoader();
if(classImages.size() == 0)
//
// No classpath defined for the schema. Default to
// classpath of public schema or to the system classloader if the
// request already is for the public schema.
//
loader = schemaName.equals(PUBLIC_SCHEMA) ? parent : getSchemaLoader(PUBLIC_SCHEMA);
else
loader = new Loader(classImages, parent);
s_schemaLoaders.put(schemaName, loader);
return loader;
}
/**
* Returns the SQL type {@link Oid} to Java {@link Class} map that contains the
* Java UDT mappings for the given schema.
* This method is called by the function mapping mechanisms. Application code
* should never call this method.
*
* @param schema The schema
* @return The Map, possibly empty but never null.
*/
public static Map getTypeMap(final String schema) throws SQLException
{
Map typesForSchema = (Map)s_typeMap.get(schema);
if(typesForSchema != null)
return typesForSchema;
s_logger.fine("Creating typeMappings for schema " + schema);
typesForSchema = new HashMap()
{
public Object get(Object key)
{
s_logger.fine("Obtaining type mapping for OID " + key + " for schema " + schema);
return super.get(key);
}
};
ClassLoader loader = Loader.getSchemaLoader(schema);
Statement stmt = SQLUtils.getDefaultConnection().createStatement();
ResultSet rs = null;
try
{
rs = stmt.executeQuery("SELECT javaName, sqlName FROM sqlj.typemap_entry");
while(rs.next())
{
try
{
String javaClassName = rs.getString(1);
String sqlName = rs.getString(2);
Class cls = loader.loadClass(javaClassName);
if(!SQLData.class.isAssignableFrom(cls))
throw new SQLException("Class " + javaClassName + " does not implement java.sql.SQLData");
Oid typeOid = Oid.forTypeName(sqlName);
typesForSchema.put(typeOid, cls);
s_logger.fine("Adding type mapping for OID " + typeOid + " -> class " + cls.getName() + " for schema " + schema);
}
catch(ClassNotFoundException e)
{
// Ignore, type is not know to this schema and that is ok
}
}
if(typesForSchema.isEmpty())
typesForSchema = Collections.EMPTY_MAP;
s_typeMap.put(schema, typesForSchema);
return typesForSchema;
}
finally
{
SQLUtils.close(rs);
SQLUtils.close(stmt);
}
}
private static URL entryURL(int entryId)
{
try
{
return new URL(
"dbf",
"localhost",
-1,
"/" + entryId,
EntryStreamHandler.getInstance());
}
catch(MalformedURLException e)
{
throw new RuntimeException(e);
}
}
private final Map m_entries;
/**
* Create a new Loader.
* @param entries
* @param parent
*/
Loader(Map entries, ClassLoader parent)
{
super(parent);
m_entries = entries;
}
protected Class findClass(final String name)
throws ClassNotFoundException
{
String path = name.replace('.', '/').concat(".class");
int[] entryId = (int[])m_entries.get(path);
if(entryId != null)
{
PreparedStatement stmt = null;
ResultSet rs = null;
try
{
// This code rely heavily on the fact that the connection
// is a singleton and that the prepared statement will live
// for the duration of the loader.
//
stmt = SQLUtils.getDefaultConnection().prepareStatement(
"SELECT entryImage FROM sqlj.jar_entry WHERE entryId = ?");
stmt.setInt(1, entryId[0]);
rs = stmt.executeQuery();
if(rs.next())
{
byte[] img = rs.getBytes(1);
rs.close();
rs = null;
return this.defineClass(name, img, 0, img.length);
}
}
catch(SQLException e)
{
Logger.getAnonymousLogger().log(Level.INFO, "Failed to load class", e);
throw new ClassNotFoundException(name + " due to: " + e.getMessage());
}
finally
{
SQLUtils.close(rs);
SQLUtils.close(stmt);
}
}
throw new ClassNotFoundException(name);
}
protected URL findResource(String name)
{
int[] entryIds = (int[])m_entries.get(name);
if(entryIds == null)
return null;
return entryURL(entryIds[0]);
}
protected Enumeration findResources(String name)
throws IOException
{
int[] entryIds = (int[])m_entries.get(name);
if(entryIds == null)
entryIds = new int[0];
return new EntryEnumeration(entryIds);
}
}
pljava-20070604/src/java/pljava/Makefile 0000664 0000767 0000770 00000005202 10630554503 020434 0 ustar iwasakims iwasakims #-------------------------------------------------------------------------
# Copyright (c) 2004, 2005 TADA AB - Taby Sweden
# Distributed under the terms shown in the file COPYRIGHT
# found in the root folder of this project or at
# http://eng.tada.se/osprojects/COPYRIGHT.html
#
# @author Thomas Hallgren
#-------------------------------------------------------------------------
NAME := pljava
JAVADOCTITLE := 'PL/Java v$(PLJAVA_MAJOR_VER).$(PLJAVA_MINOR_VER) API Specification'
include $(MODULEROOT)/Makefile.global
SRCDIR_USC := $(subst .,^,$(SRCDIR))
mkclsrc = $(subst ^,.,$(subst .,/,$(1:%=$(SRCDIR_USC)/%^java)))
JAVAH := javah
INTPKG := org.postgresql.pljava.internal
JDBCPKG := org.postgresql.pljava.jdbc
JNI_CLASSES := \
$(INTPKG).Backend \
$(INTPKG).SPI \
$(INTPKG).AclId \
$(INTPKG).ErrorData \
$(INTPKG).Oid \
$(INTPKG).ExecutionPlan \
$(INTPKG).JavaWrapper \
$(INTPKG).LargeObject \
$(INTPKG).PgSavepoint \
$(INTPKG).Portal \
$(INTPKG).Relation \
$(INTPKG).Session \
$(INTPKG).SubXactListener \
$(INTPKG).TriggerData \
$(INTPKG).Tuple \
$(INTPKG).TupleDesc \
$(INTPKG).XactListener \
$(JDBCPKG).Invocation \
$(JDBCPKG).SingleRowReader \
$(JDBCPKG).SQLInputFromChunk \
$(JDBCPKG).SQLOutputToChunk \
$(JDBCPKG).SQLInputFromTuple \
$(JDBCPKG).SQLOutputToTuple
JNISRCS := $(call mkclsrc,$(JNI_CLASSES))
ifdef USE_GCJ
# We include both the pljava_jar.o and the pjlava.jar here although
# pljava doesn't need the latter. Most java compilers will need it
# in order to compile triggers and functions later.
#
JNIHDRS = $(patsubst %,$(JNIDIR)/%.h,$(subst .,_,$(JNI_CLASSES)))
mkcname = $(subst _,.,$(1:$(JNIDIR)/%.h=%))
all: $(OBJDIR)/$(NAME)_jar.o $(JARFILE) $(JNIDIR)/.timestamp
$(OBJDIR)/$(NAME)_jar.o: .timestamp
@-mkdir -p $(@D)
@echo $(GCJ) -c -fpic -fjni -o $@ ''
@$(GCJ) -c -fpic -fjni -o $@ $(SRCS)
# gcjh fails to clear its function name cache between files (see
# gcc bugzilla #17575) so we must do each file separately to
# avoid name ambiguities that causes names to be generated with
# parameter type info.
#
$(JNIHDRS): $(JNISRCS)
@-mkdir -p $(@D)
@gcjh -jni --classpath=. -d $(@D) $(call mkcname,$@)
# gcjh generated headers don't define final constants (see gcc
# bugzilla #16843) so we must copy our own version of java.sql.Types.
#
$(JNIDIR)/.timestamp: $(JNIHDRS)
@-mkdir -p $(@D)
@cp $(PROJDIR)/fixes/gcj/java_sql_Types.h $(@D)
@touch $@
else
all: $(JARFILE) $(JNIDIR)/.timestamp
$(JNIDIR)/.timestamp: $(JNISRCS)
@-mkdir -p $(@D)
@echo javah -classpath . -d $(@D) ''
@javah -classpath . -d $(@D) $(JNI_CLASSES) java.sql.Types
@touch $@
endif
$(JARFILE): .timestamp
$(JAR) cf $@ .
pljava-20070604/src/sql/ 0000775 0000767 0000770 00000000000 10630554503 015376 5 ustar iwasakims iwasakims pljava-20070604/src/sql/uninstall.sql 0000664 0000767 0000770 00000000123 10630554503 020124 0 ustar iwasakims iwasakims DROP LANGUAGE java CASCADE;
DROP LANGUAGE javaU CASCADE;
DROP SCHEMA sqlj CASCADE;
pljava-20070604/src/sql/install.sql 0000664 0000767 0000770 00000005505 10630554503 017572 0 ustar iwasakims iwasakims CREATE SCHEMA sqlj;
GRANT USAGE ON SCHEMA sqlj TO public;
CREATE FUNCTION sqlj.java_call_handler()
RETURNS language_handler AS 'pljava'
LANGUAGE C;
CREATE TRUSTED LANGUAGE java HANDLER sqlj.java_call_handler;
CREATE FUNCTION sqlj.javau_call_handler()
RETURNS language_handler AS 'pljava'
LANGUAGE C;
CREATE LANGUAGE javaU HANDLER sqlj.javau_call_handler;
CREATE TABLE sqlj.jar_repository(
jarId SERIAL PRIMARY KEY,
jarName VARCHAR(100) UNIQUE NOT NULL,
jarOrigin VARCHAR(500) NOT NULL,
jarOwner NAME NOT NULL,
jarManifest TEXT,
deploymentDesc INT
);
GRANT SELECT ON sqlj.jar_repository TO public;
CREATE TABLE sqlj.jar_entry(
entryId SERIAL PRIMARY KEY,
entryName VARCHAR(200) NOT NULL,
jarId INT NOT NULL REFERENCES sqlj.jar_repository ON DELETE CASCADE,
entryImage BYTEA NOT NULL,
UNIQUE(jarId, entryName)
);
GRANT SELECT ON sqlj.jar_entry TO public;
ALTER TABLE sqlj.jar_repository
ADD FOREIGN KEY (deploymentDesc) REFERENCES sqlj.jar_entry ON DELETE SET NULL;
CREATE TABLE sqlj.classpath_entry(
schemaName VARCHAR(30) NOT NULL,
ordinal INT2 NOT NULL,
jarId INT NOT NULL REFERENCES sqlj.jar_repository ON DELETE CASCADE,
PRIMARY KEY(schemaName, ordinal)
);
GRANT SELECT ON sqlj.classpath_entry TO public;
CREATE TABLE sqlj.typemap_entry(
mapId SERIAL PRIMARY KEY,
javaName VARCHAR(200) NOT NULL,
sqlName NAME NOT NULL
);
GRANT SELECT ON sqlj.typemap_entry TO public;
CREATE FUNCTION sqlj.install_jar(VARCHAR, VARCHAR, BOOLEAN) RETURNS void
AS 'org.postgresql.pljava.management.Commands.installJar'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.install_jar(BYTEA, VARCHAR, BOOLEAN) RETURNS void
AS 'org.postgresql.pljava.management.Commands.installJar'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.replace_jar(VARCHAR, VARCHAR, BOOLEAN) RETURNS void
AS 'org.postgresql.pljava.management.Commands.replaceJar'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.replace_jar(BYTEA, VARCHAR, BOOLEAN) RETURNS void
AS 'org.postgresql.pljava.management.Commands.replaceJar'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.remove_jar(VARCHAR, BOOLEAN) RETURNS void
AS 'org.postgresql.pljava.management.Commands.removeJar'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.set_classpath(VARCHAR, VARCHAR) RETURNS void
AS 'org.postgresql.pljava.management.Commands.setClassPath'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.get_classpath(VARCHAR) RETURNS VARCHAR
AS 'org.postgresql.pljava.management.Commands.getClassPath'
LANGUAGE java STABLE SECURITY DEFINER;
CREATE FUNCTION sqlj.add_type_mapping(VARCHAR, VARCHAR) RETURNS void
AS 'org.postgresql.pljava.management.Commands.addTypeMapping'
LANGUAGE java SECURITY DEFINER;
CREATE FUNCTION sqlj.drop_type_mapping(VARCHAR) RETURNS void
AS 'org.postgresql.pljava.management.Commands.dropTypeMapping'
LANGUAGE java SECURITY DEFINER;
pljava-20070604/.classpath 0000664 0000767 0000770 00000001213 10630554503 015770 0 ustar iwasakims iwasakims
pljava-20070604/packaging/ 0000775 0000767 0000770 00000000000 10630554503 015734 5 ustar iwasakims iwasakims pljava-20070604/packaging/project.xml 0000664 0000767 0000770 00000003033 10630554503 020123 0 ustar iwasakims iwasakims
PL/Java
pljava-public
postgresql
@PLJAVA_VERSION@
Tada AB, Taby Sweden
http://www.tada.se
2003
http://gborg.postgresql.org/images/projects/pljava/screenshots/pljava_logo_small.gif
Public Java interfaces for PL/Java, a server side Java solution for PostgreSQL
Public interfaces for PL/Java
http://gborg.postgresql.org/images/projects/pljava
pljava-dev
http://gborg.postgresql.org/mailman/listinfo/pljava-dev
http://gborg.postgresql.org/mailman/listinfo/pljava-dev
http://gborg.postgresql.org/pipermail/pljava-dev
Thomas Hallgren
thhal
mailto:thhal@mailblocks.com
http://gborg.postgresql.org/member/memprofile?4551
MET
BSD
repo
pljava-20070604/packaging/Makefile 0000664 0000767 0000770 00000005466 10630554503 017407 0 ustar iwasakims iwasakims #-------------------------------------------------------------------------
# Copyright (c) 2003, 2004 TADA AB - Taby Sweden
# Distributed under the terms shown in the file COPYRIGHT.
#
# @author Thomas Hallgren
#-------------------------------------------------------------------------
include $(PGXS)
SS_VERSION := $(subst ., ,$(subst devel,.devel,$(subst beta,.beta,$(VERSION))))
PGSQL_MAJOR_VER = $(word 1,$(SS_VERSION))
PGSQL_MINOR_VER = $(word 2,$(SS_VERSION))
DISTRIB := distrib
ifdef USE_GCJ
GCJEXTRA=-gcj-
else
GCJEXTRA=-
endif
RELNAME := pljava-$(host_tuple)$(GCJEXTRA)pg$(PGSQL_MAJOR_VER).$(PGSQL_MINOR_VER)-$(PLJAVA_VERSION)
SRCNAME := pljava-src-$(PLJAVA_VERSION)
PKGNAME := pljava-$(PLJAVA_VERSION)
release:
@-mkdir -p $(RELNAME)
@-rm -f $(RELNAME)/*
@find . \( \
-name '*.jar' \
-o -name '*.so' \
-o -name '*.dll' \
\) -a -not -path ./$(RELNAME)'/*' -exec cp {} $(RELNAME) \;
@cp ../src/sql/*.sql $(RELNAME)
@$(TAR) cf $(RELNAME)/docs.tar docs
(cd $(RELNAME); $(TAR) zcf ../distrib/$(RELNAME).tar.gz .)
source_tarball:
@-mkdir -p distrib
@-mkdir -p $(PKGNAME)
@-rm -rf $(PKGNAME)/*
@(cd ..; find . \( \
-name CVS \
-o -name bin \
-o -name build \
-o -name .cvsignore \
\) -prune -o \( -type f -exec cp --parent {} build/$(PKGNAME) \; \) )
@$(TAR) zcf $(DISTRIB)/$(SRCNAME).tar.gz $(PKGNAME)
JAR := jar
PUBLIC_ROOT := classes/pljava
PUBLIC_CLASSES := $(wildcard $(PUBLIC_ROOT)/org/postgresql/pljava/*.*)
PUBLIC_REL_CLASSES = $(foreach var,$(PUBLIC_CLASSES),$(subst $(PUBLIC_ROOT)/,,$(var)))
PUBLIC_SRC_ROOT := ../src/java/pljava
PUBLIC_SRCS := $(wildcard $(PUBLIC_SRC_ROOT)/org/postgresql/pljava/*.*)
PUBLIC_REL_SRCS = $(foreach var,$(PUBLIC_SRCS),$(subst $(PUBLIC_SRC_ROOT)/,,$(var)))
PUBLIC_NAME := pljava-public-$(PLJAVA_VERSION)
PUBLIC_BUNDLE := distrib/$(PUBLIC_NAME)-bundle.jar
JIRA_DESC := distrib/jira-desc.txt
BUNDLEDIR := maven_bundle
PUBLIC_JARFILE := $(PUBLIC_NAME).jar
PUBLIC_SRC_JARFILE := $(PUBLIC_NAME)-src.jar
maven_bundle: $(PUBLIC_BUNDLE) $(JIRA_DESC)
$(PUBLIC_BUNDLE): $(BUNDLEDIR)/LICENSE.txt $(BUNDLEDIR)/project.xml $(BUNDLEDIR)/$(PUBLIC_JARFILE) $(BUNDLEDIR)/$(PUBLIC_SRC_JARFILE)
@(cd $(BUNDLEDIR); $(JAR) cf ../$@ *)
$(BUNDLEDIR)/LICENSE.txt: $(PROJDIR)/COPYRIGHT
@-mkdir -p $(BUNDLEDIR)
@cp $< $(BUNDLEDIR)/LICENSE.txt
$(BUNDLEDIR)/project.xml: $(PROJDIR)/packaging/project.xml
@-mkdir -p $(BUNDLEDIR)
@sed -e 's/@PLJAVA_VERSION@/'$(PLJAVA_VERSION)'/' $< > $@
$(BUNDLEDIR)/$(PUBLIC_JARFILE): $(PUBLIC_CLASSES)
@-mkdir -p $(BUNDLEDIR)
@(cd $(PUBLIC_ROOT); $(JAR) cf ../../$@ $(PUBLIC_REL_CLASSES))
$(BUNDLEDIR)/$(PUBLIC_SRC_JARFILE): $(PUBLIC_SRCS)
@-mkdir -p $(BUNDLEDIR)
@(cd $(PUBLIC_SRC_ROOT); $(JAR) cf ../../../build/$@ $(PUBLIC_REL_SRCS))
$(JIRA_DESC): $(PROJDIR)/packaging/jira-desc.txt
@sed -e 's/@PLJAVA_VERSION@/'$(PLJAVA_VERSION)'/' $< > $@
pljava-20070604/packaging/jira-desc.txt 0000664 0000767 0000770 00000000577 10630554503 020347 0 ustar iwasakims iwasakims ftp://gborg.postgresql.org/pub/pljava/stable/pljava-public-@PLJAVA_VERSION@-bundle.zip
http://gborg.postgresql.org/project/pljava
http://gborg.postgresql.org/project/pljava/genpage.php?thhalcv
PL/Java is a server side Java solution for PostgreSQL. The jar supplied
in this bundle contains the interfaces and classes needed when writing
new Java functions and triggers for PL/Java.
pljava-20070604/.externalToolBuilders/ 0000775 0000767 0000770 00000000000 10630554503 020240 5 ustar iwasakims iwasakims pljava-20070604/.externalToolBuilders/Header generation.launch 0000664 0000767 0000770 00000001232 10630554503 024736 0 ustar iwasakims iwasakims
pljava-20070604/.externalToolBuilders/org.postgresql.pljava build.xml [Builder].launch 0000664 0000767 0000770 00000002257 10630554503 031425 0 ustar iwasakims iwasakims
pljava-20070604/.settings/ 0000775 0000767 0000770 00000000000 10630554503 015726 5 ustar iwasakims iwasakims pljava-20070604/.settings/org.eclipse.cdt.core.prefs 0000664 0000767 0000770 00000000150 10630554503 022675 0 ustar iwasakims iwasakims #Fri May 19 16:01:32 CEST 2006
eclipse.preferences.version=1
indexerId=org.eclipse.cdt.core.fastIndexer
pljava-20070604/.settings/org.eclipse.jdt.core.prefs 0000664 0000767 0000770 00000001153 10630554503 022710 0 ustar iwasakims iwasakims #Fri Feb 11 14:44:25 CET 2005
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.4
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
org.eclipse.jdt.core.compiler.source=1.4
pljava-20070604/fixes/ 0000775 0000767 0000770 00000000000 10622561007 015124 5 ustar iwasakims iwasakims pljava-20070604/fixes/gcj/ 0000775 0000767 0000770 00000000000 10630554503 015671 5 ustar iwasakims iwasakims pljava-20070604/fixes/gcj/java_sql_Types.h 0000664 0000767 0000770 00000004304 10630554503 021027 0 ustar iwasakims iwasakims /* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class java_sql_Types */
#ifndef _Included_java_sql_Types
#define _Included_java_sql_Types
#ifdef __cplusplus
extern "C" {
#endif
#undef java_sql_Types_BIT
#define java_sql_Types_BIT -7L
#undef java_sql_Types_TINYINT
#define java_sql_Types_TINYINT -6L
#undef java_sql_Types_SMALLINT
#define java_sql_Types_SMALLINT 5L
#undef java_sql_Types_INTEGER
#define java_sql_Types_INTEGER 4L
#undef java_sql_Types_BIGINT
#define java_sql_Types_BIGINT -5L
#undef java_sql_Types_FLOAT
#define java_sql_Types_FLOAT 6L
#undef java_sql_Types_REAL
#define java_sql_Types_REAL 7L
#undef java_sql_Types_DOUBLE
#define java_sql_Types_DOUBLE 8L
#undef java_sql_Types_NUMERIC
#define java_sql_Types_NUMERIC 2L
#undef java_sql_Types_DECIMAL
#define java_sql_Types_DECIMAL 3L
#undef java_sql_Types_CHAR
#define java_sql_Types_CHAR 1L
#undef java_sql_Types_VARCHAR
#define java_sql_Types_VARCHAR 12L
#undef java_sql_Types_LONGVARCHAR
#define java_sql_Types_LONGVARCHAR -1L
#undef java_sql_Types_DATE
#define java_sql_Types_DATE 91L
#undef java_sql_Types_TIME
#define java_sql_Types_TIME 92L
#undef java_sql_Types_TIMESTAMP
#define java_sql_Types_TIMESTAMP 93L
#undef java_sql_Types_BINARY
#define java_sql_Types_BINARY -2L
#undef java_sql_Types_VARBINARY
#define java_sql_Types_VARBINARY -3L
#undef java_sql_Types_LONGVARBINARY
#define java_sql_Types_LONGVARBINARY -4L
#undef java_sql_Types_NULL
#define java_sql_Types_NULL 0L
#undef java_sql_Types_OTHER
#define java_sql_Types_OTHER 1111L
#undef java_sql_Types_JAVA_OBJECT
#define java_sql_Types_JAVA_OBJECT 2000L
#undef java_sql_Types_DISTINCT
#define java_sql_Types_DISTINCT 2001L
#undef java_sql_Types_STRUCT
#define java_sql_Types_STRUCT 2002L
#undef java_sql_Types_ARRAY
#define java_sql_Types_ARRAY 2003L
#undef java_sql_Types_BLOB
#define java_sql_Types_BLOB 2004L
#undef java_sql_Types_CLOB
#define java_sql_Types_CLOB 2005L
#undef java_sql_Types_REF
#define java_sql_Types_REF 2006L
#undef java_sql_Types_DATALINK
#define java_sql_Types_DATALINK 70L
#undef java_sql_Types_BOOLEAN
#define java_sql_Types_BOOLEAN 16L
#ifdef __cplusplus
}
#endif
#endif
pljava-20070604/.cdtproject 0000664 0000767 0000770 00000006452 10630554503 016161 0 ustar iwasakims iwasakims
-
-
-
make
-e /bin/make
test_all
false
true
c:/msys/bin/rxvt
-e /bin/make
clean
false
true
c:/msys/bin/rxvt
-e /bin/make
all
false
true
c:/msys/bin/rxvt
-e /bin/make
release
false
true
-
pljava-20070604/.cvsignore 0000664 0000767 0000770 00000000027 10630554503 016007 0 ustar iwasakims iwasakims bin
distrib
*.gz
build
pljava-20070604/Makefile 0000664 0000767 0000770 00000007141 10630554503 015453 0 ustar iwasakims iwasakims #-------------------------------------------------------------------------
# Copyright (c) 2004, 2005, 2006 TADA AB - Taby Sweden
# Distributed under the terms shown in the file COPYRIGHT
# found in the root folder of this project or at
# http://eng.tada.se/osprojects/COPYRIGHT.html
#
# @author Thomas Hallgren
#
# Top level Makefile for PLJava
#
# To compile a PLJava for PostgreSQL 8.x the makefile system will utilize
# the PostgreSQL pgxs system. The only prerequisite for such a compile is
# that a PostgreSQL 8.x is installed on the system and that the PATH is set
# so that the binaries of this installed can be executed.
#
# The following options are recognized (aside from normal options like
# CFLAGS etc.)
#
# PGSQLDIR= For old style (not pgxs based) compilation
# USE_GCJ=1 Builds a shared object file containing both
# C and Java code. Requires GCJ 3.4 or later.
#
#-------------------------------------------------------------------------
# Can't use $(shell pwd) directly since /bin/pwd doesn't handle mounted
# volumes very well on some systems. The /mnt/hgfs that enables host shares
# in a vmware client is one example of this.
#
export PROJDIR := $(shell $(SHELL) -c pwd)
PG_CONFIG = pg_config
export PGXS := $(shell $(PG_CONFIG) --pgxs)
export PGSQLSRC := $(dir $(PGXS))..
export top_builddir := $(PGSQLSRC)/..
export TARGETDIR := $(PROJDIR)/build
export OBJDIR := $(TARGETDIR)/objs
export JNIDIR := $(TARGETDIR)/jni
export CLASSDIR := $(TARGETDIR)/classes
export PLJAVA_MAJOR_VER := 1
export PLJAVA_MINOR_VER := 3
export PLJAVA_PATCH_VER := 1
export PLJAVA_VERSION := $(PLJAVA_MAJOR_VER).$(PLJAVA_MINOR_VER).$(PLJAVA_PATCH_VER)
export TAR := /bin/tar
OS := $(shell uname -s)
MACHINE := $(shell uname -m)
.PHONY: all clean docs javadoc source_tarball maven_bundle install uninstall depend release \
c_all c_install c_uninstall c_depend \
pljava_all pljava_javadoc \
deploy_all deploy_javadoc \
examples_all examples_javadoc \
test_all test_javadoc
all: pljava_all deploy_all c_all examples_all
install: c_install
uninstall: c_uninstall
depend: c_depend
docs:
@-mkdir -p $(TARGETDIR)
@find docs \( \
-name CVS \
-o -name .cvsignore \
\) -prune -o \( -type f -exec cp --parents {} $(TARGETDIR) \; \)
@cp COPYRIGHT $(TARGETDIR)/docs/COPYRIGHT.txt
javadoc: pljava_javadoc deploy_javadoc examples_javadoc
clean:
@-rm -rf $(TARGETDIR)
pljava_all pljava_javadoc: pljava_%:
@-mkdir -p $(CLASSDIR)/pljava
@$(MAKE) -r -C $(CLASSDIR)/pljava -f $(PROJDIR)/src/java/pljava/Makefile \
MODULEROOT=$(PROJDIR)/src/java $*
deploy_all deploy_javadoc: deploy_%:
@-mkdir -p $(CLASSDIR)/deploy
@$(MAKE) -r -C $(CLASSDIR)/deploy -f $(PROJDIR)/src/java/deploy/Makefile \
MODULEROOT=$(PROJDIR)/src/java $*
examples_all: examples_%: pljava_all
@-mkdir -p $(CLASSDIR)/examples
@$(MAKE) -r -C $(CLASSDIR)/examples -f $(PROJDIR)/src/java/examples/Makefile \
MODULEROOT=$(PROJDIR)/src/java $*
test_all: test_%:
@-mkdir -p $(CLASSDIR)/test
@$(MAKE) -r -C $(CLASSDIR)/test -f $(PROJDIR)/src/java/test/Makefile \
MODULEROOT=$(PROJDIR)/src/java $*
c_all c_install c_uninstall c_depend: c_%:
@-mkdir -p $(OBJDIR)
@$(MAKE) -r -C $(OBJDIR) -f $(PROJDIR)/src/C/pljava/Makefile \
MODULEROOT=$(PROJDIR)/src/C build_$*
source_tarball:
@-mkdir -p $(TARGETDIR)/distrib
@$(MAKE) -r -C $(TARGETDIR) -f $(PROJDIR)/packaging/Makefile $@
release: all docs javadoc
@-mkdir -p $(TARGETDIR)/distrib
@$(MAKE) -r -C $(TARGETDIR) -f $(PROJDIR)/packaging/Makefile $@
maven_bundle: pljava_all
@-mkdir -p $(TARGETDIR)/distrib
@$(MAKE) -r -C $(TARGETDIR) -f $(PROJDIR)/packaging/Makefile $@
pljava-20070604/COPYRIGHT 0000664 0000767 0000770 00000003225 10630554503 015305 0 ustar iwasakims iwasakims PL/Java, a backend Java integration for PostgreSQL
Java™ is a registered trademark of Sun Microsystems, Inc. in the United
States and other countries.
PL/Java Copyright (c) 2003 - 2006 Tada AB - Taby Sweden
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name Tada AB nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
pljava-20070604/docs/ 0000775 0000767 0000770 00000000000 10630554503 014740 5 ustar iwasakims iwasakims pljava-20070604/docs/intro.html 0000664 0000767 0000770 00000013040 10630554503 016757 0 ustar iwasakims iwasakims
PL/Java 1.1.0
|
| |
| The project is sponsored by: |
|
|
PL/Java 1.2.0 released
Bringing the power of Java™ to PostgreSQL™
Functions and Triggers.
Java™ is a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
PostgreSQL™ is a trademark of PostgreSQL Inc and Regents of the University of California.
PL/Java is an add on module to the PostgreSQL backend. It falls into the same
category as PL/SQL, PL/TCL, PL/Perl, PL/Python, and PL/R. When installed, functions
and triggers can be written in Java using your favorite Java IDE and installed
into the database.
|
The PL/Java 1.2.0
release of PL/Java provides the following features.
- Ability to write both functions and triggers using Java 1.4 or higher.
- Standardized utilities (modeled after the SQL 2003 proposal) to install and
maintain Java code in the database.
- Standardized mappings of parameters and result. Complex types as well as sets
are supported.
- An embedded, high performance, JDBC driver utilizing the internal PostgreSQL
SPI routines.
- Metadata support for the JDBC driver. Both DatabaseMetaData and ResultSetMetaData is included.
- The ability to return a ResultSet that origins from a query as an alternative to build a ResultSet row by row
- Full support for PostgreSQL 8.0 savepoints and exception handling.
- Ability to use IN, INOUT, and OUT parameters when used with PostgreSQL 8.1
- Two language handlers, one TRUSTED (the default) and one that is not TRUSTED (language tag is javaU to
conform with the defacto standard)
- Transaction and Savepoint listeners enabling code execution when a
transaction or savepoint is commited or rolled back.
- Integration with GNU GCJ on selected platforms.
PL/Java in brief
A function or trigger in SQL will appoint a static method in a Java class. In
order for the function to execute, the appointed class must be installed in the
database. PL/Java adds a set of functions that helps installing and maintaining the
java classes. Classes are stored in normal Java archives (AKA jars). A Jar may optionally
contain a deployment descriptor that in turn contains SQL commands to be executed
when the jar is deployed/undeployed. The functions are modeled after the standards
proposed for SQL 2003.
PL/Java implements a standardized way of passing parameters and return values.
Complex types and sets are passed using the standard JDBC ResultSet class. Great
care has been taken not to introduce any proprietary interfaces unless absolutely
necessary so that Java code written using PL/Java becomes as database agnostic as
possible.
A JDBC driver is included in PL/Java. This driver is written directly on top
of the PostgreSQL internal SPI routines. This driver is essential since it's very
common for functions and triggers to reuse the database. When they do, they must
use the same transactional boundaries that where used by the caller.
PL/Java is optimized for performance. The Java virtual machine executes within
the same process as the backend itself. This vouches for a very low call overhead.
PL/Java is designed with the objective to enable the power of Java to the database
itself so that database intensive business logic can execute as close to the actual
data as possible.
The standard Java Native Interface (JNI) is used when bridging calls from the
backend into the Java VM and vice versa. Please read the
rationale
behind the choice of technology and
a more
in-depth discussion about some implementation details. PL/Java is primarily targeted
to the new 8.1 version but will run with PostgreSQL 8.0 versions too albeit with
some limitations.
For info on how to get started, please read the
release
notes. A
user
guide contains more information on how to create and manage our Java functions
and triggers.
Source and selected binaries are available for download. See the
download
page for more details.
pljava-20070604/docs/userguide.html 0000664 0000767 0000770 00000073536 10630554503 017640 0 ustar iwasakims iwasakims
PL/Java 1.2 User Guide
PL/Java 1.2 User Guide
Java™ is a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
Table of contents
Utilities
Deployer
SQLJ functions
install_jar
replace_jar
remove_jar
get_classpath
set_classpath
Writing Java functions
Type mapping
Returning complex types
Functions returning sets
Using JDBC
Exception handling
Savepoints
Logging
Security
Installation
Trusted language
Execution of the deployment descriptor
Classpath manipulation
Module Configuration
When running the deployer, you must use a classpath that can see
the deploy.jar found in the PL/Java distribution and the postgresql.jar
from the PostgreSQL distribution. The former contains the code for the deployer
command and the second includes the PostgreSQL JDBC driver. You then run the
deployer with the command:
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.
Deployer options
| -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 sqlj procedures and loaded jars. |
| -user <user name> |
Name of user that connects to the database. Default is the 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 to use the user name. |
| -host <host name> |
Name of the host. Default is "localhost". |
| -port <port number> |
Port number. Default is blank. |
| -cygwin |
Use this option if the host runs on a Cygwin based windows platform. Affects
the name used for the PL/Java dynamic library. NOTE This option should not
be used when running native the Win32 port.
|
Deploying using SQL
An alternative to using the deployer is to run the install.sql and
uninstall.sql scripts that are included in the distribution.
The install_jar, replace_jar, and remove_jar
can act on a deployment descriptor allowing SQL commands to be executed after the
jar has been installed or prior to removal. The format of the deployment descriptor
is stipulated by ISO/IEC 9075-13:2003.
The descriptor is added as a normal text file to your jar file. In the Manifest
of the jar there must be an entry that appoints the file as the SQLJ deployment
descriptor.
Name: <deployment descriptor entry in the jar>SQLJDeploymentDescriptor: TRUE
The deployment descriptor must have the following form:
<descriptor file> ::=
SQLActions <left bracket> <rightbracket> <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 Sub clause 5.2, "<token> and <separator>", in ISO/IEC 9075-2.
If implementor blocks are used, PL/Java will consider only those with implementor
name PostgreSQL (case insensitive). Here is a small sample of a deployment descriptor:
SQLActions[] = {
"BEGIN INSTALL
CREATE FUNCTION javatest.java_getTimestamp()
RETURNS timestamp
AS 'org.postgresql.pljava.example.Parameters.getTimestamp'
LANGUAGE java;
END INSTALL",
"BEGIN REMOVE
DROP FUNCTION javatest.java_getTimestamp();
END REMOVE"
}
The install_jar command loads a jarfile from a location appointed
by an URL into the SQLJ jar repository. It is an error if a jar with the given name
already exists in the repository.
Usage
SELECT sqlj.install_jar(<jar_url>, <jar_name>, <deploy>);
Parameters
| 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 deployment descriptor,
false otherwise. |
The replace_jar will replace a loaded jar with another jar. Use
this command to update already loaded files. It's an error if the jar is not found.
Usage
SELECT sqlj.replace_jar(<jar_url>, <jar_name>, <redeploy>);
Parameters
| 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 jar should be undeployed according to the deployment descriptor
of the old jar and deployed according to the deployment descriptor of the new
jar, false otherwise. |
The remove_jar will drop the jar from the jar repository. Any classpath
that references this jar will be updated accordingly. It's an error if the jar is
not found.
Usage
SELECT sqlj.remove_jar(<jar_name>, <undeploy>);
Parameters
| jar_name |
The name of the jar to be removed. |
| undeploy |
True if the jar should be undeployed according to a deployment descriptor,
false otherwise. |
The get_classpath will return the classpath that has been defined
for the given schema or NULL if the schema has no classpath. It's an
error if the given schema does not exist.
Usage
SELECT sqlj.get_classpath(<schema>);
Parameters
| schema |
The name of the schema. |
The set_classpath will define a classpath for the given schema.
A classpath consists of a colon separated list of jar names. It's an error if the
given schema does not exist or if one or more jar names references non existent
jars.
Usage
SELECT sqlj.set_classpath(<schema>, <classpath>);
Parameters
| schema |
The name of the schema. |
| classpath |
The colon separated list of jar names. |
A Java function is declared with the name of a class and a static method on that
class. The class will be resolved using the classpath that has been defined for
the schema where the function is declared. If no classpath has been defined for
that schema, the "public" schema is used. If no classpath is found there either,
the class is resolved using the system classloader.
The following function can be declared to access the static method getProperty
on java.lang.System class:
CREATE FUNCTION getsysprop(VARCHAR)
RETURNS VARCHAR
AS 'java.lang.System.getProperty'
LANGUAGE java;
SELECT getsysprop('user.home');
Scalar types are mapped in a straight forward way. Here's a table of the current
mappings (will be updated as more mappings are implemented).
| PostgreSQL |
Java |
| bool |
boolean |
| 'char' |
byte |
| int2 |
short |
| int4 |
int |
| int8 |
long |
| float4 |
float |
| float8 |
double |
| varchar |
java.lang.String |
| text |
java.lang.String |
| bytea |
byte[] |
| date |
java.sql.Date |
| time |
java.sql.Time (stored value treated as local time) |
| timetz |
java.sql.Time |
| timestamp |
java.sql.Timestamp (stored value treated as local time) |
| timestamptz |
java.sql.Timestamp |
| complex |
java.sql.ResultSet |
| setof complex |
java.sql.ResultSet |
All other types are currently mapped to java.lang.String and will
utilize the standard textin/textout routines registered for respective
type.
NULL handling
The scalar types that map to Java primitives can not be passed as null
values. To enable this, those types can have an alternative mapping. You enable
this mapping by explicitly denoting it in the method reference.
CREATE FUNCTION trueIfEvenOrNull(integer)
RETURNS bool
AS 'foo.fee.Fum.trueIfEvenOrNull(java.lang.Integer)'
LANGUAGE java;
In java, you would have something like:
package foo.fee;
public class Fum
{
static boolean trueIfEvenOrNull(Integer value)
{
return (value == null)
? true
: (value.intValue() % 1) == 0;
}
}
The following two statements should both yield true:
SELECT trueIfEvenOrNull(NULL);
SELECT trueIfEvenOrNull(4);
In order to return null values from a Java method, you simply use
the object type that corresponds to the primitive (i.e. you return java.lang.Integer
instead of int). The PL/Java resolve mechanism will find the method
regardless. Since Java cannot have different return types for methods with the same
name, this does not introduce any ambiguity.
Complex types
A complex type will always be passed as a read-only java.sql.ResultSet
with exaclty one row. The ResultSet will be positioned on its row so no call to
next should be made. The values of the complex type are retrieved using the standard
getter methods of the ResultSet.
Example:
CREATE TYPE complexTest
AS(base integer, incbase integer, ctime timestamptz);
CREATE FUNCTION useComplexTest(complexTest)
RETURNS VARCHAR
AS 'foo.fee.Fum.useComplexTest'
IMMUTABLE LANGUAGE java;
In class Fum we add the static following static method:
public static String useComplexTest(ResultSet complexTest)
throws SQLException
{
int base = complexTest.getInt(1);
int incbase = complexTest.getInt(2);
Timestamp ctime = complexTest.getTimestamp(3);
return "Base = \"" + base +
"\", incbase = \"" + incbase +
"\", ctime = \"" + ctime + "\"";
}
Java does not stipulate any way to create a ResultSet from scratch. Hence, returning
a ResultSet is not an option. The SQL-2003 draft suggest that a complex return value
instead is handled as an IN/OUT parameter and PL/Java implements it that way. If
you declare a function that returns a complex type, you will need to use a Java
method with boolean return type with a last parameter of type java.sql.ResultSet.
The parameter will be initialized to an empty updateable ResultSet that contains
exactly one row.
Assume that we still have the complexTest type created above.
CREATE FUNCTION createComplexTest(int, int)
RETURNS complexTest
AS 'foo.fee.Fum.createComplexTest'
IMMUTABLE LANGUAGE java;
The PL/Java method resolve will now find the following method in the Fum class:
public static boolean complexReturn(int base, int increment, ResultSet receiver)
throws SQLException
{
receiver.updateInt(1, base);
receiver.updateInt(2, base + increment);
receiver.updateTimestamp(3, new Timestamp(System.currentTimeMillis()));
return true;
}
The return value denotes if the receiver should be considered as a valid tuple
(true) or NULL (false).
Returning sets is tricky. You don't want to first build a set and then return
it since large sets would eat too much resources. Its far better to produce one
row at a time. Incidentally, that's exactly what the PostgreSQL backend expects
a function with SETOF return to do. You can return a SETOF a scalar type such as
an int, float or varchar, or you can return a SETOF a complex type.
Returning a SETOF <scalar type>
In order to return a set of a scalar type, you need create a Java method that
returns something that implements the java.util.Iterator interface.
Here's an example of a method that returns a SETOF varchar:
CREATE FUNCTION javatest.getSystemProperties()
RETURNS SETOF varchar
AS 'foo.fee.Bar.getNames'
IMMUTABLE LANGUAGE java;
The very rudimentary java method that returns an interator:
package foo.fee;
import java.util.Iterator;
public class Bar
{
public static Iterator getNames()
{
ArrayList names = new ArrayList();
names.add("Lisa");
names.add("Bob");
names.add("Bill");
names.add("Sally");
return names.iterator();
}
}
Returning a SETOF <complex type>
A method returning a SETOF <complex type> must use either the interface org.postgresql.pljava.ResultSetProvider
or org.postgresql.pljava.ResultSetHandle.
The reason for having two interfaces is that they cater for optimal
handling of two distinct use cases. The former is great when you want to
dynamically create each row that is to be returned from the SETOF function. The
latter makes sense when you want to return the result of an executed query.
Using the ResultSetProvider interface
This interface has two methods. The boolean assignRowValues(java.sql.ResultSet tupleBuilder, int rowNumber)
and the void close() method. The PostgreSQL query evaluator will call the assignRowValues repeatedly
until it returns false or until the evaluator decides that it does not need any more rows. It will then call
close.
You can use this interface the following way:
CREATE FUNCTION javatest.listComplexTests(int, int)
RETURNS SETOF complexTest
AS 'foo.fee.Fum.listComplexTest'
IMMUTABLE LANGUAGE java;
The function maps to a static java method that returns an instance that implements the ResultSetProvider interface.
public class Fum implements ResultSetProvider
{
private final int m_base;
private final int m_increment;
public Fum(int base, int increment)
{
m_base = base;
m_increment = increment;
}
public boolean assignRowValues(ResultSet receiver, int currentRow)
throws SQLException
{
// Stop when we reach 12 rows.
//
if(currentRow >= 12)
return false;
receiver.updateInt(1, m_base);
receiver.updateInt(2, m_base + m_increment * currentRow);
receiver.updateTimestamp(3, new Timestamp(System.currentTimeMillis()));
return true;
}
public void close()
{
// Nothing needed in this example
}
public static ResultSetProvider listComplexTests(int base, int increment)
throws SQLException
{
return new Fum(base, increment);
}
}
The listComplextTests method is called once. It may return null
if no results are available or an instance of the ResultSetProvider. Here the Fum
implements this interface so it returns an instance of itself. The method assignRowValues
will then be called repeatedly until it returns false. At that time, close will be called
Using the ResultSetHandle interface
This interface is similar to the ResultSetProvider interface in that it has a
close() method that will be called at the end. But instead of having the
evaluator call a method that builds one row at a time, this method has a method
that returns a ResultSet. The query evaluator will iterate over this set
and deliver it's contents, one tuple at a time, to the caller until a call to
next() returns false or the evaluator decides that no more
rows are needed.
Here is an example that executes a query using a statement that it obtained using the
default connection. The SQL suitable for the deployment descriptor looks like this:
CREATE FUNCTION javatest.listSupers()
RETURNS SETOF pg_user
AS 'org.postgresql.pljava.example.Users.listSupers'
LANGUAGE java;
CREATE FUNCTION javatest.listNonSupers()
RETURNS SETOF pg_user
AS 'org.postgresql.pljava.example.Users.listNonSupers'
LANGUAGE java;
And in the Java package org.postgresql.pljava.example a class Users is added:
public class Users implements ResultSetHandle
{
private final String m_filter;
private Statement m_statement;
public Users(String filter)
{
m_filter = filter;
}
public ResultSet getResultSet()
throws SQLException
{
m_statement = DriverManager.getConnection("jdbc:default:connection").createStatement();
return m_statement.executeQuery("SELECT * FROM pg_user WHERE " + m_filter);
}
public void close()
throws SQLException
{
m_statement.close();
}
public static ResultSetHandle listSupers()
{
return new Users("usesuper = true");
}
public static ResultSetHandle listNonSupers()
{
return new Users("usesuper = false");
}
}
The method signature of a trigger is predefined. A trigger method must always
return void and have a org.postgresql.pljava.TriggerData parameter.
No more, no less. The TriggerData interface provides access to two ResultSet instances;
one representing the old row and one representing the new. The old row is read-only,
the new row is updateable.
The sets are only available for triggers that are fired ON EACH ROW.
Delete triggers have no new row, and insert triggers have no old row. Only update
triggers have both.
In addition to the sets, several boolean methods exists to gain more information
about the trigger. Here's an example trigger:
CREATE TABLE mdt (
id int4,
idesc text,
moddate timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL);
CREATE FUNCTION moddatetime()
RETURNS trigger
AS 'org.postgresql.pljava.example.Triggers.moddatetime'
LANGUAGE java";
CREATE TRIGGER mdt_moddatetime
BEFORE UPDATE ON mdt
FOR EACH ROW
EXECUTE PROCEDURE moddatetime (moddate);
The Java method in class org.postgresql.pljava.example.Triggers looks like this:
/**
* Update a modification time when the row is updated.
*/
static void moddatetime(TriggerData td)
throws SQLException
{
if(td.isFiredForStatement())
throw new TriggerException(td, "can't process STATEMENT events");
if(td.isFiredAfter())
throw new TriggerException(td, "must be fired before event");
if(!td.isFiredByUpdate())
throw new TriggerException(td, "can only process UPDATE events");
ResultSet _new = td.getNew();
String[] args = td.getArguments();
if(args.length != 1)
throw new TriggerException(td, "one argument was expected");
_new.updateTimestamp(args[0], new Timestamp(System.currentTimeMillis()));
}
PL/Java contains a JDBC driver that maps to the PostgreSQL SPI functions. A connection
that maps to the current transaction can be obtained using the following statement:
Connection conn = DriverManager.getConnection("jdbc:default:connection");
From there on, you can prepare and execute statements, just like with any other
JDBC connection. There are a couple of limitations though:
- The transaction cannot be managed in any way. Thus, you cannot use methods
on the connection like:
- commit()
- rollback()
- setAutoCommit()
- setTransactionIsolation()
- Savepoints are available but only if you use PostgreSQL 8.0 or later and with
some restrictions. A savepoint cannot outlive the function in which it was set
and it must also be rolled back or released by that same function.
- ResultSet's returned from executeQuery() are always FETCH_FORWARD and CONCUR_READ_ONLY.
- Meta-data is only available in PL/Java 1.1 or higher.
- CallableStatement (for stored procedures) is not yet implemented.
- Clob/Blob types need more work. byte[] and String works fine for bytea/text
respectively. A more efficient mapping is planned where the actual array is not
copied.
You can catch and handle an exception in the Postgres backend just like any
other exceptoin. The backend ErrorData structure is
exposed as a property in a class called
org.postgresql.pljava.ServerException (derived from
java.sql.SQLException) and the Java try/catch mechanism is
synchronized with the backend mechanism.
Important Note:
You will not be able to continue executing backend functions until your
function has returned and the error has been propagated when the backend has
generated an exception unless you have used a savepoint. When a savepoint is
rolled back, the exceptional condition is reset and you can continue your
execution.
PostgreSQL savepoints are exposed using the java.sql.Connection
interface. Two restrictions apply.
- A savepoint must be rolled back or released in the function where it was
set.
- A savepoint must not outlive the function where it was set
PL/Java uses the standard Java 1.4 Logger. Hence, you can write things like:
Logger.getAnonymousLogger().info( "Time is " + new Date(System.currentTimeMillis()));
At present, the logger is hardwired to a handler that maps the current state
of the PostgreSQL configuration setting log_min_messages to a valid Logger level
and that outputs all messages using the backend function elog(). The following
mapping apply between the Logger levels and the PostgreSQL backend levels.
| java.util.logging.Level |
PostgreSQL level |
| SEVERE |
ERROR |
| WARNING |
WARNING |
| INFO |
INFO |
| FINE |
DEBUG1 |
| FINER |
DEBUG2 |
| FINEST |
DEBUG3 |
Only a PostgreSQL super user can install PL/Java. The PL/Java utility functions
are installed using SECURITY DEFINER so that they execute with the
access permissions that where granted to the creator of the functions.
PL/Java is now a TRUSTED language. PostgreSQL stipulates that a language marked
as trusted has no access to the filesystem and PL/Java enforces this. Any user can
create and access functions or triggers in a trusted language. PL/Java also installs
a language handler for the language "javaU". This version is not trusted and only
a superuser can create new functions that use it. Any user can still call the functions.
The install_jar, replace_jar, and remove_jar,
optionally executes commands found in a SQL deployment descriptor. Such commands
are executed with the permissions of the caller. In other words, although the utility
function is declared with SECURITY DEFINER, it switches back to the
session user during execution of the deployment descriptor commands.
The function set_classpath requires the caller of the function has
been granted CREATE permission on the affected schema.
PL/Java makes use of PostgreSQL custom variable classes in the
postgresql.conf configuration file to add some configuration parameters.
PL/Java introduces a custom variable class named "pljava".
Here's a sample postgresql.conf entry using all (3) of the variables currently
introduced:
# define "pljava" as a custom variable class. This is a comma separated
# list of names.
#
custom_variable_classes = 'pljava'
# define the class path that the JVM will use when loading the
# initial library. Only meaningful for non GCJ installations
#
pljava.classpath = '/home/Tada/pljava/build/pljava.jar'
# Set the size of the prepared statement MRU cache
#
pljava.statement_cache_size = 10
# If true, lingering savepoints will be released on function exit. If false,
# the will be rolled back
#
pljava.release_lingering_savepoints = true
# Define startup options for the Java VM.
#
pljava.vmoptions = '-Xmx64M'
# Setting debug to true will cause the postgres process to go
# into a sleep(1) loop on its first call to java. This variable is
# only useful if you want to debug the PL/Java internal C code.
#
pljava.debug = false
pljava-20070604/docs/readme.html 0000664 0000767 0000770 00000022013 10630554503 017061 0 ustar iwasakims iwasakims
PL/Java readme
PL/Java, 1.2.x
Java™ is a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
A source tarball and four of binary builds can be found in the download area.
Two for Windows and two for i386 based Linux. Although all
pre-compiled binaries must run using a standard JVM, the PL/Java can also be
compiled and linked using GNU GCJ. PL/Java has no pre-compiled binaries for GCJ but the make system
contain what's needed to make the build easy.
Please note that all use of GCJ should be regarded as experimental. Due to limitations in
the
implementation of java.security in some versions of GCJ the PL/Java trusted
language implementation is, in fact, not trusted. At present this applies
regardless of what GCJ version since the code is conditionally compiled.
Prerequisites
- PostgreSQL >= 8.0.3
- PostgreSQL JDBC drivers (needed by the client Deployer program).
- A Java runtime >= Java 1.4 or GCJ >= 4.0.x (Linux only).
Get the binary distribution of PL/Java for your platform. Unzip it into a directory
of your own choice.
Postmaster configuration
Get the PostgreSQL environment up and running. You will need to modify the
postgresql.conf file. 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>'
Note that on the win32 platform 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
Add the following entry:
custom_variable_classes = 'pljava'
System classpath
Normally, all Java code is loaded into the database using the install_jar/replace_jar
SQL functions. Most of PL/Java (those functions included) is however implemented in Java.
Unless you use GCJ, where this Java code is compiled and linked with the pljava shared
object module, this hen and egg problem needs to be resolved using the system classpath.
Add the following entry to the
postgresql.conf file:
pljava.classpath = <pljava installation>/pljava.jar
Shared object issues
Unless you use GCJ, the postmaster must be made aware of the location
of the shared objects used by the Java Runtime Environment (JRE). Please note that this applies to the
postmaster, i.e. the backend process, and not to the client. The
client will not need these settings.
Linux/Unix
Setting the LD_LIBRARY_PATH environment will work on most Linux/Unix platforms:
export LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/i386:$JAVA_HOME/jre/lib/i386/client.
Apparently, on some Linux platforms you will also need to include $JAVA_HOME/jre/lib/i386/native_threads.
An alternative to use LD_LIBRARY_PATH is to edit the /etc/ld.so.conf
file and then use /sbin/ldconfig on some Linux/Unix systems.
zlib conflict
On some platforms there will be a conflict between the libzip.so included in the
JRE and the libz.so used by PostgreSQL (the JRE libzip.so includes a libz.so).
The symptom is an InternalError in the java.util.zip.Inflater.init when an attempt
is made to load the first class. You can verify the version of libzip.so
using the following command:
strings libzip.so | fgrep Copyright
The problem can be resolved in one of the following ways depending on your needs
and ability to recompile:
- Check if you can use a newer version of your JRE where the versions match. If so,
that's probably the best solution.
- Set the environment LD_PRELOAD in effect for the postmaster process to point to
the libzip.so present in the JRE. That will force the JRE version to be used. This
might break postgres own use of compression for the affected processes.
- Reconfigure PostgreSQL with
--without-zlib, recompile and reinstall.
This will effetively disable all compression support in PostgreSQL.
- Obtain a zlib version from somewhere that corresponds to the version used by the
JRE and relink your PostgreSQL executables with that version.
Windows
A standard install on a Windows box would be to add the following
entries to you PATH environment:
set PATH=%PATH%;%JAVA_HOME%\jre\bin;%JAVA_HOME%\jre\bin\client
You are now ready to start the postmaster.
Deploying the PL/Java
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. The deployment can be done in one of two ways. The simplest way
is probably to just execute the file install.sql as a super user (the
uninstall.sql will remove the PL/Java installation). PL/Java also comes with
deploy program that lets you install, reinstall, or uninstall PL/Java. This
program will assert that you indeed are a super user and then execute the
correct commands using jdbc. 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.Deployer
This will result in a list of options. Typically you would use something like:
java org.postgresql.pljava.deploy.Deployer -install
That's all there's to it. You are now ready to start using the PL/Java
system.
Run the example tests
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 examples.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/examples.jar', 'samples', true);
Please note that the deployment descriptor stored in examples.jar will attempt
to create the schema javatest so the user that executes the sqlj.install_jar
must have permission to do that. If this command succeeds, everything is working correctly. You may get a couple
of errors here though.
- A complaint that the class
org.postgresql.pljava.<something>
cannot be found.
The probable cause of this is that the CLASSPATH seen by the postmaster
is incorrect so that the pljava.jar is not found.
- A complaint that the libpljava.so or pljava.dll cannot be found. Probable
cause is that the
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.
NOTE: If you don't use schemas, you must still issue the set_classpath
command to assign a correct classpath to the 'public' schema. This can only be
done by a super user.
Now, you should be able to run the tests:
java org.postgresql.pljava.test.Tester
Building
Building should be very stright forward:
- No PosgreSQL source is needed.
Your path must be set to find the pg_config binary. The 'pgxs' concept in
PostgreSQL will take care of the rest.
- If you are using GCJ, you must supply USE_GCJ=1 to the make command.
- If you are using a normal Java VM, be sure to set the JAVA_HOME
environment variable.
pljava-20070604/docs/.cvsignore 0000664 0000767 0000770 00000000004 10630554503 016732 0 ustar iwasakims iwasakims api
pljava-20070604/docs/solutions.html 0000664 0000767 0000770 00000007506 10630554503 017675 0 ustar iwasakims iwasakims
Some problems and their solution
Some problems and their solution.
Java™ is a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
When writing the PL/Java, mapping the JVM into the same process-space as the
PostgreSQL backend code, some concerns have been raised regarding multiple
threads, exception handling, and memory management. Here is a brief text
explaining how these issues where resolved.
Multi threading.
Problem
Java is inherently multi threaded. The PostgreSQL backend is not. There’s
nothing stopping a developer from utilizing multiple Threads class in the Java
code. Finalizers that call out to the backend might have been spawned from a
background Garbage Collection thread. Several third party Java-packages that are
likely to be used make use of multiple threads. How can this model coexist with
the PostgreSQL backend in the same process without creating havoc?
Solution
The solution is simple. PL/Java defines a special object called the
Backend.THREADLOCK. When PL/Java is initialized, the backend will immediately
grab this objects monitor (i.e. it will synchronize on this object). When the
backend calls a Java function, the monitor is released and then
immediately regained when the call returns. All calls from Java out to backend
code are synchronized on the same lock. This ensures that only one thread at a
time can call the backend from Java, and only at a time when the backend is
awaiting the
return of a Java function call.
Exception handling
Problem
Java makes frequent use of try/catch/finally blocks. PostgreSQL sometimes use
an exception mechanism that calls longjmp to transfer control to a known state.
Such a jump would normally effectively bypass the JVM. Prior to PostgreSQL version 8.0,
the error was propagated before the actual jump and then discarded, thus there
was no way to catch and handle the error.
Solution
The backend now allows errors to be caught using the macros
PG_TRY/PG_CATCH/PG_END_TRY and in the catch block, the error can be
examined using the ErrorData structure.
PL/Java implements a java.sql.SQLException
subclass called
org.postgresql.pljava.ServerException. The ErrorData can be retrieved and
examined from that exception. A catch handler is allowed to issue a rollback to
a savepoint. After a successful rollback, execution can continue.
Java Garbage Collector versus palloc() and stack allocation.
Problem
Primitive types will be passed by value always. This includes the String type
(this is a must since Java uses double byte characters). Complex types are
however often wrapped in Java objects and passed by reference. I.e, a Java
object will contain a pointer to a palloc’ed or stack allocated memory and use native JNI calls to
extract and manipulate data. Such data will become “stale” once a call has
ended. Further attempts to access such data will at best give very unpredictable
results but more likely cause a memory fault and a crash.
Solution
The PL/Java contains code that ensures that stale pointers are cleared when
the MemoryContext or stack where they where allocated goes out of scope. The
Java wrapper objects might live on but any attempt to use them will result in a
“stale native handle” exception.
pljava-20070604/docs/jni_rationale.html 0000664 0000767 0000770 00000021634 10630554503 020452 0 ustar iwasakims iwasakims
Rationale behind using JNI as opposed to threads in a remote JVM process
Rationale behind using JNI as opposed to threads in a remote JVM process.
Java™ is a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
Reasons to use a high level language like Java™ in the backend
A large part of the reason why JNI was chosen in favor of an RPC based,
single JVM solution was due to the expected use-cases. Enterprise systems today are almost always
3-tier or n-tier. Database functions, triggers, and stored procedures are
mechanisms that extend the functionality of the backend tier. They typically
rely on a tight integration with the database due to a very high rate of
interactions and execute inside of the database largely to limit the number of
interactions between the middle tier and the backend tier. Some typical
use-cases:
- Referential integrity
enforcement. Using Java, referential integrity that goes beyond what can
be provided using the standard SQL semantics can be provided. It might
involve checking XML documents, enforcing some meta-driven rule system, or
other complex tasks that put high demands on the implementation language.
- Advanced pattern recognition.
Soundex, image comparison, etc.
- XML support functions. Java
comes with a lot of XML support. Parsers etc. are readily available.
- Support functions for O/R
mappers. A variety of support can be implemented depending on design. One
example is an O/R mapper that allows methods on persistent objects. A lot
can be gained if such methods are pushed down and executed within the
database. Consider the following (OQL):
SELECT AVG(x.salary - x.computeTax()) FROM Employee x WHERE x.salary > 120000;
Pushing the computeTax logic down to the database instead of
computing it in the middle tier (where much or the O/R logic resides) is a huge
gain from a performance standpoint. The statement could be transformed into SQL
as:
SELECT AVG(x.salary - computeTax(x.salary)) FROM Employee x WHERE x.salary > 120000;
As a result, very few interactions (typically only one) need
to be made between the middle and the backend tier.
- Views and indexes making use
of computed values. In the above example and index could be created on
computeTax(x.salary) and a view could express that as net_income.
- Message queue management.
Delivering or fetching things using message queues or other delivery
mechanisms. As with most interactions with other processes, this requires
transaction coordination of some kind.
One might argue that since a JVM often is present running an app-server in
the middle tier, would it not be more efficient if that JVM also executed the
database functions and triggers? In my opinion, this would be very bad. One
major reason for moving execution down to the database is performance (by
minimizing the number of roundtrips between the app-server and the database)
another is separation of concern. Referential data integrity and other ways to
extend the functionality of the database should not be the app-servers concern,
it belongs in the backend tier. Other aspects like database versus app-server
administration, replication of code and permission changes for functions, and
running different tiers on different servers, makes it even worse.
Resource consumption
Having one JVM per connection instead of one thread per connection running
in the same JVM will undoubtedly consume more resources. There are however a
couple of facts that must be remembered:
- The overhead of multiple
processes is already present due to the fact that each connection is a
process in a PostgreSQL system.
- In order to keep connections
separated in case they run in the same JVM, some kind of "compartments"
must be created. Either you create them using parallel class loader chains
(similar to how EAR files are managed in an EJB server) or you use a less
protective model similar to a servlet engine. In order to get a separation
that comparable to what you get using separate JVM's, you have to go for
the former. That consumes some resources.
- The JVM has undergone a
series of improvements in order to reduce footprint and startup time. Some
significant improvements where made in Java 1.4 and Java 1.5 introduces
Java Heap Self Tuning, Class Data Sharing, and Garbage Collector
Ergonomics (read more here),
technologies that will minimize the startup time and make the JVM adopt
its resource consumption in a much improved way.
- PL/Java can make use of the GCJ. Using this technology, all core
classes will be compiled into binaries and optionally pre-loaded by the
postmaster. It also means that all modules that are loaded using the
install_jar/replace_jar can be compiled into real shared objects. Finally,
it means that the footprint for each "JVM" will be significantly
decreased.
Connection pooling
In the Java community you are very likely to use a connection pool. The pool
will ensure that the number of connections stays as low as possible and that
connections are reused (instead of closed and reestablished). New JVMs are
started rarely.
Connection isolation
Separate JVMs gives you a much higher degree of isolation. This brings a
number of advantages:
- There's no problem attaching
a debugger to one connection (one JVM) while the others run unaffected.
- There's no chance that one
connection manages to accidentally (or maliciously) exchange dirty data
with another connection.
- A process that performs tasks
that consume a lot of CPU under a long period of time can be scheduled
with a lower priority using a simple OS command.
- The JVMs can be brought down
and restarted individually.
- Security policies are much
easier to enforce.
Transaction visibility
In order to maintain the correct visibility, the transaction must somehow be
propagated to the Java layer. I can see two solutions for this using RPC.
Either an XA aware JDBC-driver is used (requires XA support from PostgreSQL) or
a JDBC driver is written so that it calls back to the SPI functions in the
invoking process. Both choices results in an increased number of RPC calls and
a negative performance impact.
The PL/Java approach is to use the underlying SPI interfaces directly
through JNI by providing a "pseudo connection" that implements the
JDBC interfaces. The mapping is thus very direct. Data need never be serialized
nor duplicated.
RPC performance
Remote procedure calls are extremely expensive compared to in-process calls.
Relying on an RPC mechanism for Java calls will cripple the usefulness of such
an implementation a great deal. Here are two examples:
- In order for an update
trigger to function using RPC, you can choose one of two approaches.
Either you limit the number of RPC calls and send two full Tuples (old and
new) and a Tuple Descriptor to the remote JVM, and then pass a third Tuple
(the modified new) back to the original, or you pass those structures by
reference (as CORBA remote objects) and perform one RPC call each time you
access them. You have a tradeoff between on one hand, limited
functionality and poor performance, and on the other, good functionality
and really bad performance.
- When one or several Java
functions are used in the projection or filter of a SELECT statement on a
query processing several thousand rows, each row will cause at least one
call to Java. In case of RPC, this implies that the OS needs to do at
least two context switches (back and forth) for each row in the query.
Using JNI to directly access structures like TriggerData, Relation,
TupleDesc, and HeapTuple minimizes the amount of data that needs to be copied.
Parameters and return values that are primitives need not even become Java
objects. A 32-bit int4 Datum can be directly passed as a Java int (jint in
JNI).
Simplicity
I've have some experience of work involving CORBA and other RPCs. They add a
fair amount of complexity to the process. JNI however, is invisible to the
user.