enable binary transfer for PGgeometry and PGgeography.

Author: sebasbaumh

README.md

@@ -20,8 +20,9 @@ It is originally based on [postgis-java](https://github.com/postgis/postgis-java
 * Support for wrapped connections (like used in WildFly and c3p0 connection pooling)
 * Use generic Java types where possible and simplify/streamline API
 * Clean up code to basically only work on [WKB](https://en.wikipedia.org/wiki/Well-known_text#Well-known_binary)/EWKB implementations to reduce code duplication and focus on the actual database format
+* Support for binary transfer of geometry data (if enabled in PostgreSQL JDBC driver, see [PR#2556](https://github.com/pgjdbc/pgjdbc/pull/2556))
 * Support for the latest PostgreSQL and PostGIS versions
-    * Recommended are PostgreSQL 14 and PostGIS 3.2.0
+    * Recommended are PostgreSQL 14 and PostGIS 3.2.1
     * Supported are versions starting from PostgreSQL 9.6 and PostGIS 2.3
 * Support for JDK 11+ (there is an older [branch for JDK 8](https://github.com/sebasbaumh/postgis-java-ng/tree/jdk8))
 * The license is still LGPL
@@ -49,11 +50,11 @@ There is a Maven artifact in the official Maven repository, so just add this to
 <dependency>
 	<groupId>io.github.sebasbaumh</groupId>
 	<artifactId>postgis-java-ng</artifactId>
-	<version>22.2.0</version>
+	<version>22.3.0</version>
 </dependency>
 ```
 
-The version reflects the year of the release, e.g. `22.2.0` is a version released in 2022.
+The version reflects the year of the release, e.g. `22.3.0` is a version released in 2022.
 
 The API differs a bit from [postgis-java](https://github.com/postgis/postgis-java) with the main point being a different namespace (`io.github.sebasbaumh.postgis`) as publishing a project to Maven Central requires to own that namespace.
 In addition the class structure is a bit different (see below) to support arc geometries and reduce boilerplate code, but you should be able to adapt to it easily.

pom.xml

@@ -4,7 +4,7 @@
 	<groupId>io.github.sebasbaumh</groupId>
 	<artifactId>postgis-java-ng</artifactId>
 	<!-- version for release -->
-	<version>22.2.1-SNAPSHOT</version>
+	<version>22.3.0-SNAPSHOT</version>
 	<packaging>jar</packaging>
 
 	<name>PostGIS Java bindings</name>

src/main/java/io/github/sebasbaumh/postgis/DriverWrapper.java

@@ -27,8 +27,15 @@
 
 import java.lang.reflect.Method;
 import java.sql.Connection;
+import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.Properties;
+import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -39,6 +46,9 @@
 import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.postgresql.Driver;
 import org.postgresql.PGConnection;
+import org.postgresql.core.BaseConnection;
+import org.postgresql.core.Oid;
+import org.postgresql.core.QueryExecutor;
 
 /**
  * Wraps the PostGreSQL Driver to transparently add the PostGIS Object Classes. This avoids the need of explicit
@@ -99,6 +109,43 @@ public DriverWrapper()
 	{
 	}
 
+	/**
+	 * Tries to get a {@link QueryExecutor} from the given {@link Connection}, supports wrapped connections.
+	 * @param conn {@link Connection}
+	 * @return {@link QueryExecutor}
+	 * @throws SQLException if the {@link Connection} is no {@link BaseConnection}.
+	 */
+	private static QueryExecutor getQueryExecutor(Connection conn) throws SQLException
+	{
+		// try to get underlying PGConnection
+		PGConnection pgconn = tryUnwrap(conn);
+		// if instance is found, add the geometry types to the connection
+		if (pgconn instanceof BaseConnection)
+		{
+			return ((BaseConnection) pgconn).getQueryExecutor();
+		}
+		// try to unwrap connections coming from c3p0 connection pools
+		try
+		{
+			Class<?> clazzC3P0ProxyConnection = Class.forName("com.mchange.v2.c3p0.C3P0ProxyConnection");
+			if (clazzC3P0ProxyConnection.isInstance(conn))
+			{
+				// use method Object rawConnectionOperation(Method m, Object target, Object[] args)
+				Method mrawConnectionOperation = clazzC3P0ProxyConnection.getMethod("rawConnectionOperation",
+						Method.class, Object.class, Object[].class);
+				Method mAddDataType = BaseConnection.class.getMethod("getQueryExecutor");
+				return (QueryExecutor) mrawConnectionOperation.invoke(conn, mAddDataType, null, null);
+			}
+		}
+		catch (ReflectiveOperationException | SecurityException | IllegalArgumentException ex)
+		{
+			// ignore all errors here
+		}
+		// BaseConnection could not be found
+		throw new SQLException(
+				"Connection is neither an org.postgresql.core.BaseConnection, nor a Connection wrapped around an org.postgresql.core.BaseConnection.");
+	}
+
 	/**
 	 * Mangles the PostGIS URL to return the original PostGreSQL URL
 	 * @param url String containing the url to be "mangled"
@@ -202,6 +249,57 @@ public static void registerDataTypes(PGConnection pgconn) throws SQLException
 		pgconn.addDataType("\"public\".\"box3d\"", io.github.sebasbaumh.postgis.PGbox3d.class);
 	}
 
+	/**
+	 * Registers all datatypes for binary transfer on the given connection, supports wrapped connections.
+	 * <p>
+	 * NOTE: this is experimental and only necessary until PostgreSQL JDBC driver is able to register types for binary
+	 * transfer.
+	 * @param conn {@link Connection}
+	 * @throws SQLException if the {@link Connection} is no {@link BaseConnection}.
+	 */
+	// FIX: this is experimental and only necessary until PostgreSQL JDBC driver is able to register types for binary
+	// transfer
+	// see https://github.com/pgjdbc/pgjdbc/pull/2556
+	public static void registerDataTypesForBinaryTransfer(Connection conn) throws SQLException
+	{
+		// try to get query executor
+		QueryExecutor executor = getQueryExecutor(conn);
+		// collect oids of geometry types
+		ArrayList<Integer> geometryOids = new ArrayList<Integer>();
+		try (Statement st = conn.createStatement())
+		{
+			try (ResultSet rs = st
+					.executeQuery("SELECT oid,typname FROM pg_type WHERE typname IN ('geometry','geography')"))
+			{
+				while (rs.next())
+				{
+					geometryOids.add(rs.getInt(1));
+				}
+			}
+		}
+
+		// this is kind of a hack as it currently is not possible to get already enabled oids from the connection get
+		// base oids like in PgConnection
+		Collection<Integer> supportedBinaryOids = Arrays.asList(Oid.BYTEA, Oid.INT2, Oid.INT4, Oid.INT8, Oid.FLOAT4,
+				Oid.FLOAT8, Oid.NUMERIC, Oid.TIME, Oid.DATE, Oid.TIMETZ, Oid.TIMESTAMP, Oid.TIMESTAMPTZ,
+				Oid.BYTEA_ARRAY, Oid.INT2_ARRAY, Oid.INT4_ARRAY, Oid.INT8_ARRAY, Oid.OID_ARRAY, Oid.FLOAT4_ARRAY,
+				Oid.FLOAT8_ARRAY, Oid.VARCHAR_ARRAY, Oid.TEXT_ARRAY, Oid.POINT, Oid.BOX, Oid.UUID);
+		Set<Integer> receiveOids = new HashSet<Integer>(supportedBinaryOids);
+		Set<Integer> sendOids = new HashSet<Integer>(supportedBinaryOids);
+		// do the same as the original PostgreSQL JDBC driver
+		sendOids.remove(Oid.DATE);
+
+		// add geometry oids
+		receiveOids.addAll(geometryOids);
+		sendOids.addAll(geometryOids);
+
+		// finally set oids
+		// TODO: this replaces the already set oids and should be changed later (when additional API functions are
+		// merged to pgjdbc)
+		executor.setBinaryReceiveOids(receiveOids);
+		executor.setBinarySendOids(sendOids);
+	}
+
 	/**
 	 * Tries to turn the given {@link Connection} into a {@link PGConnection}, supports wrapped connections and
 	 * JBoss/WildFly WrappedConnections.

src/main/java/io/github/sebasbaumh/postgis/PGgeometrybase.java

@@ -30,6 +30,7 @@
 
 import org.eclipse.jdt.annotation.DefaultLocation;
 import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.postgresql.util.PGBinaryObject;
 import org.postgresql.util.PGobject;
 
 import io.github.sebasbaumh.postgis.binary.BinaryParser;
@@ -41,13 +42,23 @@
  * @author Phillip Ross
  */
 @NonNullByDefault({ DefaultLocation.PARAMETER, DefaultLocation.RETURN_TYPE })
-public abstract class PGgeometrybase extends PGobject
+public abstract class PGgeometrybase extends PGobject implements PGBinaryObject
 {
 	/* JDK 1.5 Serialization */
 	private static final long serialVersionUID = 0x100;
 
+	/**
+	 * Underlying geometry.
+	 */
+	@Nullable
 	protected Geometry geometry;
 
+	/**
+	 * Geometry data as bytes.
+	 */
+	@Nullable
+	private byte[] geometryData;
+
 	/**
 	 * Constructs an instance.
 	 * @param type type of this {@link PGobject}
@@ -98,19 +109,49 @@ public boolean equals(@Nullable Object obj)
 		return Objects.equals(this.geometry, other.geometry);
 	}
 
+	/**
+	 * Gets the binary value.
+	 * @return binary value on success, else null
+	 */
+	@Nullable
+	private byte[] getBinaryValue()
+	{
+		// short cut
+		if (this.geometryData != null)
+		{
+			return this.geometryData;
+		}
+		// check if geometry is there
+		if (this.geometry != null)
+		{
+			// build geometry data and remember it
+			byte[] data = BinaryWriter.writeBinary(geometry);
+			this.geometryData = data;
+			return data;
+		}
+		// no geometry
+		return null;
+	}
+
 	/**
 	 * Gets the underlying {@link Geometry}.
-	 * @return {@link Geometry}
+	 * @return {@link Geometry} on success, else null
 	 */
+	@Nullable
 	public Geometry getGeometry()
 	{
 		return geometry;
 	}
 
+	@Nullable
 	@Override
 	public String getValue()
 	{
-		return BinaryWriter.writeHexed(geometry);
+		if (geometry != null)
+		{
+			return BinaryWriter.writeHexed(geometry);
+		}
+		return null;
 	}
 
 	@Override
@@ -119,25 +160,72 @@ public int hashCode()
 		return Objects.hashCode(geometry);
 	}
 
+	@Override
+	public int lengthInBytes()
+	{
+		byte[] data = getBinaryValue();
+		if (data != null)
+		{
+			return data.length;
+		}
+		// no geometry
+		return 0;
+	}
+
+	@Override
+	public void setByteValue(@SuppressWarnings("null") byte[] value, int offset) throws SQLException
+	{
+		// parse the given bytes
+		this.geometry = BinaryParser.parse(value, offset);
+	}
+
 	/**
 	 * Sets the underlying {@link Geometry}.
-	 * @param newgeom {@link Geometry}
+	 * @param newgeom {@link Geometry} (can be null)
 	 */
-	public void setGeometry(Geometry newgeom)
+	public void setGeometry(@Nullable Geometry newgeom)
 	{
 		this.geometry = newgeom;
+		// reset binary data
+		this.geometryData = null;
 	}
 
 	@Override
 	public void setValue(@SuppressWarnings("null") @Nonnull String value) throws SQLException
 	{
-		geometry = BinaryParser.parse(value);
+		this.geometry = BinaryParser.parse(value);
+		// reset binary data
+		this.geometryData = null;
+	}
+
+	@Override
+	public void toBytes(@SuppressWarnings("null") byte[] bytes, int offset)
+	{
+		byte[] data = getBinaryValue();
+		if (data != null)
+		{
+			// make sure array is large enough
+			if ((bytes.length - offset) <= data.length)
+			{
+				// copy data
+				System.arraycopy(data, 0, bytes, offset, data.length);
+			}
+			else
+			{
+				throw new IllegalArgumentException(
+						"byte array is too small, expected: " + data.length + " got: " + (bytes.length - offset));
+			}
+		}
+		else
+		{
+			throw new IllegalStateException("no geometry has been set");
+		}
 	}
 
 	@Override
 	public String toString()
 	{
-		return geometry.toString();
+		return String.valueOf(geometry);
 	}
 
 }

src/main/java/io/github/sebasbaumh/postgis/binary/BinaryParser.java

@@ -60,6 +60,18 @@ private BinaryParser()
 	{
 	}
 
+	/**
+	 * Parse a hex encoded geometry
+	 * @param value byte array containing the data to be parsed
+	 * @param offset offset
+	 * @return resulting geometry for the parsed data
+	 * @throws IllegalArgumentException if a contained geometry is of the wrong type or the encoding type is unknown
+	 */
+	public static Geometry parse(byte[] value, int offset)
+	{
+		return parseGeometry(new BinaryValueGetter(value, offset));
+	}
+
 	/**
 	 * Parse a hex encoded geometry
 	 * @param value String containing the data to be parsed
@@ -68,7 +80,7 @@ private BinaryParser()
 	 */
 	public static Geometry parse(String value)
 	{
-		return parseGeometry(new ValueGetter(value));
+		return parseGeometry(new StringValueGetter(value));
 	}
 
 	/**