Let's do it cleaner and use several DynamicParameter implementations

Author: pesse

build.gradle.kts

@@ -38,6 +38,7 @@ repositories {
         }
     }
     mavenCentral()
+    jcenter()
 }
 
 dependencies {
@@ -55,6 +56,9 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter:$junitVersion")
     testImplementation("org.hamcrest:hamcrest:2.1")
 
+    // Mockito
+    testCompile("org.mockito:mockito-core:2.+")
+
     // deployer for packagecloud
     deployerJars("io.packagecloud.maven.wagon:maven-packagecloud-wagon:0.0.6")
 }

src/main/java/org/utplsql/api/db/DynamicParameterList.java

@@ -1,14 +1,77 @@
 package org.utplsql.api.db;
 
+import oracle.jdbc.OracleConnection;
+
+import java.sql.CallableStatement;
+import java.sql.SQLException;
+import java.sql.Types;
 import java.util.LinkedHashMap;
-import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 public class DynamicParameterList {
 
-    LinkedHashMap<String, Consumer<Integer>> params;
+    LinkedHashMap<String, DynamicParameter> params;
+
+    interface DynamicParameter {
+        void setParam( CallableStatement statement, int index ) throws SQLException;
+    }
+
+    static class DynamicStringParameter implements DynamicParameter {
+        private final String value;
+
+        DynamicStringParameter( String value ) {
+            this.value = value;
+        }
+
+        @Override
+        public void setParam(CallableStatement statement, int index) throws SQLException {
+            if ( value == null ) {
+                statement.setNull(index, Types.VARCHAR);
+            } else {
+                statement.setString(index, value);
+            }
+        }
+    }
+    static class DynamicIntegerParameter implements DynamicParameter {
+        private final Integer value;
+
+        DynamicIntegerParameter( Integer value ) {
+            this.value = value;
+        }
+
+        @Override
+        public void setParam(CallableStatement statement, int index) throws SQLException {
+            if ( value == null ) {
+                statement.setNull(index, Types.INTEGER);
+            } else {
+                statement.setInt(index, value);
+            }
+        }
+    }
+    static class DynamicArrayParameter implements DynamicParameter {
+        private final Object[] value;
+        private final String customTypeName;
+        private final OracleConnection oraConnection;
+
+        DynamicArrayParameter( Object[] value, String customTypeName, OracleConnection oraConnection ) {
+            this.value = value;
+            this.customTypeName = customTypeName;
+            this.oraConnection = oraConnection;
+        }
+
+        @Override
+        public void setParam(CallableStatement statement, int index) throws SQLException {
+            if ( value == null ) {
+                statement.setNull(index, Types.ARRAY, customTypeName);
+            } else {
+                statement.setArray(
+                        index, oraConnection.createOracleArray(customTypeName, value)
+                );
+            }
+        }
+    }
 
-    DynamicParameterList(LinkedHashMap<String, Consumer<Integer>> params) {
+    DynamicParameterList(LinkedHashMap<String, DynamicParameter> params) {
         this.params = params;
     }
 
@@ -18,10 +81,10 @@ public String getSql() {
                 .collect(Collectors.joining(", "));
     }
 
-    public void applyFromIndex( int startIndex ) {
+    public void setParamsStartWithIndex(CallableStatement statement, int startIndex ) throws SQLException {
         int index = startIndex;
-        for ( Consumer<Integer> function : params.values() ) {
-            function.accept(index++);
+        for ( DynamicParameter param : params.values() ) {
+            param.setParam(statement, index++);
         }
     }
 

src/main/java/org/utplsql/api/db/DynamicParameterListBuilder.java

@@ -1,20 +1,33 @@
 package org.utplsql.api.db;
 
+import oracle.jdbc.OracleConnection;
+
 import java.util.LinkedHashMap;
-import java.util.function.Consumer;
 
 public class DynamicParameterListBuilder {
 
-    private LinkedHashMap<String, Consumer<Integer>> params = new LinkedHashMap<>();
+    private LinkedHashMap<String, DynamicParameterList.DynamicParameter> params = new LinkedHashMap<>();
+    private boolean addIfNullOrEmpty = true;
 
     private DynamicParameterListBuilder() {
 
     }
 
-    public DynamicParameterListBuilder addParameter(String identifier, Consumer<Integer> function) {
-
-        params.put(identifier, function);
+    public DynamicParameterListBuilder onlyAddIfNotEmpty() {
+        addIfNullOrEmpty = false;
+        return this;
+    }
 
+    public DynamicParameterListBuilder add( String identifier, String value ) {
+        params.put(identifier, new DynamicParameterList.DynamicStringParameter(value));
+        return this;
+    }
+    public DynamicParameterListBuilder add( String identifier, Integer value ) {
+        params.put(identifier, new DynamicParameterList.DynamicIntegerParameter(value));
+        return this;
+    }
+    public DynamicParameterListBuilder add(String identifier, Object[] value, String customTypeName, OracleConnection oraConnection ) {
+        params.put(identifier, new DynamicParameterList.DynamicArrayParameter(value, customTypeName, oraConnection));
         return this;
     }
 

src/test/java/org/utplsql/api/db/DynamicParameterListTest.java

@@ -1,29 +1,37 @@
 package org.utplsql.api.db;
 
+import oracle.jdbc.OracleConnection;
 import org.junit.jupiter.api.Test;
 
-import java.util.ArrayList;
+import java.sql.CallableStatement;
+import java.sql.SQLException;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 public class DynamicParameterListTest {
 
     @Test
-    void firstTest() {
+    void callWithThreeDifferentTypes() throws SQLException {
 
-        final ArrayList<Object> resultArray = new ArrayList<>();
+        CallableStatement mockedStatement = mock(CallableStatement.class);
+        OracleConnection mockedConn = mock(OracleConnection.class);
+
+        Object[] numArr = new Object[]{1, 2};
 
         DynamicParameterList parameterList = DynamicParameterListBuilder.create()
-                .addParameter("a_object_owner", i -> resultArray.add(i + ": MyOwner"))
-                .addParameter("a_num_param", i -> resultArray.add( i + ": 123"))
+                .add("a_object_owner", "MyOwner")
+                .add("a_num_param", 123)
+                .add("a_num_array", numArr, "MY_NUM_ARR", mockedConn)
                 .build();
 
-        parameterList.applyFromIndex(5);
-        assertEquals("a_object_owner = ?, a_num_param = ?", parameterList.getSql());
+        assertEquals("a_object_owner = ?, a_num_param = ?, a_num_array = ?", parameterList.getSql());
 
-        ArrayList<Object> expectedList = new ArrayList<>();
-        expectedList.add("5: MyOwner");
-        expectedList.add("6: 123");
-        assertEquals( expectedList, resultArray);
+        parameterList.setParamsStartWithIndex(mockedStatement, 5);
+        verify(mockedStatement).setString(5, "MyOwner");
+        verify(mockedStatement).setInt(6, 123);
+        verify(mockedConn).createOracleArray("MY_NUM_ARR", numArr);
+        verify(mockedStatement).setArray(7, null);
     }
 }