Merge pull request #2 from mendix/feature/support-only-mendix-datatypes

Feature/support only mendix datatypes

Author: roland-mendix

DatabaseConnector.mpr

@@ -16,6 +16,7 @@
 import com.mendix.logging.ILogNode;
 import com.mendix.systemwideinterfaces.core.IContext;
 import com.mendix.systemwideinterfaces.core.IMendixObject;
+import com.mendix.systemwideinterfaces.core.meta.IMetaObject;
 import com.mendix.webui.CustomJavaAction;
 import databaseconnector.impl.JdbcConnector;
 
@@ -76,11 +77,11 @@ public ExecuteQuery(IContext context, String jdbcUrl, String userName, String pa
 	public java.util.List<IMendixObject> executeAction() throws Exception
 	{
 		// BEGIN USER CODE
-		String entityName = resultObject.getMetaObject().getName();
+		IMetaObject metaObject = resultObject.getMetaObject();
 		Stream<IMendixObject> resultStream = connector.executeQuery(
-		    this.jdbcUrl, this.userName, this.password, entityName, this.sql, this.getContext());
+		    this.jdbcUrl, this.userName, this.password, metaObject, this.sql, this.getContext());
 		List<IMendixObject> resultList = resultStream.collect(Collectors.toList());
-		logNode.info(String.format("List: %d", resultList.size()));
+		logNode.trace(String.format("Result list count: %d", resultList.size()));
 
 		return resultList;
 		// END USER CODE

javasource/databaseconnector/actions/ExecuteQuery.java

@@ -1,12 +1,16 @@
 package databaseconnector.impl;
 
+import com.mendix.systemwideinterfaces.core.meta.IMetaPrimitive.PrimitiveType;
+
 public class ColumnInfo {
-  private int index;
-  private String name;
+  private final int index;
+  private final String name;
+  private final PrimitiveType type;
 
-  public ColumnInfo(int index, String name) {
+  public ColumnInfo(final int index, final String name, final PrimitiveType type) {
     this.index = index;
     this.name = name;
+    this.type = type;
   }
 
   public int getIndex() {
@@ -16,4 +20,8 @@ public int getIndex() {
   public String getName() {
     return name;
   }
+
+  public PrimitiveType getType() {
+    return type;
+  }
 }

javasource/databaseconnector/actions/ExecuteQueryToJson.java

@@ -43,10 +43,10 @@ public Connection getConnection(final String jdbcUrl, final String userName, fin
 
     final Integer connPoolKey = toConnPoolKey(jdbcUrl, userName);
     final HikariDataSource dataSource = connectionPool.computeIfAbsent(connPoolKey, k -> {
-      logNode.info(String.format("Creating data source in connection pool for [url=%s, user=%s]", jdbcUrl, userName));
+      logNode.trace(String.format("Creating data source in connection pool for [url=%s, user=%s]", jdbcUrl, userName));
       return createHikariDataSource(jdbcUrl, userName, password);
     });
-    logNode.info(String.format("Getting connection from data source in connection pool for [url=%s, user=%s]", jdbcUrl, userName));
+    logNode.trace(String.format("Getting connection from data source in connection pool for [url=%s, user=%s]", jdbcUrl, userName));
     return dataSource.getConnection();
   }
 
@@ -61,7 +61,7 @@ private synchronized void initializeDrivers() {
       ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);
       Stream<String> driverNames = StreamSupport.stream(loader.spliterator(), false).map(a -> a.getClass().getName());
       String logMessage = driverNames.collect(Collectors.joining(", ", "Found JDBC Drivers: ", ""));
-      logNode.info(logMessage);
+      logNode.trace(logMessage);
       hasDriversInitialized = true;
     }
   }

javasource/databaseconnector/impl/ColumnInfo.java

@@ -1,74 +1,93 @@
 package databaseconnector.impl;
 
+import java.io.ByteArrayInputStream;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiConsumer;
 import java.util.function.Function;
-import java.util.stream.Collectors;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 
-import org.json.JSONArray;
-import org.json.JSONObject;
-
+import com.mendix.core.objectmanagement.member.MendixHashString;
 import com.mendix.logging.ILogNode;
 import com.mendix.systemwideinterfaces.core.IContext;
 import com.mendix.systemwideinterfaces.core.IMendixObject;
+import com.mendix.systemwideinterfaces.core.meta.IMetaObject;
+import com.mendix.systemwideinterfaces.core.meta.IMetaPrimitive.PrimitiveType;
 
 import databaseconnector.interfaces.ConnectionManager;
 import databaseconnector.interfaces.ObjectInstantiator;
 
+/**
+ * JdbcConnector implements the execute query (and execute statement) functionality, and returns a {@link Stream} of {@link IMendixObject}s.
+ */
 public class JdbcConnector {
   private final ILogNode logNode;
-  private ObjectInstantiator objectInstantiator;
-  private ConnectionManager connectionManager;
+  private final ObjectInstantiator objectInstantiator;
+  private final ConnectionManager connectionManager;
 
-  public JdbcConnector(final ILogNode logNode, ObjectInstantiator objectInstantiator, ConnectionManager connectionManager) {
+  public JdbcConnector(final ILogNode logNode, final ObjectInstantiator objectInstantiator, final ConnectionManager connectionManager) {
     this.logNode = logNode;
     this.objectInstantiator = objectInstantiator;
     this.connectionManager = connectionManager;
   }
 
-  public JdbcConnector(ILogNode logNode) {
+  public JdbcConnector(final ILogNode logNode) {
     this(logNode, new ObjectInstantiatorImpl(), ConnectionManagerSingleton.getInstance());
   }
 
-  public Stream<IMendixObject> executeQuery(String jdbcUrl, String userName, String password, String entityName, String sql,
-      IContext context) throws SQLException {
-    Function<Map<String, Object>, IMendixObject> toMendixObject = columns -> {
+  public Stream<IMendixObject> executeQuery(final String jdbcUrl, final String userName, final String password, final IMetaObject metaObject, final String sql,
+      final IContext context) throws SQLException {
+    String entityName = metaObject.getName();
+    
+    Function<Map<String, Optional<Object>>, IMendixObject> toMendixObject = columns -> {
       IMendixObject obj = objectInstantiator.instantiate(context, entityName);
-      columns.forEach((n, v) -> obj.setValue(context, n, v));
-      logNode.info("obj: " + obj);
+      
+      BiConsumer<String, Optional<Object>> setMemberValue = (name, value) -> {
+        PrimitiveType type = metaObject.getMetaPrimitive(name).getType();
+        // convert to suitable value (different for Binary type)
+        Function<Object, Object> toSuitableValue = toSuitableValue(type);
+        // for Boolean type, convert null to false
+        Supplier<Object> defaultValue = () -> type == PrimitiveType.Boolean ? Boolean.FALSE : null;
+        // apply two functions declared above
+        Object convertedValue = value.map(toSuitableValue).orElseGet(defaultValue);
+        // update object with converted value
+        if (type == PrimitiveType.HashString)
+          ((MendixHashString) obj.getMember(context, name)).setInitialHash((String) convertedValue);
+        else
+          obj.setValue(context, name, convertedValue);
+      };
+      
+      columns.forEach(setMemberValue);
+      logNode.trace("Instantiated object: " + obj);
       return obj;
     };
 
-    Stream<Map<String,Object>> stream = executeQuery(jdbcUrl, userName, password, sql);
-
-    return stream.map(toMendixObject);
+    return executeQuery(jdbcUrl, userName, password, metaObject, sql).map(toMendixObject);
   }
 
-  public String executeQueryToJson(String jdbcUrl, String userName, String password, String sql, IContext context) throws SQLException {
-    Stream<Map<String, Object>> stream = executeQuery(jdbcUrl, userName, password, sql);
-    Stream<JSONObject> jsonObjects = stream.map(JSONObject::new);
-
-    return new JSONArray(jsonObjects.collect(Collectors.toList())).toString();
+  private Function<Object, Object> toSuitableValue(final PrimitiveType type) {
+    return v -> type == PrimitiveType.Binary ? new ByteArrayInputStream((byte[]) v) : v;
   }
 
-  public Stream<Map<String, Object>> executeQuery(String jdbcUrl, String userName, String password, String sql) throws SQLException {
-    logNode.info(String.format("executeQuery: %s, %s, %s", jdbcUrl, userName, sql));
+  private Stream<Map<String, Optional<Object>>> executeQuery(final String jdbcUrl, final String userName, final String password, final IMetaObject metaObject, final String sql) throws SQLException {
+    logNode.trace(String.format("executeQuery: %s, %s, %s", jdbcUrl, userName, sql));
 
     try (Connection connection = connectionManager.getConnection(jdbcUrl, userName, password);
         PreparedStatement preparedStatement = connection.prepareStatement(sql);
         ResultSet resultSet = preparedStatement.executeQuery()) {
-      ResultSetReader resultSetReader = new ResultSetReader(resultSet);
+      ResultSetReader resultSetReader = new ResultSetReader(resultSet, metaObject);
 
       return resultSetReader.readAll().stream();
     }
   }
 
-  public long executeStatement(String jdbcUrl, String userName, String password, String sql) throws SQLException {
-    logNode.info(String.format("executeStatement: %s, %s, %s", jdbcUrl, userName, sql));
+  public long executeStatement(final String jdbcUrl, final String userName, final String password, final String sql) throws SQLException {
+    logNode.trace(String.format("executeStatement: %s, %s, %s", jdbcUrl, userName, sql));
 
     try (Connection connection = connectionManager.getConnection(jdbcUrl, userName, password);
         PreparedStatement preparedStatement = connection.prepareStatement(sql)) {

javasource/databaseconnector/impl/JdbcConnectionManager.java

@@ -9,7 +9,7 @@
 class ObjectInstantiatorImpl implements ObjectInstantiator {
 
   @Override
-  public IMendixObject instantiate(IContext context, String entityName) {
+  public IMendixObject instantiate(final IContext context, final String entityName) {
     return Core.instantiate(context, entityName);
   }
 }

javasource/databaseconnector/impl/JdbcConnector.java

@@ -5,24 +5,30 @@
 import java.sql.SQLException;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Optional;
 import java.util.Spliterator;
 import java.util.Spliterators;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+import com.mendix.systemwideinterfaces.core.meta.IMetaObject;
+import com.mendix.systemwideinterfaces.core.meta.IMetaPrimitive;
+
 /**
  * ResultSetIterator implements {@link Iterator} interface. It wraps {@link ResultSet} into a stream for more convenient usage. Along
  * with that, it provides information about columns of the given result set.
  */
 public class ResultSetIterator implements Iterator<ResultSet> {
-
   private final ResultSet resultSet;
   private final List<ColumnInfo> columnInfos;
+  private final IMetaObject metaObject;
 
-  public ResultSetIterator(final ResultSet resultSet) {
+  public ResultSetIterator(final ResultSet resultSet, final IMetaObject metaObject) {
     this.resultSet = resultSet;
+    this.metaObject = metaObject;
     this.columnInfos = createColumnInfos(resultSet);
   }
 
@@ -36,12 +42,24 @@ private List<ColumnInfo> createColumnInfos(final ResultSet resultSet) {
     }
   }
 
-  private ColumnInfo getColumnInfo(int index) {
+  private ColumnInfo getColumnInfo(final int index) {
+    final String columnName;
+
     try {
-      return new ColumnInfo(index, resultSet.getMetaData().getColumnName(index));
+      columnName = resultSet.getMetaData().getColumnName(index);
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
+
+    final Predicate<IMetaPrimitive> caseInsensitiveName = (IMetaPrimitive mp) -> mp.getName().equalsIgnoreCase(columnName);
+    final Optional<? extends IMetaPrimitive> primitive = metaObject.getMetaPrimitives().stream().filter(caseInsensitiveName).findFirst();
+
+    final IMetaPrimitive.PrimitiveType type = primitive.<RuntimeException>orElseThrow(() -> {
+      final String msg = "The entity type '%s' does not contain the primitive '%s' as specified in the query.";
+      throw new RuntimeException(String.format(msg, metaObject.getName(), columnName));
+    }).getType();
+
+    return new ColumnInfo(index, columnName, type);
   }
 
   @Override