diff --git a/beehive-jdbc-control/pom.xml b/beehive-jdbc-control/pom.xml
index fdf1292..2e240d3 100644
--- a/beehive-jdbc-control/pom.xml
+++ b/beehive-jdbc-control/pom.xml
@@ -33,6 +33,11 @@
beehive-controls
${project.version}
+
+ com.moparisthebest.beehive
+ beehive-jdbc-mapper
+ ${project.version}
+
com.moparisthebest.aptIn16
netui-compiler
diff --git a/beehive-jdbc-control/src/main/java/org/apache/beehive/controls/system/jdbc/NewDefaultObjectResultSetMapper.java b/beehive-jdbc-control/src/main/java/org/apache/beehive/controls/system/jdbc/NewDefaultObjectResultSetMapper.java
new file mode 100644
index 0000000..807449d
--- /dev/null
+++ b/beehive-jdbc-control/src/main/java/org/apache/beehive/controls/system/jdbc/NewDefaultObjectResultSetMapper.java
@@ -0,0 +1,56 @@
+package org.apache.beehive.controls.system.jdbc;
+
+import org.apache.beehive.controls.api.context.ControlBeanContext;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.sql.ResultSet;
+import java.util.*;
+
+/**
+ * Refer to org.apache.beehive.controls.system.jdbc.ResultSetMapper for how this class operates
+ */
+public class NewDefaultObjectResultSetMapper extends com.moparisthebest.jdbc.ResultSetMapper implements org.apache.beehive.controls.system.jdbc.ResultSetMapper {
+ /**
+ * Map the ResultSet to the method's return type. The object type returned is defined by the return type of the method.
+ *
+ * @param context A ControlBeanContext instance, see Beehive controls javadoc for additional information
+ * @param m Method assoicated with this call.
+ * @param rs Result set to map.
+ * @param cal A Calendar instance for time/date value resolution.
+ * @return The Object resulting from the ResultSet
+ */
+ @SuppressWarnings({"unchecked"})
+ public Object mapToResultType(ControlBeanContext context, Method m, ResultSet rs, Calendar cal) {
+ final Class returnType = m.getReturnType();
+ if (returnType.isArray()) {
+ return toArray(rs, returnType.getComponentType(), context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal);
+ } else if (Collection.class.isAssignableFrom(returnType)) {
+ return toCollection(rs, returnType, (Class) getActualTypeArguments(m)[0], context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal);
+ } else if (Map.class.isAssignableFrom(returnType)) {
+ Type[] types = getActualTypeArguments(m);
+ if (types[1] instanceof ParameterizedType) { // for collectionMaps
+ ParameterizedType pt = (ParameterizedType) types[1];
+ Class collectionType = (Class) pt.getRawType();
+ if (Collection.class.isAssignableFrom(collectionType))
+ return toMapCollection(rs, returnType, (Class) types[0], collectionType, (Class) pt.getActualTypeArguments()[0], context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal);
+ }
+ return toMap(rs, returnType, (Class) types[0], (Class) types[1], context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal);
+ } else if (Iterator.class.isAssignableFrom(returnType)) {
+ return ListIterator.class.isAssignableFrom(returnType) ?
+ toListIterator(rs, (Class) getActualTypeArguments(m)[0], context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal) :
+ toIterator(rs, (Class) getActualTypeArguments(m)[0], context.getMethodPropertySet(m, JdbcControl.SQL.class).arrayMaxLength(), cal);
+ } else {
+ return toObject(rs, returnType, cal);
+ }
+ }
+
+ private static Type[] getActualTypeArguments(Method m) {
+ return ((ParameterizedType) m.getGenericReturnType()).getActualTypeArguments();
+ }
+
+ public boolean canCloseResultSet() {
+ return true;
+ }
+}
diff --git a/beehive-jdbc-mapper/genQueryMapper.sh b/beehive-jdbc-mapper/genQueryMapper.sh
new file mode 100755
index 0000000..2ec05a6
--- /dev/null
+++ b/beehive-jdbc-mapper/genQueryMapper.sh
@@ -0,0 +1,117 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+function prepareFile(){
+ path="$1"
+ tmp_path="$(basename "$path")"
+ (
+ sed -n '/CODE AUTOMATICALLY GENERATED BY genQueryMapper.sh/q;p' "$path"
+ echo -e '\t// DO NOT EDIT BELOW THIS LINE, OR CHANGE THIS COMMENT, CODE AUTOMATICALLY GENERATED BY genQueryMapper.sh\n'
+ ) > "$tmp_path"
+ echo "$tmp_path"
+}
+
+function finishFile(){
+ path="$1"
+ tmp_path="$(basename "$path")"
+ echo -e "}\n" >> "$tmp_path"
+ mv "$tmp_path" "$path"
+}
+
+
+result="$(prepareFile "src/main/java/com/moparisthebest/jdbc/ResultSetMapper.java")"
+
+# single object types
+cat src/main/java/com/moparisthebest/jdbc/ResultSetMapper.java | grep public | egrep '(toObject|toSingleMap)\(' | grep ', Calendar cal)' | while read method
+do
+ #echo "method: $method"
+ method_name=$(echo $method | egrep -o '[^ ]+\(')
+ echo "ResultSetMapper.$method_name)"
+
+ cat >> "$result" <> "$result" <> "$query" <> "$caching_query" <> "$null_query"
+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"
diff --git a/beehive-jdbc-mapper/pom.xml b/beehive-jdbc-mapper/pom.xml
new file mode 100644
index 0000000..fb295ef
--- /dev/null
+++ b/beehive-jdbc-mapper/pom.xml
@@ -0,0 +1,16 @@
+
+
+ 4.0.0
+
+ com.moparisthebest.beehive
+ beehive
+ 1.0.3-SNAPSHOT
+
+ beehive-jdbc-mapper
+ ${project.artifactId}
+
+ ${project.artifactId}
+
+
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingQueryMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingQueryMapper.java
new file mode 100644
index 0000000..6aa893e
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingQueryMapper.java
@@ -0,0 +1,296 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.*;
+
+import static com.moparisthebest.jdbc.TryClose.tryClose;
+
+/**
+ * This class caches the PreparedStatement's it creates for the strings you send in, then closes them when the close() method is called.
+ * Since PreparedStatement is not thread-safe, this class cannot be either. Be sure to call it from only a single thread
+ * or synchronize around it.
+ */
+public class CachingQueryMapper extends QueryMapper {
+
+ protected final Map cache;
+
+ protected CachingQueryMapper(Connection conn, String jndiName, ResultSetMapper cm, final int maxEntries) {
+ super(conn, jndiName, cm);
+ if (maxEntries > 0) { // we want a limited cache
+ final float loadFactor = 0.75f; // default for HashMaps
+ // if we set the initialCapacity this way, nothing should ever need re-sized
+ final int initialCapacity = ((int) Math.ceil(maxEntries / loadFactor)) + 1;
+ cache = new LinkedHashMap(initialCapacity, loadFactor, true) {
+ @Override
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ final boolean remove = size() > maxEntries;
+ if(remove){
+ //System.out.printf("closing PreparedStatement '%s' with key '%s'\n", eldest.getValue(), eldest.getKey());
+ tryClose(eldest.getValue());
+ }
+ return remove;
+ }
+ };
+ } else
+ cache = new HashMap();
+ }
+
+ public CachingQueryMapper(Connection conn, ResultSetMapper cm, final int maxEntries) {
+ this(conn, null, cm, maxEntries);
+ }
+
+ public CachingQueryMapper(Connection conn, final int maxEntries) {
+ this(conn, null, null, maxEntries);
+ }
+
+ public CachingQueryMapper(String jndiName, ResultSetMapper cm, final int maxEntries) {
+ this(null, jndiName, cm, maxEntries);
+ }
+
+ public CachingQueryMapper(String jndiName, final int maxEntries) {
+ this(null, jndiName, null, maxEntries);
+ }
+
+ protected CachingQueryMapper(Connection conn, String jndiName, ResultSetMapper cm) {
+ this(conn, jndiName, cm, 20); // default size of 20
+ }
+
+ public CachingQueryMapper(Connection conn, ResultSetMapper cm) {
+ this(conn, null, cm);
+ }
+
+ public CachingQueryMapper(Connection conn) {
+ this(conn, null, null);
+ }
+
+ public CachingQueryMapper(String jndiName, ResultSetMapper cm) {
+ this(null, jndiName, cm);
+ }
+
+ public CachingQueryMapper(String jndiName) {
+ this(null, jndiName, null);
+ }
+
+ protected PreparedStatement getPreparedStatement(String sql) throws SQLException {
+ return getPreparedStatement(sql, ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);
+ }
+
+ protected PreparedStatement getPreparedStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ PreparedStatement ps = cache.get(sql);
+ if (ps == null) {
+ //System.out.println("cache miss");
+ ps = conn.prepareStatement(sql,resultSetType,resultSetConcurrency);
+ cache.put(sql, ps);
+ }
+ //else System.out.println("cache hit");
+ return ps;
+ }
+
+ public void clearCache(boolean close) {
+ //System.out.println("cache size: "+cache.size());
+ for (PreparedStatement ps : cache.values())
+ tryClose(ps);
+ if (close)
+ super.close();
+ else
+ cache.clear();
+ }
+
+ public void clearCache() {
+ this.clearCache(false);
+ }
+
+ @Override
+ public void close() {
+ this.clearCache(true);
+ }
+
+ @Override
+ public int executeUpdate(String sql, Object... bindObjects) throws SQLException {
+ return super.executeUpdate(getPreparedStatement(sql), bindObjects);
+ }
+
+ @Override
+ public boolean executeUpdateSuccess(String sql, Object... bindObjects) throws SQLException {
+ return super.executeUpdateSuccess(getPreparedStatement(sql), bindObjects);
+ }
+
+ // these grab ResultSets from the database
+
+ @Override
+ public ResultSet toResultSet(String sql, Object... bindObjects) throws SQLException {
+ return super.toResultSet(getPreparedStatement(sql), bindObjects);
+ }
+
+ @Override
+ public ResultSet toResultSet(String sql, Integer rsType, Integer rsConcurrency, Object... bindObjects) throws SQLException {
+ return super.toResultSet(getPreparedStatement(sql,rsType,rsConcurrency), bindObjects);
+ }
+
+ // DO NOT EDIT BELOW THIS LINE, OR CHANGE THIS COMMENT, CODE AUTOMATICALLY GENERATED BY genQueryMapper.sh
+
+ @Override
+ public T toObject(String sql, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toObject(getPreparedStatement(sql), componentType, bindObjects);
+ }
+
+ @Override
+ public , V> Map toSingleMap(String sql, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toSingleMap(getPreparedStatement(sql), componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public Map toSingleMap(String sql, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toSingleMap(getPreparedStatement(sql), mapValType, bindObjects);
+ }
+
+ @Override
+ public , E> T toCollection(String sql, final Class collectionType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toCollection(getPreparedStatement(sql), collectionType, componentType, bindObjects);
+ }
+
+ @Override
+ public , E> T toCollection(String sql, T list, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toCollection(getPreparedStatement(sql), list, componentType, bindObjects);
+ }
+
+ @Override
+ public , K, E> T toMap(String sql, final Class returnType, Class mapKeyType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMap(getPreparedStatement(sql), returnType, mapKeyType, componentType, bindObjects);
+ }
+
+ @Override
+ public , K, E> T toMap(String sql, T map, Class mapKeyType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMap(getPreparedStatement(sql), map, mapKeyType, componentType, bindObjects);
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(String sql, final Class returnType, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMapCollection(getPreparedStatement(sql), returnType, mapKeyType, collectionType, componentType, bindObjects);
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(String sql, T map, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMapCollection(getPreparedStatement(sql), map, mapKeyType, collectionType, componentType, bindObjects);
+ }
+
+ @Override
+ public ListIterator toListIterator(String sql, final Class type, final Object... bindObjects) throws SQLException {
+ return super.toListIterator(getPreparedStatement(sql), type, bindObjects);
+ }
+
+ @Override
+ public Iterator toIterator(String sql, final Class type, final Object... bindObjects) throws SQLException {
+ return super.toIterator(getPreparedStatement(sql), type, bindObjects);
+ }
+
+ @Override
+ public T[] toArray(String sql, final Class type, final Object... bindObjects) throws SQLException {
+ return super.toArray(getPreparedStatement(sql), type, bindObjects);
+ }
+
+ @Override
+ public List toList(String sql, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toList(getPreparedStatement(sql), componentType, bindObjects);
+ }
+
+ @Override
+ public Map toMap(String sql, Class mapKeyType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMap(getPreparedStatement(sql), mapKeyType, componentType, bindObjects);
+ }
+
+ @Override
+ public , C> Map toMapList(String sql, Class mapKeyType, Class componentType, final Object... bindObjects) throws SQLException {
+ return super.toMapList(getPreparedStatement(sql), mapKeyType, componentType, bindObjects);
+ }
+
+ @Override
+ public , E extends Map, V> T toCollectionMap(String sql, final Class collectionType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toCollectionMap(getPreparedStatement(sql), collectionType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , E extends Map, V> T toCollectionMap(String sql, T list, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toCollectionMap(getPreparedStatement(sql), list, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , K, E extends Map, V> T toMapMap(String sql, final Class returnType, Class mapKeyType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapMap(getPreparedStatement(sql), returnType, mapKeyType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , K, E extends Map, V> T toMapMap(String sql, T map, Class mapKeyType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapMap(getPreparedStatement(sql), map, mapKeyType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , K, C extends Collection, E extends Map, V> T toMapCollectionMap(String sql, final Class returnType, Class mapKeyType, Class collectionType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapCollectionMap(getPreparedStatement(sql), returnType, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , K, C extends Collection, E extends Map, V> T toMapCollectionMap(String sql, T map, Class mapKeyType, Class collectionType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapCollectionMap(getPreparedStatement(sql), map, mapKeyType, collectionType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> ListIterator> toListIteratorMap(String sql, final Class type, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toListIteratorMap(getPreparedStatement(sql), type, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> Iterator> toIteratorMap(String sql, final Class type, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toIteratorMap(getPreparedStatement(sql), type, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> Map[] toArrayMap(String sql, final Class type, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toArrayMap(getPreparedStatement(sql), type, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> List> toListMap(String sql, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toListMap(getPreparedStatement(sql), componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> Map> toMapMap(String sql, Class mapKeyType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapMap(getPreparedStatement(sql), mapKeyType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public , V> Map>> toMapListMap(String sql, Class mapKeyType, Class componentType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapListMap(getPreparedStatement(sql), mapKeyType, componentType, mapValType, bindObjects);
+ }
+
+ @Override
+ public ListIterator> toListIteratorMap(String sql, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toListIteratorMap(getPreparedStatement(sql), mapValType, bindObjects);
+ }
+
+ @Override
+ public Iterator> toIteratorMap(String sql, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toIteratorMap(getPreparedStatement(sql), mapValType, bindObjects);
+ }
+
+ @Override
+ public List> toListMap(String sql, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toListMap(getPreparedStatement(sql), mapValType, bindObjects);
+ }
+
+ @Override
+ public Map> toMapMap(String sql, Class mapKeyType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapMap(getPreparedStatement(sql), mapKeyType, mapValType, bindObjects);
+ }
+
+ @Override
+ public Map>> toMapListMap(String sql, Class mapKeyType, Class mapValType, final Object... bindObjects) throws SQLException {
+ return super.toMapListMap(getPreparedStatement(sql), mapKeyType, mapValType, bindObjects);
+ }
+
+}
+
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingResultSetMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingResultSetMapper.java
new file mode 100644
index 0000000..792547d
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingResultSetMapper.java
@@ -0,0 +1,20 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.ResultSet;
+import java.util.Calendar;
+
+public class CachingResultSetMapper extends ResultSetMapper {
+
+ public CachingResultSetMapper(Calendar cal, int arrayMaxLength) {
+ super(cal, arrayMaxLength);
+ }
+
+ public CachingResultSetMapper() {
+ super();
+ }
+
+ @Override
+ protected RowToObjectMapper getRowMapper(ResultSet resultSet, Class returnTypeClass, Calendar cal, Class mapValType) {
+ return new CachingRowToObjectMapper(resultSet, returnTypeClass, cal, mapValType);
+ }
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingRowToObjectMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingRowToObjectMapper.java
new file mode 100644
index 0000000..0f9c27a
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CachingRowToObjectMapper.java
@@ -0,0 +1,65 @@
+package com.moparisthebest.jdbc;
+
+import java.lang.reflect.AccessibleObject;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CachingRowToObjectMapper extends RowToObjectMapper {
+
+ protected static final Map cache = new HashMap();
+
+ protected final int thisHash;
+ protected final String[] keys;
+
+ public CachingRowToObjectMapper(ResultSet resultSet, Class returnTypeClass, Calendar cal, Class mapValType) {
+ super(resultSet, returnTypeClass, cal, mapValType);
+ try {
+ keys = super.getKeysFromResultSet();
+ //System.out.printf("keys: %d, %s: %d\n", Arrays.hashCode(keys), _returnTypeClass, _returnTypeClass.hashCode());
+ thisHash = Arrays.hashCode(keys) ^ _returnTypeClass.hashCode();
+ } catch (SQLException e) {
+ throw new MapperException("CachingRowToObjectMapper: SQLException: " + e.getMessage(), e);
+ }
+ }
+
+ @Override
+ protected String[] getKeysFromResultSet() throws SQLException {
+ return keys;
+ }
+
+ @Override
+ protected void getFieldMappings() throws SQLException {
+ FieldMapping fm = cache.get(thisHash);
+ if (fm == null) {
+ //System.out.printf("cache miss, hashcode: %d\n", thisHash);
+ // generate and put into cache
+ super.getFieldMappings();
+ synchronized (cache) {
+ // I *think* we only need to synchronize here, instead of around the get as well
+ // it may allow some leaks (field mappings being generated more than once)
+ // but the performance benefits of not having this entire method synchronized
+ // statically probably outweighs the negatives
+ cache.put(thisHash, new FieldMapping(_fields, _fieldTypes));
+ }
+ } else {
+ //System.out.printf("cache hit, hashcode: %d\n", thisHash);
+ // load from cache
+ _fields = fm._fields;
+ _fieldTypes = fm._fieldTypes;
+ }
+ }
+
+ private static class FieldMapping {
+ public final AccessibleObject[] _fields;
+ public final int[] _fieldTypes;
+
+ private FieldMapping(AccessibleObject[] _fields, int[] _fieldTypes) {
+ this._fields = _fields;
+ this._fieldTypes = _fieldTypes;
+ }
+ }
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Cleaner.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Cleaner.java
new file mode 100644
index 0000000..6db48dd
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Cleaner.java
@@ -0,0 +1,6 @@
+package com.moparisthebest.jdbc;
+
+public interface Cleaner {
+
+ public T clean(T dto);
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningResultSetMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningResultSetMapper.java
new file mode 100644
index 0000000..14f77eb
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningResultSetMapper.java
@@ -0,0 +1,25 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.ResultSet;
+import java.util.Calendar;
+
+public class CleaningResultSetMapper extends ResultSetMapper {
+
+ private final Cleaner cleaner;
+
+ public CleaningResultSetMapper(Cleaner cleaner, Calendar cal, int arrayMaxLength) {
+ super(cal, arrayMaxLength);
+ this.cleaner = cleaner;
+ }
+
+ public CleaningResultSetMapper(Cleaner cleaner) {
+ super();
+ this.cleaner = cleaner;
+ }
+
+ @Override
+ @SuppressWarnings({"unchecked"})
+ protected RowToObjectMapper getRowMapper(ResultSet resultSet, Class returnTypeClass, Calendar cal, Class mapValType) {
+ return new CleaningRowToObjectMapper((Cleaner)cleaner, resultSet, returnTypeClass, cal, mapValType);
+ }
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningRowToObjectMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningRowToObjectMapper.java
new file mode 100644
index 0000000..91d3388
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/CleaningRowToObjectMapper.java
@@ -0,0 +1,21 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.ResultSet;
+import java.util.Calendar;
+
+public class CleaningRowToObjectMapper extends RowToObjectMapper {
+
+ private final Cleaner cleaner;
+
+ public CleaningRowToObjectMapper(Cleaner cleaner, ResultSet resultSet, Class returnTypeClass, Calendar cal, Class mapValType) {
+ super(resultSet, returnTypeClass, cal, mapValType);
+ if (cleaner == null)
+ throw new NullPointerException("cleaner cannot be null!");
+ this.cleaner = cleaner;
+ }
+
+ @Override
+ public T mapRowToReturnType() {
+ return cleaner.clean(super.mapRowToReturnType());
+ }
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Finishable.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Finishable.java
new file mode 100644
index 0000000..97d2262
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/Finishable.java
@@ -0,0 +1,8 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public interface Finishable {
+ public void finish(ResultSet rs) throws SQLException;
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/MapperException.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/MapperException.java
new file mode 100644
index 0000000..583ab8d
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/MapperException.java
@@ -0,0 +1,45 @@
+package com.moparisthebest.jdbc;
+
+/**
+ * The MapperException class declares an unchecked exception that is thrown by the Controls
+ * runtime under certain failure conditions.
+ */
+public class MapperException extends RuntimeException
+{
+ /**
+ * Default constructor.
+ */
+ public MapperException() {
+ super();
+ }
+
+ /**
+ * Constructs a MapperException object with the specified String as a message.
+ *
+ * @param message The message to use.
+ */
+ public MapperException(String message)
+ {
+ super(message);
+ }
+
+ /**
+ * Constructs a MapperException with the specified cause.
+ * @param t the cause
+ */
+ public MapperException(Throwable t) {
+ super(t);
+ }
+
+ /**
+ * Constructs a MapperException object using the specified String as a message, and the
+ * specified Throwable as a nested exception.
+ *
+ * @param message The message to use.
+ * @param t The exception to nest within this exception.
+ */
+ public MapperException(String message, Throwable t)
+ {
+ super(message + "[" + t + "]", t);
+ }
+}
diff --git a/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java
new file mode 100644
index 0000000..5484e01
--- /dev/null
+++ b/beehive-jdbc-mapper/src/main/java/com/moparisthebest/jdbc/NullQueryMapper.java
@@ -0,0 +1,887 @@
+package com.moparisthebest.jdbc;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.*;
+
+public class NullQueryMapper extends QueryMapper {
+
+ protected final boolean verbose;
+ protected final QueryMapper delegate;
+
+ private NullQueryMapper(Connection conn, String jndiName, QueryMapper delegate, ResultSetMapper cm, boolean verbose) {
+ this.verbose = verbose;
+ this.delegate = delegate == null ? new QueryMapper(conn, jndiName, cm) : delegate;
+ }
+
+ public NullQueryMapper(QueryMapper delegate, boolean verbose) {
+ this(null, null, delegate, null, verbose);
+ }
+
+ public NullQueryMapper(QueryMapper delegate) {
+ this(null, null, delegate, null, true);
+ }
+
+ public NullQueryMapper(Connection conn, boolean verbose) {
+ this(conn, null, null, null, verbose);
+ }
+
+ public NullQueryMapper(Connection conn, ResultSetMapper cm, boolean verbose) {
+ this(conn, null, null, cm, verbose);
+ }
+
+ public NullQueryMapper(Connection conn) {
+ this(conn, true);
+ }
+
+ public NullQueryMapper(Connection conn, ResultSetMapper cm) {
+ this(conn, cm, true);
+ }
+
+ public NullQueryMapper(String jndiName, boolean verbose) {
+ this(null, jndiName, null, null, verbose);
+ }
+
+ public NullQueryMapper(String jndiName, ResultSetMapper cm, boolean verbose) {
+ this(null, jndiName, null, cm, verbose);
+ }
+
+ public NullQueryMapper(String jndiName) {
+ this(jndiName, true);
+ }
+
+ public NullQueryMapper(String jndiName, ResultSetMapper cm) {
+ this(jndiName, cm, true);
+ }
+
+ // these update the database
+
+ @Override
+ public int executeUpdate(PreparedStatement ps, Object... bindObjects) {
+ try {
+ return delegate.executeUpdate(ps, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public boolean executeUpdateSuccess(PreparedStatement ps, Object... bindObjects) {
+ try {
+ return delegate.executeUpdateSuccess(ps, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return false;
+ }
+
+ @Override
+ public int executeUpdate(String sql, Object... bindObjects) {
+ try {
+ return delegate.executeUpdate(sql, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public boolean executeUpdateSuccess(String sql, Object... bindObjects) {
+ try {
+ return delegate.executeUpdateSuccess(sql, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return false;
+ }
+
+ // these update the database using UpdateableDTOs
+
+ @Override
+ public int updateRows(UpdateableDTO dto) {
+ try {
+ return delegate.updateRows(dto);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public int updateRows(Collection dtos) {
+ try {
+ return delegate.updateRows(dtos);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public int updateRows(UpdateableDTO[] dtos) {
+ try {
+ return delegate.updateRows(dtos);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public int insertRows(UpdateableDTO dto) {
+ try {
+ return delegate.insertRows(dto);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public int insertRows(Collection dtos) {
+ try {
+ return delegate.insertRows(dtos);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ @Override
+ public int insertRows(UpdateableDTO[] dtos) {
+ try {
+ return delegate.insertRows(dtos);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return -1;
+ }
+
+ // these grab ResultSets from the database
+
+ @Override
+ public ResultSet toResultSet(PreparedStatement ps, Object... bindObjects) {
+ try {
+ return delegate.toResultSet(ps, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public ResultSet toResultSet(String sql, Object... bindObjects) {
+ try {
+ return delegate.toResultSet(sql, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ // 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();
+ }
+
+ @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
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ NullQueryMapper that = (NullQueryMapper) o;
+
+ if (verbose != that.verbose) return false;
+ if (delegate != null ? !delegate.equals(that.delegate) : that.delegate != null) return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = (verbose ? 1 : 0);
+ result = 31 * result + (delegate != null ? delegate.hashCode() : 0);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "NullQueryMapper{" +
+ "verbose=" + verbose +
+ ", delegate=" + delegate +
+ "}";
+ }
+
+ // DO NOT EDIT BELOW THIS LINE, OR CHANGE THIS COMMENT, CODE AUTOMATICALLY GENERATED BY genQueryMapper.sh
+
+ @Override
+ public T toObject(PreparedStatement query, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toObject(query, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public T toObject(String query, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toObject(query, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , V> Map toSingleMap(PreparedStatement query, Class componentType, Class mapValType, final Object... bindObjects) {
+ try {
+ return delegate.toSingleMap(query, componentType, mapValType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , V> Map toSingleMap(String query, Class componentType, Class mapValType, final Object... bindObjects) {
+ try {
+ return delegate.toSingleMap(query, componentType, mapValType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public Map toSingleMap(PreparedStatement query, Class mapValType, final Object... bindObjects) {
+ try {
+ return delegate.toSingleMap(query, mapValType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public Map toSingleMap(String query, Class mapValType, final Object... bindObjects) {
+ try {
+ return delegate.toSingleMap(query, mapValType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , E> T toCollection(PreparedStatement query, final Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toCollection(query, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , E> T toCollection(String query, final Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toCollection(query, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , E> T toCollection(PreparedStatement query, T list, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toCollection(query, list, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , E> T toCollection(String query, T list, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toCollection(query, list, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E> T toMap(PreparedStatement query, final Class returnType, Class mapKeyType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMap(query, returnType, mapKeyType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E> T toMap(String query, final Class returnType, Class mapKeyType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMap(query, returnType, mapKeyType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E> T toMap(PreparedStatement query, T map, Class mapKeyType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMap(query, map, mapKeyType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E> T toMap(String query, T map, Class mapKeyType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMap(query, map, mapKeyType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(PreparedStatement query, final Class returnType, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMapCollection(query, returnType, mapKeyType, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(String query, final Class returnType, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMapCollection(query, returnType, mapKeyType, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(PreparedStatement query, T map, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMapCollection(query, map, mapKeyType, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public , K, E extends Collection, C> T toMapCollection(String query, T map, Class mapKeyType, Class collectionType, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toMapCollection(query, map, mapKeyType, collectionType, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public ListIterator toListIterator(PreparedStatement query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toListIterator(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public ListIterator toListIterator(String query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toListIterator(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public Iterator toIterator(PreparedStatement query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toIterator(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public Iterator toIterator(String query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toIterator(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public T[] toArray(PreparedStatement query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toArray(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public T[] toArray(String query, final Class type, final Object... bindObjects) {
+ try {
+ return delegate.toArray(query, type, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public List toList(PreparedStatement query, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toList(query, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public List toList(String query, Class componentType, final Object... bindObjects) {
+ try {
+ return delegate.toList(query, componentType, bindObjects);
+ } catch (Throwable e) {
+ if (verbose) e.printStackTrace();
+ }
+ return null;
+ }
+
+ @Override
+ public Map toMap(PreparedStatement query, Class mapKeyType, Class