Add ListQueryMapper and various InList implementations to assist with sql-in-type queries

beehive-jdbc-mapper/genQueryMapper.sh

@@ -59,6 +59,7 @@ finishFile "src/main/java/com/moparisthebest/jdbc/ResultSetMapper.java"
 query="$(prepareFile "src/main/java/com/moparisthebest/jdbc/QueryMapper.java")"
 caching_query="$(prepareFile "src/main/java/com/moparisthebest/jdbc/CachingQueryMapper.java")"
 null_query="$(prepareFile "src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java")"
+list_query="$(prepareFile "src/main/java/com/moparisthebest/jdbc/ListQueryMapper.java")"
 
 cat src/main/java/com/moparisthebest/jdbc/ResultSetMapper.java | grep public | grep '(ResultSet rs' | egrep -v '(int arrayMaxLength|Calendar cal)' | while read method
 do
@@ -110,8 +111,23 @@ EOF
 
 EOF
     done >> "$null_query"
+
+    # ListQueryMapper.java
+    cat >> "$list_query" <<EOF
+	@Override
+	$(echo $method | sed -e 's/ResultSet rs/PreparedStatement ps/' -e 's/) {/, final Object... bindObjects) throws SQLException {/')
+		return delegate.$method_name$(echo $method | sed -e 's/^.*(//' -e 's/final //g' -e 's/, [^ ]* /, /g' -e 's/ResultSet rs/ps/' -e 's/) {/, bindObjects);/')
+	}
+
+	@Override
+	$(echo $method | sed -e 's/ResultSet rs/String sql/' -e 's/) {/, final Object... bindObjects) throws SQLException {/')
+		return delegate.$method_name$(echo $method | sed -e 's/^.*(//' -e 's/final //g' -e 's/, [^ ]* /, /g' -e 's/ResultSet rs/prepareSql(sql, bindObjects)/' -e 's/) {/, bindObjects);/')
+	}
+
+EOF
 done
 
 finishFile "src/main/java/com/moparisthebest/jdbc/QueryMapper.java"
 finishFile "src/main/java/com/moparisthebest/jdbc/CachingQueryMapper.java"
 finishFile "src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java"
+finishFile "src/main/java/com/moparisthebest/jdbc/ListQueryMapper.java"

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/ArrayInList.java

@@ -0,0 +1,52 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.Array;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Collection;
+
+/**
+ * Created by mopar on 4/29/15.
+ */
+public class ArrayInList implements InList {
+
+	private static final InList instance = new ArrayInList();
+
+	public static InList instance() {
+		return instance;
+	}
+
+	protected ArrayInList() {
+	}
+
+	protected String columnAppend() {
+		return " = ANY(?)";
+	}
+
+	protected <T> Array toArray(final Connection conn, final Collection<T> values) throws SQLException {
+		return conn.createArrayOf(
+				values.iterator().next() instanceof Number ? "number" : "text",
+				values.toArray()
+		);
+	}
+
+	public <T> InListObject inList(final Connection conn, final String columnName, final Collection<T> values) throws SQLException {
+		return values == null || values.isEmpty() ? InListObject.empty : new ArrayListObject(
+				columnName + columnAppend(),
+				toArray(conn, values)
+		);
+	}
+
+	class ArrayListObject extends InListObject {
+		private final Array array;
+
+		public ArrayListObject(final String sql, final Array array) {
+			super(sql);
+			this.array = array;
+		}
+
+		public Array getArray() {
+			return array;
+		}
+	}
+}

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/BindInList.java

@@ -0,0 +1,92 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.Connection;
+import java.util.*;
+
+/**
+ * Created by mopar on 4/29/15.
+ */
+public class BindInList implements InList {
+
+	private static final int defaultMaxSize = Integer.parseInt(System.getProperty("QueryMapper.BindInList.defaultMaxSize", "999"));
+
+	private static final InList instance = new BindInList();
+
+	public static InList instance() {
+		return instance;
+	}
+
+	private final int maxSize;
+
+	public BindInList(final int maxSize) {
+		this.maxSize = maxSize;
+	}
+
+	protected BindInList() {
+		this(defaultMaxSize);
+	}
+
+	private static <T> List<List<T>> split(final List<T> list, final int maxLength) {
+		final int listSize = list.size();
+		final List<List<T>> ret = new ArrayList<List<T>>();
+		if (listSize < maxLength)
+			ret.add(list);
+		else
+			for (int fromIndex = 0, toIndex = maxLength; fromIndex < listSize; fromIndex = toIndex, toIndex += maxLength)
+				ret.add(list.subList(fromIndex, toIndex > listSize ? listSize : toIndex));
+		return ret;
+	}
+
+	private <T> String toInList(final String fieldName, final Collection<T> items) {
+		final StringBuilder sb = new StringBuilder("(");
+
+		// do it quick if it will fit in one in-list
+		if (items.size() < maxSize) // 999 or less
+			return buildInList(items, sb, fieldName).append(")").toString();
+
+		// else we need to split lists
+		boolean notFirst = false;
+		for (final List<T> item : split(new ArrayList<T>(items), maxSize)) {
+			if (notFirst) sb.append(" OR ");
+			else notFirst = true;
+			buildInList(item, sb, fieldName);
+		}
+
+		return sb.append(")").toString();
+	}
+
+	private static <T> StringBuilder buildInList(Iterable<T> list, StringBuilder sb, String fieldName) {
+		return oracleCommaSeparatedList(list, sb.append(fieldName).append(" IN (")).append(")");
+	}
+
+	private static <T> StringBuilder oracleCommaSeparatedList(Iterable<T> list, StringBuilder sb) {
+		boolean notFirst = false;
+		for (final T obj : list) {
+			// DO NOT DO THIS ANYMORE: if (obj == null) continue;
+			if (notFirst) sb.append(',');
+			else notFirst = true;
+			sb.append('?');
+		}
+		return sb;
+	}
+
+	public <T> InListObject inList(final Connection conn, final String columnName, final Collection<T> values) {
+		return values == null || values.isEmpty() ? InListObject.empty : new BindInListObject(
+				toInList(columnName, values),
+				values.toArray()
+		);
+	}
+
+	class BindInListObject extends InListObject {
+		private final Object[] bindObjects;
+
+		public BindInListObject(final String sql, final Object[] bindObjects) {
+			super(sql);
+			this.bindObjects = bindObjects;
+		}
+
+		public Object[] getBindObjects() {
+			return bindObjects;
+		}
+	}
+}

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/InList.java

@@ -0,0 +1,35 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Collection;
+
+/**
+ * For a column name and a Collection, return a Object usable by QueryMapper for binding to a PreparedStatement and
+ * ListQueryMapper for substituting in the query
+ */
+public interface InList {
+
+	/**
+	 * Returns an Object who's .toString returns a String for a query, and QueryMapper knows how to bind to a PreparedStatement
+	 * @param columnName Column name for query
+	 * @param values values for in list
+	 * @return object
+	 */
+	public <T> InListObject inList(final Connection conn, final String columnName, final Collection<T> values) throws SQLException;
+
+	class InListObject {
+		static final InListObject empty = new InListObject("(0=1)");
+
+		private final String sql;
+
+		public InListObject(final String sql) {
+			this.sql = sql;
+		}
+
+		@Override
+		public final String toString() {
+			return sql;
+		}
+	}
+}

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/ListQueryMapper.java

@@ -0,0 +1,554 @@
+package com.moparisthebest.jdbc;
+
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.*;
+
+public class ListQueryMapper extends QueryMapper {
+
+	private static final InList defaultInList;
+
+	static {
+		InList def = null;
+		try {
+			final Class<?> ensureContext = Class.forName(System.getProperty("QueryMapper.defaultInList.class", "com.moparisthebest.jdbc.BindInList"));
+			final Method method = ensureContext.getMethod(System.getProperty("QueryMapper.defaultInList.method", "instance"));
+			def = (InList) method.invoke(null);
+		} catch (Throwable e) {
+			// NEVER ignore
+			throw new RuntimeException(e);
+		}
+		defaultInList = def;
+	}
+
+	protected final QueryMapper delegate;
+	protected final InList inList;
+
+	private static final String inListReplace = "{inList}";
+
+	private ListQueryMapper(Connection conn, String jndiName, QueryMapper delegate, ResultSetMapper cm, InList inList) {
+		this.inList = inList;
+		this.delegate = delegate == null ? new QueryMapper(conn, jndiName, cm) :
+				(delegate instanceof ListQueryMapper ? ((ListQueryMapper)delegate).delegate : delegate);
+	}
+
+	public ListQueryMapper(QueryMapper delegate, InList inList) {
+		this(null, null, delegate, null, inList);
+	}
+
+	public ListQueryMapper(QueryMapper delegate) {
+		this(null, null, delegate, null, defaultInList);
+	}
+
+	public ListQueryMapper(Connection conn, InList inList) {
+		this(conn, null, null, null, inList);
+	}
+
+	public ListQueryMapper(Connection conn, ResultSetMapper cm, InList inList) {
+		this(conn, null, null, cm, inList);
+	}
+
+	public ListQueryMapper(Connection conn) {
+		this(conn, defaultInList);
+	}
+
+	public ListQueryMapper(Connection conn, ResultSetMapper cm) {
+		this(conn, cm, defaultInList);
+	}
+
+	public ListQueryMapper(String jndiName, InList inList) {
+		this(null, jndiName, null, null, inList);
+	}
+
+	public ListQueryMapper(String jndiName, ResultSetMapper cm, InList inList) {
+		this(null, jndiName, null, cm, inList);
+	}
+
+	public ListQueryMapper(String jndiName) {
+		this(jndiName, defaultInList);
+	}
+
+	public ListQueryMapper(String jndiName, ResultSetMapper cm) {
+		this(jndiName, cm, defaultInList);
+	}
+
+	public static ListQueryMapper wrap(final QueryMapper qm){
+		return qm instanceof ListQueryMapper ? (ListQueryMapper)qm : new ListQueryMapper(qm);
+	}
+
+	public static ListQueryMapper wrap(final QueryMapper qm, final InList inList){
+		return qm instanceof ListQueryMapper && ((ListQueryMapper)qm).inList == inList ? (ListQueryMapper)qm : new ListQueryMapper(qm, inList);
+	}
+
+	public <T> InList.InListObject inList(final String columnName, final Collection<T> values) throws SQLException {
+		return this.inList.inList(delegate.conn, columnName, values);
+	}
+
+	// these update the database
+
+	@Override
+	public int executeUpdate(final PreparedStatement ps, final Object... bindObjects) throws SQLException {
+		return delegate.executeUpdate(ps, bindObjects);
+	}
+
+	@Override
+	public boolean executeUpdateSuccess(final PreparedStatement ps, final Object... bindObjects) throws SQLException {
+		return delegate.executeUpdateSuccess(ps, bindObjects);
+	}
+
+	// these update the database using UpdateableDTOs
+
+	@Override
+	public int updateRows(final UpdateableDTO dto) throws SQLException {
+		return delegate.updateRows(dto);
+	}
+
+	@Override
+	public int updateRows(final Collection<UpdateableDTO> dtos) throws SQLException {
+		return delegate.updateRows(dtos);
+	}
+
+	@Override
+	public int updateRows(final UpdateableDTO[] dtos) throws SQLException {
+		return delegate.updateRows(dtos);
+	}
+
+	@Override
+	public int insertRows(final UpdateableDTO dto) throws SQLException {
+		return delegate.insertRows(dto);
+	}
+
+	@Override
+	public int insertRows(final Collection<UpdateableDTO> dtos) throws SQLException {
+		return delegate.insertRows(dtos);
+	}
+
+	@Override
+	public int insertRows(final UpdateableDTO[] dtos) throws SQLException {
+		return delegate.insertRows(dtos);
+	}
+
+	// these grab ResultSets from the database
+
+	@Override
+	public ResultSet toResultSet(PreparedStatement ps, Object... bindObjects) throws SQLException {
+		return delegate.toResultSet(ps, bindObjects);
+	}
+
+	// these are standard getters
+
+	@Override
+	public ResultSetMapper getCustomResultSetMapper() {
+		return delegate.getCustomResultSetMapper();
+	}
+
+	@Override
+	public Connection getConnection() {
+		return delegate.getConnection();
+	}
+
+	// these just delegate and change no functionality
+
+	@Override
+	public void close() {
+		delegate.close();
+	}
+
+	// and these are standard
+
+	@Override
+	public boolean equals(final Object o) {
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+
+		final ListQueryMapper that = (ListQueryMapper) o;
+
+		if (delegate != null ? !delegate.equals(that.delegate) : that.delegate != null) return false;
+		if (inList != null ? !inList.equals(that.inList) : that.inList != null) return false;
+
+		return true;
+	}
+
+	@Override
+	public int hashCode() {
+		int result = delegate != null ? delegate.hashCode() : 0;
+		result = 31 * result + (inList != null ? inList.hashCode() : 0);
+		return result;
+	}
+
+	@Override
+	public String toString() {
+		return "ListQueryMapper{" +
+				"delegate=" + delegate +
+				", inList=" + inList +
+				"} " + super.toString();
+	}
+
+	// begin of ListQueryMapper specific methods
+
+	private static StringBuilder recursiveReplace(final StringBuilder sb, final Object... bindObjects) {
+		if (bindObjects != null && bindObjects.length > 0) {
+			for (Object o : bindObjects) {
+				if (o != null) {
+					if (o instanceof InList.InListObject) {
+						final int startIndex = sb.indexOf(inListReplace);
+						if (startIndex < -1)
+							return sb; // we've replaced all, maybe an error? meh
+						sb.replace(startIndex, startIndex + inListReplace.length(), o.toString());
+					} else if (o instanceof Object[]) {
+						recursiveReplace(sb, (Object[]) o);
+					} else if (o instanceof Collection) {
+						recursiveReplace(sb, ((Collection) o).toArray());
+					}
+				}
+			}
+		}
+		return sb;
+	}
+
+	protected String prepareSql(final String sql, final Object... bindObjects) {
+		return !sql.contains(inListReplace) ? sql : recursiveReplace(new StringBuilder(sql), bindObjects).toString();
+	}
+
+	@Override
+	public int executeUpdate(final String sql, final Object... bindObjects) throws SQLException {
+		return delegate.executeUpdate(prepareSql(sql, bindObjects), bindObjects);
+	}
+
+	@Override
+	public boolean executeUpdateSuccess(final String sql, final Object... bindObjects) throws SQLException {
+		return delegate.executeUpdateSuccess(prepareSql(sql, bindObjects), bindObjects);
+	}
+
+	@Override
+	public ResultSet toResultSet(String sql, Object... bindObjects) throws SQLException {
+		return delegate.toResultSet(prepareSql(sql, bindObjects), bindObjects);
+	}
+
+	// DO NOT EDIT BELOW THIS LINE, OR CHANGE THIS COMMENT, CODE AUTOMATICALLY GENERATED BY genQueryMapper.sh
+
+	@Override
+	public <T> T toObject(PreparedStatement ps, Class<T> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toObject(ps, componentType, bindObjects);
+	}
+
+	@Override
+	public <T> T toObject(String sql, Class<T> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toObject(prepareSql(sql, bindObjects), componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Map<String, V> toSingleMap(PreparedStatement ps, Class<T> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toSingleMap(ps, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Map<String, V> toSingleMap(String sql, Class<T> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toSingleMap(prepareSql(sql, bindObjects), componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> Map<String, V> toSingleMap(PreparedStatement ps, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toSingleMap(ps, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> Map<String, V> toSingleMap(String sql, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toSingleMap(prepareSql(sql, bindObjects), mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E> T toCollection(PreparedStatement ps, final Class<T> collectionType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollection(ps, collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E> T toCollection(String sql, final Class<T> collectionType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollection(prepareSql(sql, bindObjects), collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E> T toCollection(PreparedStatement ps, T list, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollection(ps, list, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E> T toCollection(String sql, T list, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollection(prepareSql(sql, bindObjects), list, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E> T toMap(PreparedStatement ps, final Class<T> returnType, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(ps, returnType, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E> T toMap(String sql, final Class<T> returnType, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(prepareSql(sql, bindObjects), returnType, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E> T toMap(PreparedStatement ps, T map, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(ps, map, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E> T toMap(String sql, T map, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(prepareSql(sql, bindObjects), map, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Collection<C>, C> T toMapCollection(PreparedStatement ps, final Class<T> returnType, Class<K> mapKeyType, Class<E> collectionType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollection(ps, returnType, mapKeyType, collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Collection<C>, C> T toMapCollection(String sql, final Class<T> returnType, Class<K> mapKeyType, Class<E> collectionType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollection(prepareSql(sql, bindObjects), returnType, mapKeyType, collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Collection<C>, C> T toMapCollection(PreparedStatement ps, T map, Class<K> mapKeyType, Class<E> collectionType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollection(ps, map, mapKeyType, collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Collection<C>, C> T toMapCollection(String sql, T map, Class<K> mapKeyType, Class<E> collectionType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollection(prepareSql(sql, bindObjects), map, mapKeyType, collectionType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T> ListIterator<T> toListIterator(PreparedStatement ps, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toListIterator(ps, type, bindObjects);
+	}
+
+	@Override
+	public <T> ListIterator<T> toListIterator(String sql, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toListIterator(prepareSql(sql, bindObjects), type, bindObjects);
+	}
+
+	@Override
+	public <T> Iterator<T> toIterator(PreparedStatement ps, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toIterator(ps, type, bindObjects);
+	}
+
+	@Override
+	public <T> Iterator<T> toIterator(String sql, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toIterator(prepareSql(sql, bindObjects), type, bindObjects);
+	}
+
+	@Override
+	public <T> T[] toArray(PreparedStatement ps, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toArray(ps, type, bindObjects);
+	}
+
+	@Override
+	public <T> T[] toArray(String sql, final Class<T> type, final Object... bindObjects) throws SQLException {
+		return delegate.toArray(prepareSql(sql, bindObjects), type, bindObjects);
+	}
+
+	@Override
+	public <E> List<E> toList(PreparedStatement ps, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toList(ps, componentType, bindObjects);
+	}
+
+	@Override
+	public <E> List<E> toList(String sql, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toList(prepareSql(sql, bindObjects), componentType, bindObjects);
+	}
+
+	@Override
+	public <K, E> Map<K, E> toMap(PreparedStatement ps, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(ps, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <K, E> Map<K, E> toMap(String sql, Class<K> mapKeyType, Class<E> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMap(prepareSql(sql, bindObjects), mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends List<C>, C> Map<K, E> toMapList(PreparedStatement ps, Class<K> mapKeyType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapList(ps, mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends List<C>, C> Map<K, E> toMapList(String sql, Class<K> mapKeyType, Class<C> componentType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapList(prepareSql(sql, bindObjects), mapKeyType, componentType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E extends Map<String, V>, V> T toCollectionMap(PreparedStatement ps, final Class<T> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollectionMap(ps, collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E extends Map<String, V>, V> T toCollectionMap(String sql, final Class<T> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollectionMap(prepareSql(sql, bindObjects), collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E extends Map<String, V>, V> T toCollectionMap(PreparedStatement ps, T list, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollectionMap(ps, list, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Collection<E>, E extends Map<String, V>, V> T toCollectionMap(String sql, T list, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toCollectionMap(prepareSql(sql, bindObjects), list, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Map<String, V>, V> T toMapMap(PreparedStatement ps, final Class<T> returnType, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(ps, returnType, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Map<String, V>, V> T toMapMap(String sql, final Class<T> returnType, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(prepareSql(sql, bindObjects), returnType, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Map<String, V>, V> T toMapMap(PreparedStatement ps, T map, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(ps, map, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, E>, K, E extends Map<String, V>, V> T toMapMap(String sql, T map, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(prepareSql(sql, bindObjects), map, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, C>, K, C extends Collection<E>, E extends Map<String, V>, V> T toMapCollectionMap(PreparedStatement ps, final Class<T> returnType, Class<K> mapKeyType, Class<C> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollectionMap(ps, returnType, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, C>, K, C extends Collection<E>, E extends Map<String, V>, V> T toMapCollectionMap(String sql, final Class<T> returnType, Class<K> mapKeyType, Class<C> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollectionMap(prepareSql(sql, bindObjects), returnType, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, C>, K, C extends Collection<E>, E extends Map<String, V>, V> T toMapCollectionMap(PreparedStatement ps, T map, Class<K> mapKeyType, Class<C> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollectionMap(ps, map, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<K, C>, K, C extends Collection<E>, E extends Map<String, V>, V> T toMapCollectionMap(String sql, T map, Class<K> mapKeyType, Class<C> collectionType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapCollectionMap(prepareSql(sql, bindObjects), map, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> ListIterator<Map<String, V>> toListIteratorMap(PreparedStatement ps, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListIteratorMap(ps, type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> ListIterator<Map<String, V>> toListIteratorMap(String sql, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListIteratorMap(prepareSql(sql, bindObjects), type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Iterator<Map<String, V>> toIteratorMap(PreparedStatement ps, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toIteratorMap(ps, type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Iterator<Map<String, V>> toIteratorMap(String sql, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toIteratorMap(prepareSql(sql, bindObjects), type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Map<String, V>[] toArrayMap(PreparedStatement ps, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toArrayMap(ps, type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <T extends Map<String, V>, V> Map<String, V>[] toArrayMap(String sql, final Class<T> type, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toArrayMap(prepareSql(sql, bindObjects), type, mapValType, bindObjects);
+	}
+
+	@Override
+	public <E extends Map<String, V>, V> List<Map<String, V>> toListMap(PreparedStatement ps, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListMap(ps, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <E extends Map<String, V>, V> List<Map<String, V>> toListMap(String sql, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListMap(prepareSql(sql, bindObjects), componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends Map<String, V>, V> Map<K, Map<String, V>> toMapMap(PreparedStatement ps, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(ps, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends Map<String, V>, V> Map<K, Map<String, V>> toMapMap(String sql, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(prepareSql(sql, bindObjects), mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends Map<String, V>, V> Map<K, List<Map<String, V>>> toMapListMap(PreparedStatement ps, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapListMap(ps, mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, E extends Map<String, V>, V> Map<K, List<Map<String, V>>> toMapListMap(String sql, Class<K> mapKeyType, Class<E> componentType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapListMap(prepareSql(sql, bindObjects), mapKeyType, componentType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> ListIterator<Map<String, V>> toListIteratorMap(PreparedStatement ps, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListIteratorMap(ps, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> ListIterator<Map<String, V>> toListIteratorMap(String sql, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListIteratorMap(prepareSql(sql, bindObjects), mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> Iterator<Map<String, V>> toIteratorMap(PreparedStatement ps, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toIteratorMap(ps, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> Iterator<Map<String, V>> toIteratorMap(String sql, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toIteratorMap(prepareSql(sql, bindObjects), mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> List<Map<String, V>> toListMap(PreparedStatement ps, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListMap(ps, mapValType, bindObjects);
+	}
+
+	@Override
+	public <V> List<Map<String, V>> toListMap(String sql, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toListMap(prepareSql(sql, bindObjects), mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, V> Map<K, Map<String, V>> toMapMap(PreparedStatement ps, Class<K> mapKeyType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(ps, mapKeyType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, V> Map<K, Map<String, V>> toMapMap(String sql, Class<K> mapKeyType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapMap(prepareSql(sql, bindObjects), mapKeyType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, V> Map<K, List<Map<String, V>>> toMapListMap(PreparedStatement ps, Class<K> mapKeyType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapListMap(ps, mapKeyType, mapValType, bindObjects);
+	}
+
+	@Override
+	public <K, V> Map<K, List<Map<String, V>>> toMapListMap(String sql, Class<K> mapKeyType, Class<V> mapValType, final Object... bindObjects) throws SQLException {
+		return delegate.toMapListMap(prepareSql(sql, bindObjects), mapKeyType, mapValType, bindObjects);
+	}
+
+}
+

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java

@@ -56,6 +56,10 @@ public class NullQueryMapper extends QueryMapper {
 		this(jndiName, cm, true);
 	}
 
+	public static NullQueryMapper wrap(final QueryMapper qm){
+		return qm instanceof NullQueryMapper ? (NullQueryMapper)qm : new NullQueryMapper(qm);
+	}
+
 	// these update the database
 
 	@Override
@@ -201,16 +205,6 @@ public class NullQueryMapper extends QueryMapper {
 		delegate.close();
 	}
 
-	@Override
-	protected PreparedStatement bind(PreparedStatement ps, Object... bindObjects) throws SQLException {
-		return delegate.bind(ps, bindObjects);
-	}
-
-	@Override
-	protected ResultSet bindExecute(PreparedStatement ps, Object... bindObjects) throws SQLException {
-		return delegate.bindExecute(ps, bindObjects);
-	}
-
 	// and these are standard
 
 	@Override

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/OracleArrayInList.java

@@ -0,0 +1,62 @@
+package com.moparisthebest.jdbc;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Array;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Collection;
+
+/**
+ * Created by mopar on 4/29/15.
+ */
+public class OracleArrayInList extends ArrayInList {
+
+	private static final InList instance = new OracleArrayInList();
+
+	public static InList instance() {
+		return instance;
+	}
+
+	private static final Class<?> oracleConnection;
+	private static final Method createArray;
+
+	static {
+		Class<?> oc;
+		Method ca;
+		try {
+			oc = Class.forName("oracle.jdbc.OracleConnection");
+			ca = oc.getDeclaredMethod("createOracleArray", String.class, Object.class);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+		oracleConnection = oc;
+		createArray = ca;
+	}
+
+	protected OracleArrayInList() {
+	}
+
+	protected String columnAppend() {
+		return " IN(select column_value from table(?))";
+	}
+
+	protected <T> Array toArray(final Connection conn, final Collection<T> values) throws SQLException {
+		/*
+		return conn.unwrap(oracle.jdbc.OracleConnection.class).createOracleArray(
+				values.iterator().next() instanceof Number ? "ARRAY_NUM_TYPE" : "ARRAY_STR_TYPE",
+				values.toArray()
+		);
+		*/
+		try {
+			return (Array) createArray.invoke(conn.unwrap(oracleConnection),
+					values.iterator().next() instanceof Number ? "ARRAY_NUM_TYPE" : "ARRAY_STR_TYPE",
+					values.toArray()
+			);
+		} catch (SQLException e) {
+			throw e;
+		} catch (Exception e) {
+			throw new RuntimeException(e); // should never happen, but if it does don't hide it
+		}
+	}
+}

beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/QueryMapper.java

@@ -155,6 +155,8 @@ public class QueryMapper implements Closeable {
 			}
 		else if (o instanceof Blob)
 			ps.setBlob(index, (Blob) o);
+		else if (o instanceof ArrayInList.ArrayListObject)
+			ps.setArray(index, ((ArrayInList.ArrayListObject) o).getArray());
 		else
 			ps.setObject(index, o); // probably won't get here ever, but just in case...
 		/*
@@ -201,7 +203,13 @@ public class QueryMapper implements Closeable {
 		if (bindObjects != null && bindObjects.length > 0) {
 			for (Object o : bindObjects) {
 				if (o != null) {
-					if (o instanceof Object[]) {
+					if (o == InList.InListObject.empty) {
+						continue; // ignore
+					} else if (o instanceof BindInList.BindInListObject) {
+						if (((BindInList.BindInListObject) o).getBindObjects() != null)
+							index = recursiveBind(ps, index, ((BindInList.BindInListObject) o).getBindObjects());
+						continue;
+					} else if (o instanceof Object[]) {
 						index = recursiveBind(ps, index, (Object[]) o);
 						continue;
 					} else if (o instanceof Collection) {