Hi,
There have been multiple discussions about new custom type
implementations on this list, and the necessary extensions that are
needed to allow binary transfer.
I just implemented the raw skeleton of my current idea how such thing
may work. It is based on what I remember from earlier.
The basic idea is that primitive types, Strings and byte[] are handled
by the driver directly, and all other built-in datatypes (e. G.
BigDecimal or Timestamp) as well as extension datatypes are handled by
this new model.
As it may make sense to call getInt on a BigDecimal, for reading all
methods are present, they are meant to be called 1:1 by the underlying
ResultSet. For writing, this is different, and everything can be handled
by a single setObject() method. I'm not really shure about which of the
given variants is the best one, so I included some of them.
It allows having different handlers for reading and writing, as well as
it allows a single handler to handle several sql and java types. It can
be made backwards compatible by including a TypeTextReader/
TypeTextWriter implementation that handles all PGobject subclasses.
This code is just a rough skeleton for my idea. I would like to get your
feedback what you think about it before I put too much effort into this.
Open issues are:
- What do you think about SUNs jdbc type map approach? I personally
think that, unfortunately, this is not flexible enough.
- How do we handle endianness? PostGIS canonical binary representation
includes endian information, but what about the other types?
- Handling of NULL values. I currently assume that the TypeDrivers are
not used for NULL values, because they can be handled in a type
independend manner by the driver itsself.
Markus
--
markus schaber | dipl. informatiker
logi-track ag | rennweg 14-16 | ch 8001 zürich
phone +41-43-888 62 52 | fax +41-43-888 62 53
mailto:schabios@logi-track.com | www.logi-track.com
/* TypeBinaryWriter.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.Calendar;
public interface TypeBinaryReader extends TypeDriver {
String getString(byte[] data, int start, int length) throws SQLException;
boolean getBoolean(byte[] data, int start, int length) throws SQLException;
byte getByte(byte[] data, int start, int length) throws SQLException;
short getShort(byte[] data, int start, int length) throws SQLException;
int getInt(byte[] data, int start, int length) throws SQLException;
long getLong(byte[] data, int start, int length) throws SQLException;
float getFloat(byte[] data, int start, int length) throws SQLException;
double getDouble(byte[] data, int start, int length) throws SQLException;
BigDecimal getBigDecimal(byte[] data, int start, int length) throws SQLException;
byte[] getBytes(byte[] data, int start, int length) throws SQLException;
java.sql.Date getDate(byte[] data, int start, int length) throws SQLException;
java.sql.Date getDate(byte[] data, int start, int length, Calendar cal) throws SQLException;
java.sql.Time getTime(byte[] data, int start, int length) throws SQLException;
java.sql.Time getTime(byte[] data, int start, int length, Calendar cal) throws SQLException;
java.sql.Timestamp getTimestamp(byte[] data, int start, int length) throws SQLException;
java.sql.Timestamp getTimestamp(byte[] data, int start, int length, Calendar cal) throws SQLException;
java.io.InputStream getAsciiStream(byte[] data, int start, int length) throws SQLException;
java.io.InputStream getUnicodeStream(byte[] data, int start, int length) throws SQLException;
java.io.InputStream getBinaryStream(byte[] data, int start, int length) throws SQLException;
Object getObject(byte[] data, int start, int length) throws SQLException;
java.io.Reader getCharacterStream(byte[] data, int start, int length) throws SQLException;
java.net.URL getURL(byte[] data, int start, int length) throws SQLException;
}
/*
* TypeBinaryWriter.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.SQLException;
public interface TypeBinaryWriter extends TypeDriver {
/**
* Return the length of an encoded object in bytes.
*
* This method can calculate the length on actual data. You can call it with
* any object the driver accepts via set* methods.
*
* @return the lenght in bytes, -1 for unknown.
* @throws SQLException if the driver does not know to handle the object or
* something else goes wrong.
*/
int objectBytesLength(Object data) throws SQLException;
/** Render the object into the SQL binary representation */
void renderObject(Object data, byte[] target, int startindex);
/**
* Render the object into the SQL binary representation
*/
void renderObject(Object data, OutputStream outstream) throws SQLException, IOException;
}
/*
* TypeDriver.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import org.postgresql.PGConnection;
import java.sql.SQLException;
public interface TypeDriver {
/**
* Return all classes that are known to be supported at compile-time.
*/
public Class[] getSupportedClasses();
/** Return all sql types that are known to be supported. */
public String[] getSupportedTypes();
/** Test whether we support the SQL type. */
public boolean supports(String type);
/**
* Test whether we support the following class.
*
* This must return true for all classes that are in getSupportedClasses. It
* is also allowed to return true for other classes it knows to write, for
* example third-party subclasses that are not known at compile time.
*/
public boolean supports(Class klass);
/** Which SQL type do we produce for this object
* Note that this mapping is not 1:1, a single SQL type may correspond
* to a cuple of java types.
*/
public String objectType(Object data) throws SQLException;
/** Do we support creation of binary representation?
* @returns true on instances of TypeBinaryWriter
*/
public boolean supportsBinaryWrite();
/** Do we support creation of text representation?
* @returns true on instances of TypeTextWriter
*/
public boolean supportsTextWrite();
/** Do we support parsing of binary representation?
* @returns true on instances of TypeBinaryReader
*/
public boolean supportsBinaryReading();
/** Do we support parsing of text representation?
* @returns true on instances of TypeTextReader
*/
public boolean supportsTextReading();
/**
* Initialize the TypeDriver for a new connection.
*
* This method may do read-only queries on the database. It allows the
* driver to make adoptions for different protocols, server versions or
* installed data types. An example for this is PostGIS, where older
* versions do not support binary representation on the server side.
*
* XXX: Should we only use java.sql.Connection here?
*
* @returns the TypeDriver instance, which may be the same as the input
* parameter if no adoption is made.
*/
public TypeDriver forConnection(PGConnection conn) throws SQLException;
}
/*
* TypeMap.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import org.postgresql.PGConnection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
public class TypeMap {
protected HashMap byType = new HashMap();
protected HashMap byClass = new HashMap();
protected ArrayList drivers = new ArrayList();
/**
* Search the driver for a given SQL type
*
* @returns the driver, null if none is found
*/
public TypeDriver getDriverForType(String type) {
return (TypeDriver) byType.get(type);
}
/**
* Search the driver for a given java object
*
* @returns the driver, null if none is found
*/
public TypeDriver getDriverForObject(Object obj) {
Class klass = obj.getClass();
return getDriverForClass(klass);
}
/**
* Search the driver for a given java class
*
* @returns the driver, null if none is found
*/
private TypeDriver getDriverForClass(Class klass) {
TypeDriver d = (TypeDriver) byClass.get(klass);
if (d == null) {
for (int i = 0; i < drivers.size(); i++) {
TypeDriver drv = (TypeDriver) drivers.get(i);
if (drv.supports(klass)) {
d = drv;
break;
}
}
if (d != null) { // cache the search result
byClass.put(klass, d);
}
}
return d;
}
/** Register a new driver */
public void addDriver(TypeDriver drv) {
Class[] classes = drv.getSupportedClasses();
for (int i = 0; i < classes.length; i++) {
byClass.put(classes[i], drv);
}
String[] types = drv.getSupportedTypes();
for (int i = 0; i < types.length; i++) {
byType.put(types[i], drv);
}
drivers.add(drv);
}
/**
* Clones the TypeDriver for a new connection.
*
* This is e. G. used by the driver to get connection specific instances
* from the default TypeDriver, and by Connection.setCatalog() to re-init
* the typemap on a database change.
*
* This method may do read-only queries on the database, as it calls
* TypeDriver.forConnection() for each known driver.
*
* XXX: Should we only use java.sql.Connection here?
*
* @returns the TypeDriver instance
*/
public TypeMap forConnection(PGConnection conn) throws SQLException {
TypeMap result = new TypeMap();
for (int i = 0; i < drivers.size(); i++) {
TypeDriver drv = (TypeDriver) drivers.get(i);
TypeDriver newdrv = drv.forConnection(conn);
result.addDriver(newdrv);
}
return result;
}
}
/* TypeBinaryWriter.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.Calendar;
public interface TypeTextReader extends TypeDriver {
String getString(String data) throws SQLException;
boolean getBoolean(String data) throws SQLException;
byte getByte(String data) throws SQLException;
short getShort(String data) throws SQLException;
int getInt(String data) throws SQLException;
long getLong(String data) throws SQLException;
float getFloat(String data) throws SQLException;
double getDouble(String data) throws SQLException;
BigDecimal getBigDecimal(String data) throws SQLException;
byte[] getBytes(String data) throws SQLException;
java.sql.Date getDate(String data) throws SQLException;
java.sql.Date getDate(String data, Calendar cal) throws SQLException;
java.sql.Time getTime(String data) throws SQLException;
java.sql.Time getTime(String data, Calendar cal) throws SQLException;
java.sql.Timestamp getTimestamp(String data) throws SQLException;
java.sql.Timestamp getTimestamp(String data, Calendar cal) throws SQLException;
java.io.InputStream getAsciiStream(String data) throws SQLException;
java.io.InputStream getUnicodeStream(String data) throws SQLException;
java.io.InputStream getBinaryStream(String data) throws SQLException;
Object getObject(String data) throws SQLException;
java.io.Reader getCharacterStream(String data) throws SQLException;
java.net.URL getURL(String data) throws SQLException;
}
/*
* TypeBinaryWriter.java
*
* (C) 28.02.2005 Markus Schaber, Logi-Track ag, CH 8001 Zuerich
*
* $Id: $
*/
package org.postgresql.types;
import java.io.IOException;
import java.io.Writer;
import java.sql.SQLException;
public interface TypeTextWriter extends TypeDriver {
/**
* Return the length of an encoded object in characters.
*
* This method can calculate the length on actual data. You can call it with
* any object the driver accepts via set* methods.
*
* @return the lenght in bytes, -1 for unknown.
* @throws SQLException if the driver does not know to handle the object or
* something else goes wrong.
*/
int objectCharLength(Object data) throws SQLException;
/** Render the object into the SQL text representation */
String renderObject(Object data);
/** Render the object into the SQL text representation */
void renderObject(Object data, StringBuffer sb);
/** Render the object into the SQL text representation */
void renderObject(Object data, char[] target, int startindex);
/** Render the object into the SQL text representation
* @throws IOException */
void renderObject(Object data, Writer target) throws IOException;
}
