Merge pull request #4 from Nordstrom/pr/add-sproc-support

Pr/add sproc support

Author: sbabcoc

src/main/java/com/nordstrom/common/jdbc/DatabaseUtils.java

@@ -1,52 +1,76 @@
 package com.nordstrom.common.jdbc;
 
+import java.sql.CallableStatement;
 import java.sql.Connection;
 import java.sql.Driver;
 import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Iterator;
+import java.util.Objects;
 import java.util.ServiceLoader;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import com.nordstrom.common.base.UncheckedThrow;
+import com.nordstrom.common.jdbc.Param.Mode;
 
 import java.sql.PreparedStatement;
 
 /**
- * This utility class provides facilities that enable you to define collections of database queries and
- * execute them easily. Query collections are defined as Java enumeration that implement the {@link QueryAPI}
- * interface: <ul>
+ * This utility class provides facilities that enable you to define collections of database queries and stored
+ * procedures in an easy-to-execute format.
+ * <p>
+ * Query collections are defined as Java enumerations that implement the {@link QueryAPI}
+ * interface:
+ * <ul>
  * <li>{@link QueryAPI#getQueryStr() getQueryStr} - Get the query string for this constant. This is the actual query
  *     that's sent to the database.</li>
  * <li>{@link QueryAPI#getArgNames() getArgNames} - Get the names of the arguments for this query. This provides
  *     diagnostic information if the incorrect number of arguments is specified by the client.</li>
- * <li>{@link QueryAPI#getArgCount() getArgCount} - Get the number of arguments required by this query. This enables
- *     {@link #executeQuery(Class, QueryAPI, Object[])} to verify that the correct number of arguments has been
- *     specified by the client.</li>
  * <li>{@link QueryAPI#getConnection() getConnection} - Get the connection string associated with this query. This
  *     eliminates the need for the client to provide this information.</li>
  * <li>{@link QueryAPI#getEnum() getEnum} - Get the enumeration to which this query belongs. This enables {@link 
  *     #executeQuery(Class, QueryAPI, Object[])} to retrieve the name of the query's enumerated constant for
  *     diagnostic messages.</li>
  * </ul>
- *
- * To maximize usability and configurability, we recommend the following implementation strategy for your query
- * collections: <ul>
- * <li>Define your query collection as an enumeration that implements {@link QueryAPI}.</li>
- * <li>Define each query constant with a property name and a name for each argument (if any).</li>
+ * <p>
+ * Store procedure collections are defined as Java enumerations that implement the {@link SProcAPI}
+ * interface: 
+ * <ul>
+ * <li>{@link SProcAPI#getSignature() getSignature} - Get the signature for this stored procedure object. This defines
+ *     the name of the stored procedure and the modes of its arguments. If the stored procedure accepts varargs, this
+ *     will also be indicated.</li>
+ * <li>{@link SProcAPI#getArgTypes() getArgTypes} - Get the argument types for this stored procedure object. </li>
+ * <li>{@link SProcAPI#getConnection() getConnection} - Get the connection string associated with this stored
+ *     procedure. This eliminates the need for the client to provide this information.</li>
+ * <li>{@link SProcAPI#getEnum() getEnum} - Get the enumeration to which this stored procedure belongs. This enables
+ *     {@link #executeStoredProcedure(Class, SProcAPI, Object[])} to retrieve the name of the stored procedured's
+ *     enumerated constant for diagnostic messages.</li>
+ * </ul>
+ * <p>
+ * To maximize usability and configurability, we recommend the following implementation strategy: <ul>
+ * <li>Define your collection as an enumeration: <ul>
+ *     <li>Query collections implement {@link QueryAPI}.</li>
+ *     <li>Stored procedure collections implement {@link SProcAPI}.</li>
+ *     </ul></li>
+ * <li>Define each constant: <ul>
+ *     <li>(query) Specify a property name and a name for each argument (if any).</li>
+ *     <li>(sproc) Declare the signature and the type for each argument (if any).</li>
+ *     </ul></li>
  * <li>To assist users of your queries, preface their names with a type indicator (<b>GET</b> or <b>UPDATE</b>).</li>
- * <li>Back the query collection with a configuration that implements the <b>{@code Settings API}</b>: <ul>
+ * <li>Back query collections with configurations that implement the <b>{@code Settings API}</b>: <ul>
  *     <li>groupId: com.nordstrom.test-automation.tools</li>
  *     <li>artifactId: settings</li>
  *     <li>className: com.nordstrom.automation.settings.SettingsCore</li>
- *     </ul>
- * </li>
- * <li>To support execution on multiple endpoints, implement {@link QueryAPI#getConnection() getConnection} with
- *     sub-configurations or other dynamic data sources (e.g. - web service).</li>
+ *     </ul></li>
+ * <li>To support execution on multiple endpoints, implement {@link QueryAPI#getConnection()} or {@link
+ *     SProcAPI#getConnection()} with sub-configurations or other dynamic data sources (e.g.
+ *     - web service).</li>
  * </ul>
  * <b>Query Collection Example</b>
- * <br><br>
+ * 
  * <pre>
  * public class OpctConfig extends {@code SettingsCore<OpctConfig.OpctValues>} {
  * 
@@ -110,11 +134,6 @@
  *         }
  * 
  *         {@code @Override}
- *         public int getArgCount() {
- *             return args.length;
- *         }
- * 
- *         {@code @Override}
  *         public String getConnection() {
  *             if (rmsQueries.contains(this)) {
  *                 return getRmsConnect();
@@ -166,11 +185,56 @@
  *     public static OpctConfig getConfig() {
  *         return OpctValues.config;
  *     }
+ * 
+ *     public enum SProcValues implements SProcAPI {
+ *         /** args: [  ] *&#47;
+ *         SHOW_SUPPLIERS("SHOW_SUPPLIERS()"),
+ *         /** args: [ coffee_name, supplier_name ] *&#47;
+ *         GET_SUPPLIER_OF_COFFEE("GET_SUPPLIER_OF_COFFEE(&gt;, &lt;)", Types.VARCHAR, Types.VARCHAR),
+ *         /** args: [ coffee_name, max_percent, new_price ] *&#47;
+ *         RAISE_PRICE("RAISE_PRICE(&gt;, &gt;, =)", Types.VARCHAR, Types.REAL, Types.NUMERIC),
+ *         /** args: [ str, val... ] *&#47;
+ *         IN_VARARGS("IN_VARARGS(&lt;, &gt;:)", Types.VARCHAR, Types.INTEGER),
+ *         /** args: [ val, str... ] *&#47;
+ *         OUT_VARARGS("OUT_VARARGS(&gt;, &lt;:)", Types.INTEGER, Types.VARCHAR);
+ * 
+ *         private int[] argTypes;
+ *         private String signature;
+ * 
+ *         SProcValues(String signature, int... argTypes) {
+ *             this.signature = signature;
+ *             
+ *             this.argTypes = argTypes;
+ *         }
+ * 
+ *         {@code @Override}
+ *         public String getSignature() {
+ *             return signature;
+ *         }
+ * 
+ *         {@code @Override}
+ *         public int[] getArgTypes () {
+ *             return argTypes;
+ *         }
+ * 
+ *         {@code @Override}
+ *         public String getConnection() {
+               return OpctValues.getRmsConnect();
+ *         }
+ * 
+ *         {@code @Override}
+ *         public {@code Enum<SProcValues>} getEnum() {
+ *             return this;
+ *         }
+ *     }
  * }
  * </pre>
  */
 public class DatabaseUtils {
 
+    private static Pattern SPROC_PATTERN = 
+                    Pattern.compile("([\\p{Alpha}_][\\p{Alpha}\\p{Digit}@$#_]*)(?:\\(([<>=](?:,\\s*[<>=])*)?(:)?\\))?");
+    
     private DatabaseUtils() {
         throw new AssertionError("DatabaseUtils is a static utility class that cannot be instantiated");
     }
@@ -211,7 +275,7 @@ public static int getInt(QueryAPI query, Object... queryArgs) {
      * 
      * @param query query object to execute
      * @param queryArgs replacement values for query place-holders
-     * @return row 1 / column 1 as string; 'null' if no rows were returned
+     * @return row 1 / column 1 as string; {@code null} if no rows were returned
      */
     public static String getString(QueryAPI query, Object... queryArgs) {
         return (String) executeQuery(String.class, query, queryArgs);
@@ -230,12 +294,12 @@ public static ResultPackage getResultPackage(QueryAPI query, Object... queryArgs
 
     /**
      * Execute the specified query with the supplied arguments, returning a result of the indicated type.
-     * <br><br>
+     * <p>
      * <b>TYPES</b>: Specific result types produce the following behaviors: <ul>
-     * <li>'null' - The query is executed as an update operation.</li>
+     * <li>{@code null} - The query is executed as an update operation.</li>
      * <li>{@link ResultPackage} - An object containing the connection, statement, and result set is returned</li>
      * <li>{@link Integer} - If rows were returned, row 1 / column 1 is returned as an Integer; otherwise -1</li>
-     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise 'null'</li>
+     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise {@code null}</li>
      * <li>For other types, {@link ResultSet#getObject(int, Class)} to return row 1 / column 1 as that type</li></ul>
      * 
      * @param resultType desired result type (see TYPES above)
@@ -246,7 +310,7 @@ public static ResultPackage getResultPackage(QueryAPI query, Object... queryArgs
      * when you're done with it to free up database and JDBC resources that were allocated for it. 
      */
     private static Object executeQuery(Class<?> resultType, QueryAPI query, Object... queryArgs) {
-        int expectCount = query.getArgCount();
+        int expectCount = query.getArgNames().length;
         int actualCount = queryArgs.length;
 
         if (actualCount != expectCount) {
@@ -267,51 +331,270 @@ private static Object executeQuery(Class<?> resultType, QueryAPI query, Object..
 
     /**
      * Execute the specified query with the supplied arguments, returning a result of the indicated type.
-     * <br><br>
+     * <p>
      * <b>TYPES</b>: Specific result types produce the following behaviors: <ul>
-     * <li>'null' - The query is executed as an update operation.</li>
+     * <li>{@code null} - The query is executed as an update operation.</li>
      * <li>{@link ResultPackage} - An object containing the connection, statement, and result set is returned</li>
      * <li>{@link Integer} - If rows were returned, row 1 / column 1 is returned as an Integer; otherwise -1</li>
-     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise 'null'</li>
+     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise {@code null}</li>
      * <li>For other types, {@link ResultSet#getObject(int, Class)} to return row 1 / column 1 as that type</li></ul>
      * 
      * @param resultType desired result type (see TYPES above)
      * @param connectionStr database connection string
      * @param queryStr a SQL statement that may contain one or more '?' IN parameter placeholders
-     * @param param an array of objects containing the input parameter values
+     * @param params an array of objects containing the input parameter values
      * @return for update operations, the number of rows affected; for query operations, an object of the indicated type<br>
      * <b>NOTE</b>: If you specify {@link ResultPackage} as the result type, it's recommended that you close this object
      * when you're done with it to free up database and JDBC resources that were allocated for it. 
      */
-    public static Object executeQuery(Class<?> resultType, String connectionStr, String queryStr, Object... param) {
-        Object result = null;
-        boolean failed = false;
+    public static Object executeQuery(Class<?> resultType, String connectionStr, String queryStr, Object... params) {
+        try {
+            Connection connection = getConnection(connectionStr);
+            PreparedStatement statement = connection.prepareStatement(queryStr);
+            
+            for (int i = 0; i < params.length; i++) {
+                statement.setObject(i + 1, params[i]);
+            }
+            
+            return executeStatement(resultType, connection, statement);
+        } catch (SQLException e) {
+            throw UncheckedThrow.throwUnchecked(e);
+        }
+    }
+    
+    /**
+     * Execute the specified stored procedure object with supplied parameters
+     * 
+     * @param sproc stored procedure object to execute
+     * @param params an array of objects containing the input parameter values
+     * @return row 1 / column 1 as integer; -1 if no rows were returned
+     */
+    public static int getInt(SProcAPI sproc, Object... params) {
+        Integer result = (Integer) executeStoredProcedure(Integer.class, sproc, params);
+        return (result != null) ? result.intValue() : -1;
+    }
+    
+    /**
+     * Execute the specified stored procedure object with supplied parameters
+     * 
+     * @param sproc stored procedure object to execute
+     * @param params an array of objects containing the input parameter values
+     * @return row 1 / column 1 as string; {@code null} if no rows were returned
+     */
+    public static String getString(SProcAPI sproc, Object... params) {
+        return (String) executeStoredProcedure(String.class, sproc, params);
+    }
+    
+    /**
+     * Execute the specified stored procedure object with supplied parameters
+     * 
+     * @param sproc stored procedure object to execute
+     * @param params an array of objects containing the input parameter values
+     * @return {@link ResultPackage} object
+     */
+    public static ResultPackage getResultPackage(SProcAPI sproc, Object... params) {
+        return (ResultPackage) executeStoredProcedure(ResultPackage.class, sproc, params);
+    }
+    
+    /**
+     * Execute the specified stored procedure with the specified arguments, returning a result of the indicated type.
+     * <p>
+     * <b>TYPES</b>: Specific result types produce the following behaviors: <ul>
+     * <li>{@link ResultPackage} - An object containing the connection, statement, and result set is returned</li>
+     * <li>{@link Integer} - If rows were returned, row 1 / column 1 is returned as an Integer; otherwise -1</li>
+     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise {@code null}</li>
+     * <li>For other types, {@link ResultSet#getObject(int, Class)} to return row 1 / column 1 as that type</li></ul>
+     * 
+     * @param resultType desired result type (see TYPES above)
+     * @param sproc stored procedure object to execute
+     * @param params an array of objects containing the input parameter values
+     * @return an object of the indicated type<br>
+     * <b>NOTE</b>: If you specify {@link ResultPackage} as the result type, it's recommended that you close this object
+     * when you're done with it to free up database and JDBC resources that were allocated for it. 
+     */
+    public static Object executeStoredProcedure(Class<?> resultType, SProcAPI sproc, Object... params) {
+        Objects.requireNonNull(resultType, "[resultType] argument must be non-null");
 
-        Connection connection = null;
-        PreparedStatement statement = null;
-        ResultSet resultSet = null;
+        String[] args = {};
+        String sprocName = null;
+        boolean hasVarArgs = false;
+        int[] argTypes = sproc.getArgTypes();
+        String signature = sproc.getSignature();
+        Matcher matcher = SPROC_PATTERN.matcher(signature);
+        
+        String message = null;
+        if (matcher.matches()) {
+            sprocName = matcher.group(1);
+            hasVarArgs = (matcher.group(3) != null);
+            if (matcher.group(2) != null) {
+                args = matcher.group(2).split(",\\s");
+            } else {
+                if (hasVarArgs) {
+                    message = String.format("VarArgs indicated with no placeholder in signature for %s: %s",
+                            sproc.getEnum().name(), signature);
+                }
+            }
+        } else {
+            message = String.format("Unsupported stored procedure signature for %s: %s",
+                            sproc.getEnum().name(), signature);
+        }
+        
+        if (message != null) {
+            throw new IllegalArgumentException(message);
+        }
+        
+        int argsCount = args.length;
+        int typesCount = argTypes.length;
+        int parmsCount = params.length;
+        
+        int minCount = typesCount;
+        
+        // if unbalanced args/types
+        if (argsCount != typesCount) {
+            message = String.format(
+                            "Signature argument count differs from declared type count for %s%s: "
+                                            + "signature: %d; declared: %d",
+                            sproc.getEnum().name(), Arrays.toString(argTypes), argsCount, typesCount);
+        } else if (hasVarArgs) {
+            minCount -= 1;
+            if (parmsCount < minCount) {
+                message = String.format(
+                                "Insufficient arguments count for %s%s: minimum: %d; actual: %d",
+                                sproc.getEnum().name(), Arrays.toString(argTypes), minCount, parmsCount);
+            }
+        } else if (parmsCount != typesCount) {
+            if (typesCount == 0) {
+                message = "No arguments expected for " + sproc.getEnum().name();
+            } else {
+                message = String.format(
+                                "Incorrect arguments count for %s%s: expect: %d; actual: %d",
+                                sproc.getEnum().name(), Arrays.toString(argTypes), typesCount, parmsCount);
+            }
+        }
+        
+        if (message != null) {
+            throw new IllegalArgumentException(message);
+        }
+        
+        Param[] parmArray = Param.array(parmsCount);
+        
+        int i;
+        
+        // process declared parameters
+        for (i = 0; i < minCount; i++) {
+            Mode mode = Mode.fromChar(args[i].charAt(0));
+            parmArray[i] = Param.create(mode, argTypes[i], params[i]);
+        }
+        
+        // handle varargs parameters
+        for (int j = i; j < parmsCount; j++) {
+            Mode mode = Mode.fromChar(args[i].charAt(0));
+            parmArray[j] = Param.create(mode, argTypes[i], params[j]);
+        }
+        
+        return executeStoredProcedure(resultType, sproc.getConnection(), sprocName, parmArray);
+    }
+    
+    /**
+     * Execute the specified stored procedure with the supplied arguments, returning a result of the indicated type.
+     * <p>
+     * <b>TYPES</b>: Specific result types produce the following behaviors: <ul>
+     * <li>{@link ResultPackage} - An object containing the connection, statement, and result set is returned</li>
+     * <li>{@link Integer} - If rows were returned, row 1 / column 1 is returned as an Integer; otherwise -1</li>
+     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise {@code null}</li>
+     * <li>For other types, {@link ResultSet#getObject(int, Class)} to return row 1 / column 1 as that type</li></ul>
+     * 
+     * @param resultType desired result type (see TYPES above)
+     * @param connectionStr database connection string
+     * @param sprocName name of the stored procedure to be executed
+     * @param params an array of objects containing the input parameter values
+     * @return an object of the indicated type<br>
+     * <b>NOTE</b>: If you specify {@link ResultPackage} as the result type, it's recommended that you close this object
+     * when you're done with it to free up database and JDBC resources that were allocated for it. 
+     */
+    public static Object executeStoredProcedure(Class<?> resultType, String connectionStr, String sprocName, Param... params) {
+        Objects.requireNonNull(resultType, "[resultType] argument must be non-null");
+        
+        StringBuilder sprocStr = new StringBuilder("{call ").append(sprocName).append("(");
+        
+        String placeholder = "?";
+        for (int i = 0; i < params.length; i++) {
+            sprocStr.append(placeholder);
+            placeholder = ",?";
+        }
+        
+        sprocStr.append(")}");
 
         try {
-            connection = getConnection(connectionStr);
-            statement = connection.prepareStatement(queryStr); //NOSONAR
+            Connection connection = getConnection(connectionStr);
+            CallableStatement statement = connection.prepareCall(sprocStr.toString());
 
-            for (int i = 0; i < param.length; i++) {
-                statement.setObject(i + 1, param[i]);
+            for (int i = 0; i < params.length; i++) {
+                params[i].set(statement, i + 1);
             }
 
+            return executeStatement(resultType, connection, statement);
+        } catch (SQLException e) {
+            throw UncheckedThrow.throwUnchecked(e);
+        }
+    }
+    
+    /**
+     * Execute the specified prepared statement, returning a result of the indicated type.
+     * <p>
+     * <b>TYPES</b>: Specific result types produce the following behaviors: <ul>
+     * <li>{@code null} - The prepared statement is a query to be executed as an update operation.</li>
+     * <li>{@link ResultPackage} - An object containing the connection, statement, and result set is returned</li>
+     * <li>{@link Integer} - If rows were returned, row 1 / column 1 is returned as an Integer; otherwise -1</li>
+     * <li>{@link String} - If rows were returned, row 1 / column 1 is returned as an String; otherwise {@code null}</li>
+     * <li>For other types, {@link ResultSet#getObject(int, Class)} to return row 1 / column 1 as that type</li></ul>
+     * <p>
+     * <b>NOTE</b>: For all result types except {@link ResultPackage}, the specified connection and statement, as well
+     * as the result set from executing the statement, are closed prior to returning the result. 
+     * 
+     * @param resultType desired result type (see TYPES above)
+     * @param connectionStr database connection string
+     * @param statement prepared statement to be executed (query or store procedure)
+     * @return for update operations, the number of rows affected; for query operations, an object of the indicated type<br>
+     * <b>NOTE</b>: If you specify {@link ResultPackage} as the result type, it's recommended that you close this object
+     * when you're done with it to free up database and JDBC resources that were allocated for it. 
+     */
+    private static Object executeStatement(Class<?> resultType, Connection connection, PreparedStatement statement) {
+        Object result = null;
+        boolean failed = false;
+        
+        ResultSet resultSet = null;
+        
+        try {
             if (resultType == null) {
                 result = Integer.valueOf(statement.executeUpdate());
             } else {
-                resultSet = statement.executeQuery(); //NOSONAR
-                
-                if (resultType == ResultPackage.class) {
-                    result = new ResultPackage(connection, statement, resultSet); //NOSONAR
-                } else if (resultType == Integer.class) {
-                    result = Integer.valueOf((resultSet.next()) ? resultSet.getInt(1) : -1);
-                } else if (resultType == String.class) {
-                    result = (resultSet.next()) ? resultSet.getString(1) : null;
+                if (statement instanceof CallableStatement) {
+                    if (statement.execute()) {
+                        resultSet = statement.getResultSet(); //NOSONAR
+                    }
+                    
+                    if (resultType == ResultPackage.class) {
+                        result = new ResultPackage(connection, statement, resultSet); //NOSONAR
+                    } else if (resultType == Integer.class) {
+                        result = ((CallableStatement) statement).getInt(1);
+                    } else if (resultType == String.class) {
+                        result = ((CallableStatement) statement).getString(1);
+                    } else {
+                        result = ((CallableStatement) statement).getObject(1);
+                    }
                 } else {
-                    result = (resultSet.next()) ? resultSet.getObject(1, resultType) : null;
+                    resultSet = statement.executeQuery(); //NOSONAR
+                    
+                    if (resultType == ResultPackage.class) {
+                        result = new ResultPackage(connection, statement, resultSet); //NOSONAR
+                    } else if (resultType == Integer.class) {
+                        result = Integer.valueOf((resultSet.next()) ? resultSet.getInt(1) : -1);
+                    } else if (resultType == String.class) {
+                        result = (resultSet.next()) ? resultSet.getString(1) : null;
+                    } else {
+                        result = (resultSet.next()) ? resultSet.getObject(1, resultType) : null;
+                    }
                 }
             }
 
@@ -375,19 +658,12 @@ public interface QueryAPI {
         String getQueryStr();
 
         /**
-         * Get the argument name for this query object
+         * Get the argument names for this query object.
          *  
          * @return query object argument names
          */
         String[] getArgNames();
 
-        /**
-         * Get the count of arguments for this query object.
-         * 
-         * @return query object argument count
-         */
-        int getArgCount();
-        
         /**
          * Get the database connection string for this query object.
          * 
@@ -403,6 +679,55 @@ public interface QueryAPI {
         Enum<? extends QueryAPI> getEnum(); //NOSONAR
     }
 
+    /**
+     * This interface defines the API supported by database stored procedure collections
+     */
+    public interface SProcAPI {
+        
+        /**
+         * Get the signature for this stored procedure object.
+         * <p>
+         * Each argument place holder in the stored procedure signature indicates the mode of the corresponding
+         * parameter: 
+         * 
+         * <ul>
+         *     <li>'&gt;' : This argument is an IN parameter</li>
+         *     <li>'&lt;' : This argument is an OUT parameter</li>
+         *     <li>'=' : This argument is an INOUT parameter</li>
+         * </ul>
+         * 
+         * For example:
+         * 
+         * <blockquote>RAISE_PRICE(&gt;, &lt;, =)</blockquote>
+         * 
+         * The first and second arguments are IN parameters, and the third argument is an INOUT parameter.
+         * 
+         * @return stored procedure signature
+         */
+        String getSignature();
+        
+        /**
+         * Get the argument types for this stored procedure object.
+         * 
+         * @return stored procedure argument types
+         */
+        int[] getArgTypes();
+        
+        /**
+         * Get the database connection string for this stored procedure object.
+         * 
+         * @return stored procedure connection string
+         */
+        String getConnection();
+        
+        /**
+         * Get the implementing enumerated constant for this stored procedure object.
+         * 
+         * @return stored procedure enumerated constant
+         */
+        Enum<? extends SProcAPI> getEnum(); //NOSONAR
+    }
+    
     /**
      * This class defines a package of database objects associated with a query. These include:<ul>
      * <li>{@link Connection} object</li>
@@ -428,6 +753,21 @@ private ResultPackage(Connection connection, PreparedStatement statement, Result
             this.resultSet = resultSet;
         }
 
+        public Connection getConnection() {
+            return connection;
+        }
+        
+        public PreparedStatement getStatement() {
+            return statement;
+        }
+        
+        public CallableStatement getCallable() {
+            if (statement instanceof CallableStatement) {
+                return (CallableStatement) statement;
+            }
+            throw new UnsupportedOperationException("The statement of this package is not a CallableStatement");
+        }
+        
         /**
          * Get the result set object of this package.
          * 

src/main/java/com/nordstrom/common/jdbc/Param.java

@@ -0,0 +1,533 @@
+package com.nordstrom.common.jdbc;
+
+import java.math.BigDecimal;
+import java.sql.CallableStatement;
+import java.sql.SQLException;
+import java.sql.Types;
+
+/**
+ * This class is used to encapsulate parameters for stored procedure calls. In addition to parameter value, instances
+ * of this class define {@link Mode parameter mode} (IN/OUT/INOUT) and {@link Types parameter type} (e.g. - INTEGER).
+ */
+public class Param {
+    
+    private Mode mode = Mode.IN;
+    private int paramType;
+    private Object inputValue;
+    
+    /**
+     * Constructor: Private, to discourage direct instantiation.
+     */
+    private Param() {
+    }
+    
+    /**
+     * Instantiate a parameter of the indicated mode and type with the specified value.
+     * 
+     * @param mode parameter {@link Mode mode}
+     * @param paramType parameter {@link Types type}
+     * @param inputValue parameter value
+     * @return new {@link Param} object
+     */
+    public static Param create(Mode mode, int paramType, Object inputValue) {
+        if (mode == Mode.OUT) {
+            return Param.out(paramType);
+        } else if (mode == Mode.INOUT) {
+            return Param.inOut(paramType, inputValue);
+        }
+        return Param.in(paramType, inputValue);
+    }
+    
+    /**
+     * Instantiate an IN parameter of the indicated type with the specified value.
+     * 
+     * @param paramType parameter {@link Types type}
+     * @param inputValue parameter value
+     * @return new {@link Param} object
+     */
+    public static Param in(int paramType, Object inputValue) {
+        Param parameter = new Param();
+        parameter.mode = Mode.IN;
+        parameter.paramType = paramType;
+        parameter.inputValue = inputValue;
+        return parameter;
+    }
+    
+    /**
+     * Instantiate an OUT parameter of the indicated type.
+     * 
+     * @param paramType parameter {@link Types type}
+     * @return new {@link Param} object
+     */
+    public static Param out(int paramType) {
+        Param parameter = new Param();
+        parameter.mode = Mode.OUT;
+        parameter.paramType = paramType;
+        return parameter;
+    }
+    
+    /**
+     * Instantiate an INOUT parameter of the indicated type with the specified value.
+     * 
+     * @param paramType parameter {@link Types type}
+     * @param inputValue parameter value
+     * @return new {@link Param} object
+     */
+    public static Param inOut(int paramType, Object inputValue) {
+        Param parameter = new Param();
+        parameter.mode = Mode.INOUT;
+        parameter.inputValue = inputValue;
+        parameter.paramType = paramType;
+        return parameter;
+    }
+    
+    /**
+     * Allocate an array with the specified capacity of {@link Param} objects.
+     * 
+     * @param size desired array capacity
+     * @return {@link Param} array of specified capacity
+     */
+    static Param[] array(int size) {
+        return new Param[size];
+    }
+    
+    /**
+     * Store this parameter at the indicated index for the specified callable statement.
+     *  
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    public void set(CallableStatement sproc, int index) throws SQLException {
+        if (isOutput()) {
+            sproc.registerOutParameter(index, paramType);
+        }
+        
+        if (isInput()) {
+            if (inputValue == null) {
+                sproc.setNull(index, paramType);
+            } else {
+                switch (paramType) {
+    
+                    case Types.CHAR:
+                    case Types.VARCHAR:
+                    case Types.LONGVARCHAR:
+                        setCharString(sproc, index);
+                        break;
+    
+                    case Types.NCHAR:
+                    case Types.NVARCHAR:
+                    case Types.LONGNVARCHAR:
+                        setNCharString(sproc, index);
+                        break;
+    
+                    case Types.BINARY:
+                    case Types.VARBINARY:
+                    case Types.LONGVARBINARY:
+                        setBinary(sproc, index);
+                        break;
+    
+                    case Types.BIT:
+                    case Types.BOOLEAN:
+                        setBoolean(sproc, index);
+                        break;
+    
+                    case Types.SMALLINT:
+                        setSmallInt(sproc, index);
+                        break;
+    
+                    case Types.INTEGER:
+                        setInteger(sproc, index);
+                        break;
+    
+                    case Types.BIGINT:
+                        setBigInt(sproc, index);
+                        break;
+    
+                    case Types.REAL:
+                        setReal(sproc, index);
+                        break;
+    
+                    case Types.DOUBLE:
+                    case Types.FLOAT:
+                        setDouble(sproc, index);
+                        break;
+    
+                    case Types.DECIMAL:
+                    case Types.NUMERIC:
+                        setDecimal(sproc, index);
+                        break;
+    
+                    case Types.DATE:
+                        setDate(sproc, index);
+                        break;
+    
+                    case Types.TIME:
+                        setTime(sproc, index);
+                        break;
+    
+                    case Types.TIMESTAMP:
+                        setTimestamp(sproc, index);
+                        break;
+    
+                    case Types.OTHER:
+                    case Types.JAVA_OBJECT:
+                        setJavaObject(sproc, index);
+                        break;
+    
+                    default:
+                        throw new UnsupportedOperationException("Specified parameter type ["
+                                        + paramType + "] is unsupported");
+                }
+            }
+        }
+    }
+    
+    /**
+     * Store this character string parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setCharString(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof String) {
+            sproc.setString(index, (String) inputValue); 
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a string");
+        }
+    }
+    
+    /**
+     * Store this character string parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setNCharString(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof String) {
+            sproc.setNString(index, (String) inputValue); 
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a string");
+        }
+    }
+    
+    /**
+     * Store this binary parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setBinary(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof byte[]) {
+            sproc.setBytes(index, (byte[]) inputValue); 
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not an array of bytes");
+        }
+    }
+    
+    /**
+     * Store this boolean parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setBoolean(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Boolean) {
+            sproc.setBoolean(index, (Boolean) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a boolean");
+        }
+    }
+    
+    /**
+     * Store this small integer parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setSmallInt(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Short) {
+            sproc.setShort(index, (Short) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a small integer (short)");
+        }
+    }
+    
+    /**
+     * Store this integer parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setInteger(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Integer) {
+            sproc.setInt(index, (Integer) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not an integer");
+        }
+    }
+    
+    /**
+     * Store this big integer parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setBigInt(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Long) {
+            sproc.setLong(index, (Long) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a big integer (long)");
+        }
+    }
+    
+    /**
+     * Store this single-precision floating-point parameter at the indicated index for the specified callable
+     * statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setReal(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Float) {
+            sproc.setFloat(index, (Float) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a single-precision float (float)");
+        }
+    }
+    
+    /**
+     * Store this double-precision floating-point parameter at the indicated index for the specified callable
+     * statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setDouble(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof Double) {
+            sproc.setDouble(index, (Double) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a double-precision float (double)");
+        }
+    }
+    
+    /**
+     * Store this decimal parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setDecimal(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof BigDecimal) {
+            sproc.setBigDecimal(index, (BigDecimal) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a decimal (BigDecimal)");
+        }
+    }
+    
+    /**
+     * Store this SQL Date parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setDate(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof java.sql.Date) {
+            sproc.setDate(index, (java.sql.Date) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a SQL Date object");
+        }
+    }
+    
+    /**
+     * Store this SQL Time parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setTime(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof java.sql.Time) {
+            sproc.setTime(index, (java.sql.Time) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a SQL Time object");
+        }
+    }
+    
+    /**
+     * Store this SQL Timestamp parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setTimestamp(CallableStatement sproc, int index) throws SQLException {
+        if (inputValue instanceof java.sql.Timestamp) {
+            sproc.setTimestamp(index, (java.sql.Timestamp) inputValue);
+        } else {
+            throw new IllegalArgumentException("Specified parameter value is not a SQL Timestamp object");
+        }
+    }
+    
+    /**
+     * Store this Java object parameter at the indicated index for the specified callable statement.
+     * 
+     * @param sproc target {@link CallableStatement} object
+     * @param index parameter index
+     * @throws SQLException if the specified index is not valid; if a database access error occurs or this method is
+     *         called on a closed {@link CallableStatement}
+     */
+    private void setJavaObject(CallableStatement sproc, int index) throws SQLException {
+        sproc.setObject(index, inputValue);
+    }
+    
+    /**
+     * Get the {@link Mode} of this parameter (IN/OUT/INOUT)
+     * 
+     * @return parameter mode
+     */
+    public Mode getMode() {
+        return mode;
+    }
+    
+    /**
+     * Determine if this parameter is an input.
+     * 
+     * @return {@code true} if this parameter is an input; otherwise {@code false}
+     */
+    public boolean isInput() {
+        return mode.isInput();
+    }
+    
+    /**
+     * Determine if this parameter is an output.
+     * 
+     * @return {@code true} if this parameter is an output; otherwise {@code false}
+     */
+    public boolean isOutput() {
+        return mode.isOutput();
+    }
+    
+    /**
+     * Get the input value of this parameter.
+     * 
+     * @return parameter input value
+     */
+    public Object getInValue() {
+        return inputValue;
+    }
+    
+    /**
+     * Get the value {@link Types type} of this parameter.
+     * 
+     * @return parameter {@link Types type}
+     */
+    public int getParamType() {
+        return paramType;
+    }
+    
+    /**
+     * This enumeration defines the stored procedure parameter modes with their associated placeholder characters.
+     */
+    public enum Mode {
+        /** placeholder: '>' */
+        IN('>', Mode.INPUT),
+        /** placeholder: '<' */
+        OUT('<', Mode.OUTPUT),
+        /** placeholder: '=' */
+        INOUT('=', Mode.INPUT | Mode.OUTPUT);
+        
+        private static final int INPUT = 1;
+        private static final int OUTPUT = 2;
+        
+        private char chr;
+        private int val;
+        
+        /**
+         * Constructor
+         * 
+         * @param chr placeholder character
+         * @param val directionality flags
+         */
+        Mode(char chr, int val) {
+            this.chr = chr;
+            this.val = val;
+        }
+        
+        /**
+         * Get the placeholder character for this parameter mode.
+         * 
+         * @return parameter mode placeholder
+         */
+        public char chr() {
+            return chr;
+        }
+        
+        /**
+         * Get the directionality flags for this parameter mode.
+         * 
+         * @return parameter mode directionality
+         */
+        public int val() {
+            return val;
+        }
+        
+        /**
+         * Determine if this mode represents an input parameter.
+         * 
+         * @return {@code true} if this is an input mode; otherwise {@code false}
+         */
+        public boolean isInput() {
+            return ((val & INPUT) == INPUT);
+        }
+        
+        /**
+         * Determine if this mode represents an output parameter.
+         * 
+         * @return {@code true} if this is an output mode; otherwise {@code false}
+         */
+        public boolean isOutput() {
+            return ((val & OUTPUT) == OUTPUT);
+        }
+        
+        /**
+         * Get the parameter mode constant that corresponds to the specified placeholder character.
+         * 
+         * @param chr parameter mode placeholder
+         * @return parameter mode constant
+         */
+        public static Mode fromChar(char chr) {
+            for (Mode thisMode : values()) {
+                if (thisMode.chr == chr) {
+                    return thisMode;
+                }
+            }
+            throw new IllegalArgumentException("Specified parameter mode placeholder '" + chr + "' is unsupported");
+        }
+    }
+}

src/test/java/com/nordstrom/common/jdbc/DatabaseUtilsTest.java

@@ -1,14 +1,19 @@
 package com.nordstrom.common.jdbc;
 
+import static org.testng.Assert.assertEquals;
+
+import java.sql.CallableStatement;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.sql.Types;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 import com.nordstrom.common.jdbc.DatabaseUtils.QueryAPI;
 import com.nordstrom.common.jdbc.DatabaseUtils.ResultPackage;
+import com.nordstrom.common.jdbc.DatabaseUtils.SProcAPI;
 
 public class DatabaseUtilsTest {
 
@@ -76,6 +81,31 @@ public void updateRows() {
     }
 
     @Test(dependsOnMethods={"updateRows"})
+    public void showAddresses() {
+        try {
+            DatabaseUtils.update(TestQuery.SHOW_ADDRESSES);
+        } catch (Exception e) {
+        }
+        
+        ResultPackage pkg = DatabaseUtils.getResultPackage(TestSProc.SHOW_ADDRESSES);
+        
+        int rowCount = 0;
+        try {
+            while (pkg.getResultSet().next()) {
+                rowCount++;
+                int num = pkg.getResultSet().getInt("num");
+                String addr = pkg.getResultSet().getString("addr");
+                System.out.println("addr" + rowCount + ": " + num + " " + addr);
+            }
+        } catch (SQLException e) {
+        }
+        pkg.close();
+        
+        DatabaseUtils.update(TestQuery.DROP_PROC_SHOW);
+        assertEquals(rowCount, 2);
+    }
+    
+    @Test(dependsOnMethods={"showAddresses"})
     public void getInt() {
         DatabaseUtils.getInt(TestQuery.GET_NUM);
     }
@@ -96,14 +126,86 @@ public void dropTable() {
         DatabaseUtils.update(TestQuery.DROP);
     }
 
+    @Test
+    public void testInVarargs() {
+        try {
+            DatabaseUtils.update(TestQuery.IN_VARARGS);
+        } catch (Exception e) {
+        }
+        
+        String result = DatabaseUtils.getString(TestSProc.IN_VARARGS, "", 5, 4, 3);
+        DatabaseUtils.update(TestQuery.DROP_PROC_IN);
+        assertEquals(result, "RESULT:  5 4 3");
+    }
+    
+    @Test()
+    public void testOutVarargs() throws SQLException {
+        try {
+            DatabaseUtils.update(TestQuery.OUT_VARARGS);
+        } catch (Exception e) {
+        }
+        
+        ResultPackage pkg = DatabaseUtils.getResultPackage(TestSProc.OUT_VARARGS, 5, 0, 0, 0);
+        
+        int[] out = new int[3];
+        out[0] = ((CallableStatement) pkg.getStatement()).getInt(2);
+        out[1] = ((CallableStatement) pkg.getStatement()).getInt(3);
+        out[2] = ((CallableStatement) pkg.getStatement()).getInt(4);
+        pkg.close();
+        
+        DatabaseUtils.update(TestQuery.DROP_PROC_OUT);
+        
+        assertEquals(out[0], 5);
+        assertEquals(out[1], 6);
+        assertEquals(out[2], 7);
+    }
+    
+    @Test
+    public void testInOutVarargs() throws SQLException {
+        try {
+            DatabaseUtils.update(TestQuery.INOUT_VARARGS);
+        } catch (Exception e) {
+        }
+        
+        ResultPackage pkg = DatabaseUtils.getResultPackage(TestSProc.INOUT_VARARGS, 5, 3, 10, 100);
+        
+        int[] out = new int[3];
+        out[0] = pkg.getCallable().getInt(2);
+        out[1] = pkg.getCallable().getInt(3);
+        out[2] = pkg.getCallable().getInt(4);
+        pkg.close();
+        
+        DatabaseUtils.update(TestQuery.DROP_PROC_INOUT);
+        
+        assertEquals(out[0], 8);
+        assertEquals(out[1], 15);
+        assertEquals(out[2], 105);
+    }
+    
     enum TestQuery implements QueryAPI {
         CREATE("create table location(num int, addr varchar(40))"),
         INSERT("insert into location values (?, ?)", "num", "addr"),
         UPDATE("update location set num=?, addr=? where num=?", "num", "addr", "whereNum"),
+        SHOW_ADDRESSES("create procedure SHOW_ADDRESSES() parameter style java "
+                        + "language java dynamic result sets 1 "
+                        + "external name 'com.nordstrom.common.jdbc.StoredProcedure.showAddresses'"),
+        DROP_PROC_SHOW("drop procedure SHOW_ADDRESSES"),
         GET_NUM("select num from location where addr='Union St.'"),
         GET_STR("select addr from location where num=1910"),
         GET_RESULT_PACKAGE("select * from location"),
-        DROP("drop table location");
+        DROP("drop table location"),
+        IN_VARARGS("create procedure IN_VARARGS(out result varchar( 32672 ), b int ...) "
+                        + "language java parameter style derby no sql deterministic "
+                        + "external name 'com.nordstrom.common.jdbc.StoredProcedure.inVarargs'"),
+        DROP_PROC_IN("drop procedure IN_VARARGS"),
+        OUT_VARARGS("create procedure OUT_VARARGS(seed int, out b int ...) "
+                        + "language java parameter style derby no sql deterministic "
+                        + "external name 'com.nordstrom.common.jdbc.StoredProcedure.outVarargs'"),
+        DROP_PROC_OUT("drop procedure OUT_VARARGS"),
+        INOUT_VARARGS("create procedure INOUT_VARARGS(seed int, inout b int ...) "
+                        + "language java parameter style derby no sql deterministic "
+                        + "external name 'com.nordstrom.common.jdbc.StoredProcedure.inoutVarargs'"),
+        DROP_PROC_INOUT("drop procedure INOUT_VARARGS");
 
         private String query;
         private String[] args;
@@ -123,11 +225,6 @@ public String[] getArgNames() {
             return args;
         }
 
-        @Override
-        public int getArgCount() {
-            return args.length;
-        }
-
         @Override
         public String getConnection() {
             return connection();
@@ -142,6 +239,41 @@ public static String connection() {
             return "jdbc:derby:@TestDB";
         }
     }
+    
+    enum TestSProc implements SProcAPI {
+        SHOW_ADDRESSES("SHOW_ADDRESSES()"),
+        IN_VARARGS("IN_VARARGS(<, >:)", Types.VARCHAR, Types.INTEGER),
+        OUT_VARARGS("OUT_VARARGS(>, <:)", Types.INTEGER, Types.INTEGER),
+        INOUT_VARARGS("INOUT_VARARGS(>, =:)", Types.INTEGER, Types.INTEGER);
+        
+        private int[] argTypes;
+        private String signature;
+        
+        TestSProc(String signature, int... argTypes) {
+            this.signature = signature;
+            this.argTypes = argTypes;
+        }
+
+        @Override
+        public String getSignature() {
+            return signature;
+        }
+
+        @Override
+        public int[] getArgTypes() {
+            return argTypes;
+        }
+
+        @Override
+        public String getConnection() {
+            return TestQuery.connection();
+        }
+
+        @Override
+        public Enum<? extends SProcAPI> getEnum() {
+            return this;
+        }
+    }
 
     /**
      * Prints details of an SQLException chain to <code>System.err</code>.

src/test/java/com/nordstrom/common/jdbc/StoredProcedure.java

@@ -0,0 +1,64 @@
+package com.nordstrom.common.jdbc;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class StoredProcedure {
+
+    public static void showAddresses(ResultSet[] rs) throws SQLException {
+        Connection con = DriverManager.getConnection("jdbc:default:connection");
+        String query = "select NUM, ADDR from LOCATION";
+        Statement stmt = con.createStatement();
+        rs[0] = stmt.executeQuery(query);
+    }
+
+    //////////////////////////
+    //
+    // IN, OUT, IN/OUT PARAMETERS
+    //
+    //////////////////////////
+
+    public static void inVarargs(String[] result, int... values) {
+        String retval;
+        if (values == null) {
+            retval = null;
+        } else if (values.length == 0) {
+            retval = null;
+        } else {
+            StringBuilder buffer = new StringBuilder();
+
+            buffer.append("RESULT: ");
+
+            for (int value : values) {
+                buffer.append(" " + Integer.toString(value));
+            }
+
+            retval = buffer.toString();
+        }
+
+        result[0] = retval;
+    }
+
+    public static void outVarargs(int seed, int[]... values) throws Exception {
+        if (values == null) {
+            return;
+        } else {
+            for (int i = 0; i < values.length; i++) {
+                values[i][0] = seed + i;
+            }
+        }
+    }
+
+    public static void inoutVarargs(int seed, int[]... values) throws Exception {
+        if (values == null) {
+            return;
+        } else {
+            for (int i = 0; i < values.length; i++) {
+                values[i][0] += seed;
+            }
+        }
+    }
+}