Coverage Report - net.admin4j.jdbc.driver.sql.SQLWrappingUtils
 
Classes in this File Line Coverage Branch Coverage Complexity
SQLWrappingUtils
68%
74/108
67%
39/58
5.833
 
 1   
 /*
 2   
  * This software is licensed under the Apache License, Version 2.0
 3   
  * (the "License") agreement; you may not use this file except in compliance with
 4   
  * the License.  You may obtain a copy of the License at
 5   
  *
 6   
  *      http://www.apache.org/licenses/LICENSE-2.0
 7   
  *
 8   
  * Unless required by applicable law or agreed to in writing, software
 9   
  * distributed under the License is distributed on an "AS IS" BASIS,
 10   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 11   
  * See the License for the specific language governing permissions and
 12   
  * limitations under the License.
 13   
  */
 14   
 package net.admin4j.jdbc.driver.sql;
 15   
 
 16   
 import java.lang.reflect.Constructor;
 17   
 import java.sql.CallableStatement;
 18   
 import java.sql.Connection;
 19   
 import java.sql.PreparedStatement;
 20   
 import java.sql.Statement;
 21   
 import java.util.Map;
 22   
 import java.util.concurrent.ConcurrentHashMap;
 23   
 
 24   
 import net.admin4j.deps.commons.lang3.JavaVersion;
 25   
 import net.admin4j.deps.commons.lang3.SystemUtils;
 26   
 import net.admin4j.jdbc.driver.DriverContext;
 27   
 import net.admin4j.util.Admin4jRuntimeException;
 28   
 import net.admin4j.util.annotate.PackageRestrictions;
 29   
 
 30   
 /**
 31   
  * Will wrap JDBC objects with the appropriate wrapper for tracking and reporting purposes.
 32   
  * @author D. Ashmore
 33   
  * @since 1.0
 34   
  */
 35   
 @PackageRestrictions({"net.admin4j","java","javax"})
 36  0 
 public class SQLWrappingUtils {
 37   
 
 38   
  // Only used as Commons Lang is an unwanted dependancy for JDBC drivers.
 39  9 
     public static final String LINE_SEPARATOR = System.getProperty("line.separator");
 40   
 
 41  9 
     private static Map<Class, Constructor> constructorMap = new ConcurrentHashMap<Class, Constructor>();
 42   
 
 43   
     public static Object wrap(Object sqlObject) {
 44  18 
         return wrap(sqlObject, null, null, null);
 45   
     }
 46   
 
 47   
     public static Object wrap(Object sqlObject, Connection connection) {
 48  21 
         return wrap(sqlObject, connection, null, null);
 49   
     }
 50   
 
 51   
     @SuppressWarnings("rawtypes")
 52   
     public static Object wrap(Object sqlObject, Connection connection, String sqlText, StackTraceElement[] stack) {
 53  180075 
         Constructor wrapperConstructor = null;
 54  180075 
         Object jdbcObject = null;
 55   
         try {
 56  180075 
             wrapperConstructor = findconstructor(sqlObject);
 57   
 
 58  180075 
             if (wrapperConstructor != null && wrapperConstructor.getParameterTypes().length == 1) {
 59  18 
                 jdbcObject = wrapperConstructor.newInstance(sqlObject);
 60  18 
                 encodeSqlText(sqlText, stack, jdbcObject);
 61  18 
                 return jdbcObject;
 62   
             }
 63  180057 
             else if (wrapperConstructor != null && wrapperConstructor.getParameterTypes().length == 2) {
 64  180057 
                 jdbcObject = wrapperConstructor.newInstance(connection, sqlObject);
 65  180057 
                 encodeSqlText(sqlText, stack, jdbcObject);
 66  180057 
                 return jdbcObject;
 67   
             }
 68   
         }
 69  0 
         catch (Admin4jRuntimeException are) {
 70  0 
             throw are.addContextValue("className", sqlObject.getClass().getName());
 71   
         }
 72  0 
         catch (Exception e) {
 73  0 
             throw new Admin4jRuntimeException("Error wrapping JDBC object", e)
 74   
             .addContextValue("className", sqlObject.getClass().getName());
 75  0 
         }
 76   
 
 77  0 
         throw new Admin4jRuntimeException("Error wrapping JDBC object")
 78   
         .addContextValue("className", sqlObject.getClass().getName());
 79   
     }
 80   
 
 81   
     private static Constructor findconstructor(Object sqlObject)
 82   
             throws ClassNotFoundException, NoSuchMethodException {
 83  180075 
         Constructor wrapperConstructor = constructorMap.get(sqlObject.getClass());
 84  180075 
         if (wrapperConstructor != null) {
 85  180048 
             return wrapperConstructor;
 86   
         }
 87   
 
 88  0 
         if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8)) {
 89  9 
             wrapperConstructor = findWrapperConstructor18(sqlObject);
 90   
         }
 91  0 
         else if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_7)) {
 92  9 
             wrapperConstructor = findWrapperConstructor17(sqlObject);
 93   
         }
 94  0 
         else if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_6)) {
 95  9 
             wrapperConstructor = findWrapperConstructor16(sqlObject);
 96   
         }
 97   
         else {
 98  0 
             wrapperConstructor = findWrapperConstructor15(sqlObject);
 99   
         }
 100  27 
         constructorMap.put(sqlObject.getClass(), wrapperConstructor);
 101  27 
         return wrapperConstructor;
 102   
     }
 103   
 
 104   
     private static void encodeSqlText(String sqlText, StackTraceElement[] stack, Object jdbcObject) {
 105  180075 
         if (sqlText != null && jdbcObject instanceof SqlContext) {
 106  180033 
             ((SqlContext)jdbcObject).setSqlText(sqlText);
 107  180033 
             ((SqlContext)jdbcObject).setExecutionStack(stack);
 108   
         }
 109  180075 
     }
 110   
 
 111   
     public static void encodeDriverContext(Object jdbcObject, String driverClassName, String poolName, Integer driverMajorVersion, Integer driverMinorVersion) {
 112  15 
         if (jdbcObject instanceof DriverContext) {
 113  15 
             ((DriverContext)jdbcObject).setDriverClassname(driverClassName);
 114  15 
             ((DriverContext)jdbcObject).setDriverMajorVersion(driverMajorVersion);
 115  15 
             ((DriverContext)jdbcObject).setDriverMinorVersion(driverMinorVersion);
 116  15 
             ((DriverContext)jdbcObject).setPoolName(poolName);
 117   
         }
 118  15 
     }
 119   
 
 120   
     @SuppressWarnings({ "unchecked", "rawtypes" })
 121   
     private static Constructor findWrapperConstructor18(Object sqlObject) throws ClassNotFoundException, SecurityException, NoSuchMethodException {
 122  9 
         Class wrapperClass = null;
 123  9 
         if (sqlObject instanceof Connection) {
 124  3 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.ConnectionWrapper42");
 125  3 
             return wrapperClass.getConstructor(Connection.class);
 126   
         }
 127  6 
         else if (sqlObject instanceof CallableStatement) {
 128  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.CallableStatementWrapper42");
 129  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, CallableStatement.class);
 130   
         }
 131  4 
         else if (sqlObject instanceof PreparedStatement) {
 132  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.PreparedStatementWrapper42");
 133  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, PreparedStatement.class);
 134   
         }
 135  2 
         else if (sqlObject instanceof Statement) {
 136  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.StatementWrapper42");
 137  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, Statement.class);
 138   
         }
 139   
         else {
 140  0 
             throw new Admin4jRuntimeException("Error wrapping JDBC object")
 141   
             .addContextValue("className", sqlObject.getClass().getName());
 142   
         }
 143   
     }
 144   
 
 145   
     @SuppressWarnings({ "unchecked", "rawtypes" })
 146   
     private static Constructor findWrapperConstructor17(Object sqlObject) throws ClassNotFoundException, SecurityException, NoSuchMethodException {
 147  9 
         Class wrapperClass = null;
 148  9 
         if (sqlObject instanceof Connection) {
 149  3 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.ConnectionWrapper41");
 150  3 
             return wrapperClass.getConstructor(Connection.class);
 151   
         }
 152  6 
         else if (sqlObject instanceof CallableStatement) {
 153  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.CallableStatementWrapper41");
 154  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, CallableStatement.class);
 155   
         }
 156  4 
         else if (sqlObject instanceof PreparedStatement) {
 157  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.PreparedStatementWrapper41");
 158  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, PreparedStatement.class);
 159   
         }
 160  2 
         else if (sqlObject instanceof Statement) {
 161  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.StatementWrapper41");
 162  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, Statement.class);
 163   
         }
 164   
         else {
 165  0 
             throw new Admin4jRuntimeException("Error wrapping JDBC object")
 166   
             .addContextValue("className", sqlObject.getClass().getName());
 167   
         }
 168   
     }
 169   
 
 170   
     @SuppressWarnings({ "unchecked", "rawtypes" })
 171   
     private static Constructor findWrapperConstructor16(Object sqlObject) throws ClassNotFoundException, SecurityException, NoSuchMethodException {
 172  9 
         Class wrapperClass = null;
 173  9 
         if (sqlObject instanceof Connection) {
 174  3 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.ConnectionWrapper40");
 175  3 
             return wrapperClass.getConstructor(Connection.class);
 176   
         }
 177  6 
         else if (sqlObject instanceof CallableStatement) {
 178  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.CallableStatementWrapper40");
 179  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, CallableStatement.class);
 180   
         }
 181  4 
         else if (sqlObject instanceof PreparedStatement) {
 182  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.PreparedStatementWrapper40");
 183  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, PreparedStatement.class);
 184   
         }
 185  2 
         else if (sqlObject instanceof Statement) {
 186  2 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.StatementWrapper40");
 187  2 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, Statement.class);
 188   
         }
 189   
         else {
 190  0 
             throw new Admin4jRuntimeException("Error wrapping JDBC object")
 191   
             .addContextValue("className", sqlObject.getClass().getName());
 192   
         }
 193   
     }
 194   
 
 195   
     @SuppressWarnings({ "unchecked", "rawtypes" })
 196   
     private static Constructor findWrapperConstructor15(Object sqlObject) throws ClassNotFoundException, SecurityException, NoSuchMethodException {
 197  0 
         Class wrapperClass = null;
 198  0 
         if (sqlObject instanceof Connection) {
 199  0 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.ConnectionWrapper30");
 200  0 
             return wrapperClass.getConstructor(Connection.class);
 201   
         }
 202  0 
         else if (sqlObject instanceof CallableStatement) {
 203  0 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.CallableStatementWrapper30");
 204  0 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, CallableStatement.class);
 205   
         }
 206  0 
         else if (sqlObject instanceof PreparedStatement) {
 207  0 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.PreparedStatementWrapper30");
 208  0 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, PreparedStatement.class);
 209   
         }
 210  0 
         else if (sqlObject instanceof Statement) {
 211  0 
             wrapperClass = Class.forName("net.admin4j.jdbc.driver.sql.StatementWrapper30");
 212  0 
             return wrapperClass.getConstructor(ConnectionWrapper30Base.class, Statement.class);
 213   
         }
 214   
         else {
 215  0 
             throw new Admin4jRuntimeException("Error wrapping JDBC object")
 216   
             .addContextValue("className", sqlObject.getClass().getName());
 217   
         }
 218   
     }
 219   
 
 220   
     /**
 221   
      * Only used as Commons Lang is an unwanted dependancy for JDBC drivers.
 222   
      * @param objArray
 223   
      * @return
 224   
      */
 225   
     protected static String array2String(Object[] objArray) {
 226  0 
         StringBuffer buffer = new StringBuffer();
 227  0 
         for (Object obj: objArray) {
 228  0 
             buffer.append(obj.toString());
 229  0 
             buffer.append(SystemUtils.LINE_SEPARATOR);
 230   
         }
 231  0 
         return buffer.toString();
 232   
     }
 233   
 
 234   
     // Only used as Commons Lang is an unwanted dependancy for JDBC drivers.
 235   
     protected static void notNull(Object value, String message) {
 236  360132 
         if (value == null) {
 237  0 
             throw new IllegalArgumentException(message);
 238   
         }
 239  360132 
     }
 240   
 
 241   
 }
Report generated by Cobertura 2.0.3 on 11/22/15 10:14 AM.