21 support for stored procedures (#22)

* Creating action to call stored procedure

* Adding integration test.

* Improving docs and changelog with procedure call action description

* Improving docs.

Author: denyshld

README.md

@@ -206,6 +206,26 @@ Checkbox ``Don't throw Error on an Empty Result`` allows to emit an empty respon
 ![image](https://user-images.githubusercontent.com/40201204/43644579-f593d1c8-9737-11e8-9b97-ee9e575a19f7.png)
 As an input metadata you will get a Primary Key field to provide the data inside as a clause value.
 
+### Execute stored procedure
+This action calls stored procedure from selected `DB Schema` and `Stored procedure` name
+#### Input fields description
+- **DB Schema** - a schema that contains a procedure to call. Must be selected from the dropdown list before `Stored procedure` name
+- **Stored procedure** - a name of a procedure to call, can be selected from the dropdown list
+
+Metadata generates automatically using `IN` & `IN OUT` procedure parameters for input, and `OUT` & `IN OUT` procedure parameters for output.
+
+As array fields this action now support ONLY:
+- CURSOR (as SQL type)
+- REF CURSOR (as ORACLE type)
+The result for this type of fields would be returned as an array of JSON objects.
+
+This action DOES NOT processing MSSql @RETURN_VALUE.
+
+For MySQL component same to DATABASE is same to SCHEMA by it's 
+[definition](https://dev.mysql.com/doc/refman/8.0/en/getting-information.html), so DB Schema dropdown is empty for MySQL. 
+
+[MSSQL DB](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-procedure-transact-sql?view=sql-server-2017) stored procedures has only IN and INOUT fields.
+
 ### Create or update record action (Deprecated)
 This action exists in JDBC component only for backward compatibility. [**Upsert row by primary key**](#upsert-row-by-primary-key-action) Action is recommended to use.
 
@@ -219,6 +239,7 @@ This action exists in JDBC component only for backward compatibility. [**Upsert
 - ``Oracle`` - compatible with Oracle Database 8.1.7 - 12.1.0.2
 - ``MSSQL`` - compatible with Microsoft SQL Server 2008 R2 and higher
 3. The current implementation of the action ``Upsert By Primary Key`` doesn't mark non-nullable fields as required fields at a dynamic metadata. In case of updating such fields with an empty value you will get SQL Exception ``Cannot insert the value NULL into...``. You should manually fill in all non-nullable fields with previous data, if you want to update part of columns in a row, even if data in that fields doesn't change. 
+4. The current implementation of the action ``Execute stored procedure`` doesn't support ResultSet response type parameters for stored procedure output. 
 
 ## License
 Apache-2.0 © [elastic.io GmbH](https://www.elastic.io "elastic.io GmbH")

build.gradle

@@ -1,5 +1,5 @@
 group = 'io.elastic'
-version = '2.0.1'
+version = '2.1.0'
 apply plugin: 'java'
 apply plugin: 'idea'
 apply plugin: 'eclipse'

changelog.md

@@ -1,38 +1,25 @@
 # jdbc Component Change Log 
 
+## 2.1.0 (2019-07-22)
 
-## [Unrelased]
-### Added 
-### Change 
-### Deprecated 
-### Removed 
-### Fixed 
-### Security 
+* Add Execute stored procedure action
 
-## [V2.0.1] 2019-06-24 elastic.io 
+## 2.0.1 (2019-06-24)
 
-### Fixed 
-- Improvement error logging for generating metadata of `Select` action
+* Fix error logging for generating metadata of `Select` action
 
-## [V2.0.0] 2018-09-19 elastic.io 
+## 2.0.0 (2018-09-19)
 
-### Added 
+* Add Select trigger
+* Add Get rows polling trigger
 
-Triggers 
-- SELECT 
-- GET ROWS POLLING
+* Add Select action
+* Add Lookup by primary key action
+* Add Upsert by primary key action (for migration)
+* Add Delete by primary key action
 
-Actions 
-- SELECT 
-- LOOKUP BY PRIMARY KEY
-- UPSERT BY PRIMARY KEY (for migration)
-- DELETE BY PRIMARY KEY
+* Remove CreateOrUpdateRecord action
 
-### Removed 
-Actions 
-- CreateOrUpdateRecord
-
-### Fixed 
-- fix issue in postgresql - getDate(null)
-- fix null values as input for select
+* Fix issue in postgresql - getDate(null)
+* Fix null values as input for select
 

component.json

@@ -132,7 +132,6 @@
     }
   },
   "actions": {
-
     "lookupRowByPrimaryKey": {
       "main": "io.elastic.jdbc.actions.LookupRowByPrimaryKey",
       "title": "Lookup Row By Primary Key",
@@ -230,6 +229,31 @@
         }
       },
       "dynamicMetadata": "io.elastic.jdbc.ColumnNamesProviderOld"
+    },
+    "executeStoredProcedure": {
+      "main": "io.elastic.jdbc.actions.ExecuteStoredProcedure",
+      "title": "Execute stored procedure",
+      "description": "Executing selected stored procedure from selected DB schema",
+      "fields": {
+        "schemaName": {
+          "viewClass": "SelectView",
+          "prompt": "Select a Schema",
+          "label": "DB Schema",
+          "required": true,
+          "model": "io.elastic.jdbc.SchemasProvider"
+        },
+        "procedureName": {
+          "viewClass": "SelectView",
+          "prompt": "Select a stored procedure name",
+          "label": "Stored procedure",
+          "model": "io.elastic.jdbc.ProcedureFieldsNameProvider",
+          "required": true,
+          "require": [
+            "schemaName"
+          ]
+        }
+      },
+      "dynamicMetadata": "io.elastic.jdbc.ProcedureFieldsNameProvider"
     }
   }
 }

src/main/java/io/elastic/jdbc/ProcedureFieldsNameProvider.java

@@ -0,0 +1,141 @@
+package io.elastic.jdbc;
+
+import io.elastic.api.DynamicMetadataProvider;
+import io.elastic.api.SelectModelProvider;
+import io.elastic.jdbc.ProcedureParameter.Direction;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import javax.json.Json;
+import javax.json.JsonObject;
+import javax.json.JsonObjectBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ProcedureFieldsNameProvider implements DynamicMetadataProvider, SelectModelProvider {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(ProcedureFieldsNameProvider.class);
+
+  @Override
+  public JsonObject getSelectModel(JsonObject configuration) {
+    JsonObjectBuilder result = Json.createObjectBuilder();
+    List<String> proceduresNames = getProceduresList(configuration);
+    proceduresNames.forEach(procedure -> result.add(procedure, procedure));
+    return result.build();
+  }
+
+  @Override
+  public JsonObject getMetaModel(JsonObject configuration) {
+    List<ProcedureParameter> parameters = getProcedureMetadata(configuration);
+    return paramsListToMetadata(parameters);
+  }
+
+  public static JsonObject paramsListToMetadata(List<ProcedureParameter> parameters) {
+    JsonObjectBuilder result = Json.createObjectBuilder();
+    JsonObjectBuilder inFields = Json.createObjectBuilder();
+    JsonObjectBuilder outFields = Json.createObjectBuilder();
+
+    parameters.stream()
+        .filter(p -> p.getDirection() == Direction.IN || p.getDirection() == Direction.INOUT)
+        .forEach(p -> {
+          JsonObjectBuilder valueContent = Json.createObjectBuilder()
+              .add("type", Utils.cleanJsonType(Utils.detectColumnType(p.getType(), "")))
+              .add("name", p.getName())
+              .add("required", true);
+          inFields.add(p.getName(), valueContent.build());
+        });
+
+    JsonObjectBuilder inMetadata = Json.createObjectBuilder()
+        .add("type", "object")
+        .add("properties", inFields.build());
+
+    parameters.stream()
+        .filter(p -> p.getDirection() == Direction.OUT || p.getDirection() == Direction.INOUT)
+        .forEach(p -> {
+          JsonObjectBuilder valueContent = Json.createObjectBuilder()
+              .add("type", Utils.cleanJsonType(Utils.detectColumnType(p.getType(), "")))
+              .add("name", p.getName())
+              .add("required", true);
+          outFields.add(p.getName(), valueContent.build());
+        });
+
+    JsonObjectBuilder outMetadata = Json.createObjectBuilder()
+        .add("type", "object")
+        .add("properties", outFields.build());
+
+    result.add("in", inMetadata.build()).add("out", outMetadata.build());
+
+    JsonObject metadataResponse = result.build();
+    LOGGER.trace(metadataResponse.toString());
+    return metadataResponse;
+  }
+
+  public List<String> getProceduresList(JsonObject config) {
+    List<String> result = new ArrayList<>();
+    try (Connection conn = Utils.getConnection(config)) {
+      DatabaseMetaData meta = conn.getMetaData();
+      ResultSet res = meta.getProcedures(null, config.getString("schemaName"), null);
+      while (res.next()) {
+        String cat = res.getString("PROCEDURE_CAT");
+        String schem = res.getString("PROCEDURE_SCHEM");
+        String name = res.getString("PROCEDURE_NAME");
+
+        name = name.indexOf(';') == -1 ? name : name.substring(0, name.indexOf(';'));
+
+        result.add(name);
+      }
+      res.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+
+    return result;
+  }
+
+  public static List<ProcedureParameter> getProcedureMetadata(JsonObject config) {
+    List<ProcedureParameter> parameters = new LinkedList<>();
+
+    try (Connection conn = Utils.getConnection(config)) {
+      DatabaseMetaData dbMetaData = conn.getMetaData();
+      ResultSet rs = dbMetaData.getProcedureColumns(conn.getCatalog(),
+          config.getString("schemaName"),
+          config.getString("procedureName"),
+          null);
+
+      int order = 1;
+      while (rs.next()) {
+        // get stored procedure metadata
+        String procedureCatalog = rs.getString(1);
+        String procedureSchema = rs.getString(2);
+        String procedureName = rs.getString(3);
+        String columnName = rs.getString(4);
+        short columnReturn = rs.getShort(5);
+        int columnDataType = rs.getInt(6);
+        String columnReturnTypeName = rs.getString(7);
+        int columnPrecision = rs.getInt(8);
+        int columnByteLength = rs.getInt(9);
+        short columnScale = rs.getShort(10);
+        short columnRadix = rs.getShort(11);
+        short columnNullable = rs.getShort(12);
+        String columnRemarks = rs.getString(13);
+
+        if (columnReturnTypeName.equals("REF CURSOR")) {
+          columnDataType = -10;
+        }
+
+        if (columnName.equals("@RETURN_VALUE")) {
+          continue;
+        }
+
+        parameters.add(new ProcedureParameter(columnName, columnReturn, columnDataType, order++));
+      }
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+
+    return parameters;
+  }
+}

src/main/java/io/elastic/jdbc/ProcedureParameter.java

@@ -0,0 +1,83 @@
+package io.elastic.jdbc;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ProcedureParameter {
+
+  private String name;
+  private Direction direction;
+  private int type;
+  private int order;
+
+  public ProcedureParameter(String name, Direction direction, int type) {
+    this.name = name;
+    this.direction = direction;
+    this.type = type;
+  }
+
+  public ProcedureParameter(String name, short direction, int type) {
+    this.name = name;
+    this.direction = jdbcColTypeToDirection(direction);
+    this.type = type;
+  }
+
+  public ProcedureParameter(String name, Direction direction, int type, int order) {
+    this.name = name;
+    this.direction = direction;
+    this.type = type;
+    this.order = order;
+  }
+
+  public ProcedureParameter(String name, short direction, int type, int order) {
+    this.name = name;
+    this.direction = jdbcColTypeToDirection(direction);
+    this.type = type;
+    this.order = order;
+  }
+
+  private Direction jdbcColTypeToDirection(short direction) {
+    List<Short> inputTypes = Arrays.asList((short) 1);
+    List<Short> outputTypes = Arrays.asList((short) 3, (short) 4, (short) 5);
+    List<Short> inOutputTypes = Arrays.asList((short) 2);
+
+    return inputTypes.contains(direction) ? Direction.IN
+        : outputTypes.contains(direction) ? Direction.OUT
+            : inOutputTypes.contains(direction) ? Direction.INOUT
+                : Direction.UNDEFINED;
+  }
+
+  public enum Direction {
+    IN("in"),
+    OUT("out"),
+    INOUT("inout"),
+    UNDEFINED("undefined");
+
+    private String dirName;
+
+    Direction(String dirName) {
+      this.dirName = dirName;
+    }
+
+    @Override
+    public String toString() {
+      return this.dirName;
+    }
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public Direction getDirection() {
+    return direction;
+  }
+
+  public int getType() {
+    return type;
+  }
+
+  public int getOrder() {
+    return order;
+  }
+}