Add support for varargs

Author: sbabcoc

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

@@ -325,22 +325,6 @@ public static Object executeQuery(Class<?> resultType, String connectionStr, Str
     public static Object executeStoredProcedure(Class<?> resultType, SProcAPI sproc, Object... parms) {
         Objects.requireNonNull(resultType, "[resultType] argument must be non-null");
 
-        int typesCount = sproc.getArgCount();
-        int parmsCount = parms.length;
-        
-        if (parmsCount != typesCount) {
-            String message;
-            
-            if (typesCount == 0) {
-                message = "No arguments expected for " + sproc.getEnum().name();
-            } else {
-                message = String.format("Incorrect argument count for %s%s: expect: %d; actual: %d", 
-                        sproc.getEnum().name(), Arrays.toString(sproc.getArgTypes()), typesCount, parmsCount);
-            }
-            
-            throw new IllegalArgumentException(message);
-        }
-        
         String sprocName;
         String[] args = {};
         String signature = sproc.getSignature();
@@ -358,31 +342,47 @@ public static Object executeStoredProcedure(Class<?> resultType, SProcAPI sproc,
         }
 
         int argsCount = args.length;
+        int typesCount = sproc.getArgCount();
+        
+        // if unbalanced args/types
         if (argsCount != typesCount) {
             String message = String.format("Signature argument count differs from declared type count for %s%s: "
                             + "signature: %d; declared: %d", 
                             sproc.getEnum().name(), Arrays.toString(sproc.getArgTypes()), argsCount, typesCount);
             throw new IllegalArgumentException(message);
         }
 
+        int parmsCount = parms.length;
+        
+        // if parms specified with no matching types
+        if ((parmsCount > 0) && (typesCount == 0)) {
+            throw new IllegalArgumentException("No arguments expected for " + sproc.getEnum().name());
+        }
+        
+        // if fewer parms than types
+        if (parmsCount < typesCount) {
+            String message = String.format("Insufficient arguments count for %s%s: minimum: %d; actual: %d", 
+                    sproc.getEnum().name(), Arrays.toString(sproc.getArgTypes()), typesCount, parmsCount);
+            throw new IllegalArgumentException(message);
+        }
+        
         int[] argTypes = sproc.getArgTypes();
-        Param[] parmArray = Param.array(typesCount);
-        for (int i = 0; i < typesCount; i++) {
-            int type = argTypes[i];
-            Mode mode = Mode.fromChar(args[i].charAt(0));
-            switch (mode) {
-                case IN:
-                    parmArray[i] = Param.in(parms[i], type);
-                    break;
-
-                case OUT:
-                    parmArray[i] = Param.out(type);
-                    break;
-
-                case INOUT:
-                    parmArray[i] = Param.inOut(parms[i], type);
-                    break;
-            }
+        Param[] parmArray = Param.array(parmsCount);
+        
+        int i = 0;
+        int type = 0;
+        Mode mode = Mode.IN;
+        
+        // process declared parameters
+        for (i = 0; i < typesCount; i++) {
+            type = argTypes[i];
+            mode = Mode.fromChar(args[i].charAt(0));
+            parmArray[i] = Param.create(mode, type, parms[i]);
+        }
+        
+        // handle varargs parameters
+        for (; i < parmsCount; i++) {
+            parmArray[i] = Param.create(mode, type, parms[i]);
         }
 
         return executeStoredProcedure(resultType, sproc.getConnection(), sprocName, parmArray);

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

@@ -12,8 +12,8 @@
 public class Param {
 
     private Mode mode = Mode.IN;
-    private Object inputValue;
     private int paramType;
+    private Object inputValue;
 
     /**
      * Constructor: Private, to discourage direct instantiation.
@@ -22,17 +22,34 @@ private Param() {
     }
 
     /**
-     * Instantiate an IN parameter of the indicated type with the specified value.
+     * 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(Object inputValue, int paramType) {
+    public static Param in(int paramType, Object inputValue) {
         Param parameter = new Param();
         parameter.mode = Mode.IN;
-        parameter.inputValue = inputValue;
         parameter.paramType = paramType;
+        parameter.inputValue = inputValue;
         return parameter;
     }
 
@@ -52,11 +69,11 @@ public static Param out(int paramType) {
     /**
      * Instantiate an INOUT parameter of the indicated type with the specified value.
      * 
-     * @param inputValue parameter value
      * @param paramType parameter {@link Types type}
+     * @param inputValue parameter value
      * @return new {@link Param} object
      */
-    public static Param inOut(Object inputValue, int paramType) {
+    public static Param inOut(int paramType, Object inputValue) {
         Param parameter = new Param();
         parameter.mode = Mode.INOUT;
         parameter.inputValue = inputValue;