The attached file: SerializePatch2.tgz, contains a patch for

org.postgresql.util.Serialize and org.postgresql.jdbc2.PreparedStatement
that  fixes the ability to "serialize" a simple java class into a
postgres table.

The current cvs seems completely broken in this support, so the patch
puts it  into working condition, granted that there are many limitations
with  serializing java classes into Postgres.

The code to do serialize appears to have been in the driver since
Postgres  6.4, according to some comments in the source.  My code is not
adding any  totally new ability to the driver, rather just fixing what
is there so that  it actually is usable.  I do not think that it should
affect any existing  functions of the driver that people regularly
depend on.

The code is activated if you use jdbc2.PreparedStatement and try to
setObject  some java class type that is unrecognized, like not String or
not some other  primitive type.  This will cause a sequence of function
calls that results in  an instance of Serialize being instantiated for
the class type passed.  The  Serialize constructor will query pg_class
to see if it can find an existing  table that matches the name of the
java class. If found, it will continue and  try to use the table to
store the object, otherwise an SQL exception is  thrown and no harm is
done.  Serialize.create() has to be used to setup the  table for a java
class before anything can really happen with this code other  than an
SQLException (unless by some freak chance a table exists that it  thinks
it can use).

I saw a difference in Serialize.java between 7.1.3 and 7.2devel that I
didn't  notice before, so I had to redo my changes from the 7.2devel
version (why I  had to resend this patch now).  I was missing the
fixString stuff, which is  nice and is imporant to ensure the inserts
will not fail due to embedded  single quote or unescaped backslashes. I
changed that fixString function in  Serialize just a little since there
is no need to muddle with escaping  newlines: only escaping single quote
and literal backslashes is needed.  Postgres appears to insert newlines
within strings without trouble.

src/interfaces/jdbc/org/postgresql/jdbc2/PreparedStatement.java

@@ -613,7 +613,8 @@ public class PreparedStatement extends Statement implements java.sql.PreparedSta
 		else if (x instanceof PGobject)
 			setString(parameterIndex, ((PGobject)x).getValue());
 		else
-			setLong(parameterIndex, connection.putObject(x));
+			// Try to store java object in database
+			setSerialize(parameterIndex, connection.putObject(x), x.getClass().getName() );
 	}
 
 	/**
@@ -674,6 +675,29 @@ public class PreparedStatement extends Statement implements java.sql.PreparedSta
 		inStrings[paramIndex - 1] = s;
 	}
 
+	/**
+	 * Set a parameter to a tablerow-type oid reference.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the oid of the object from org.postgresql.util.Serialize.store
+	 * @param classname the classname of the java object x
+	 * @exception SQLException if a database access error occurs
+	 */
+	private void setSerialize(int parameterIndex, long x, String classname) throws SQLException
+	{
+		// converts . to _, toLowerCase, and ensures length<32
+		String tablename = Serialize.toPostgreSQL( classname );
+		DriverManager.println("setSerialize: setting " + x + "::" + tablename );
+
+		// OID reference to tablerow-type must be cast like:  <oid>::<tablename>
+		// Note that postgres support for tablerow data types is incomplete/broken.
+		// This cannot be just a plain OID because then there would be ambiguity
+		// between when you want the oid itself and when you want the object
+		// an oid references.
+		set(parameterIndex, Long.toString(x) + "::" + tablename );
+	}
+
+
     // ** JDBC 2 Extensions **
 
     /**
@@ -803,3 +827,4 @@ public class PreparedStatement extends Statement implements java.sql.PreparedSta
     }
 
 }
+