Merge f209432 into cbf8b83

build.gradle

@@ -106,7 +106,7 @@ dependencies {
 }
 
 
-def hsql = 'org.hsqldb:hsqldb:2.2.9'
+def hsql = 'org.hsqldb:hsqldb:2.4.1'
 
 
 allprojects {

config/codenarc/rulesMain.groovy

@@ -210,7 +210,7 @@ ruleset {
     UnnecessaryBooleanInstantiation { priority = 1 }
     UnnecessaryCallForLastElement { priority = 1 }
     UnnecessaryCallToSubstring { priority = 1 }
-    UnnecessaryCast { priority = 1 }
+    //UnnecessaryCast { priority = 1 }
     UnnecessaryCatchBlock { priority = 1 }
     UnnecessaryCollectCall { priority = 1 }
     UnnecessaryCollectionCall { priority = 1 }

gradle.properties

@@ -1 +1 @@
-version=1.4.0-SNAPSHOT
+version=1.3.0

modules/core/src/de/diedavids/cuba/runtimediagnose/db/DbDiagnoseServiceBean.groovy

@@ -2,6 +2,7 @@ package de.diedavids.cuba.runtimediagnose.db
 
 import com.haulmont.cuba.core.Persistence
 import com.haulmont.cuba.core.Query
+import com.haulmont.cuba.core.global.Stores
 import com.haulmont.cuba.core.global.TimeSource
 import com.haulmont.cuba.core.global.UserSessionSource
 import de.diedavids.cuba.runtimediagnose.diagnose.DiagnoseExecution
@@ -46,61 +47,60 @@ class DbDiagnoseServiceBean implements DbDiagnoseService {
     @Inject
     DiagnoseExecutionFactory diagnoseExecutionFactory
 
-
     @Override
-    DbQueryResult runSqlDiagnose(String queryString, DiagnoseType diagnoseType) {
+    DbQueryResult runSqlDiagnose(
+            String queryString,
+            DiagnoseType diagnoseType,
+            String dataStore
+    ) {
         Statements queryStatements = dbQueryParser.analyseQueryString(queryString, diagnoseType)
 
         if (!statementsAvailable(queryStatements)) {
             return selectResultFactory.createFromRows([])
         }
 
         def queryStatement = queryStatements.statements[0].toString()
-        DiagnoseExecution diagnoseExecution = createAdHocDiagnose(queryStatement, diagnoseType)
+        DiagnoseExecution diagnoseExecution = createAdHocDiagnose(queryStatement, diagnoseType, dataStore)
+        tryToRunSqlDiagnose(diagnoseType, queryStatement, queryStatements, dataStore, diagnoseExecution)
+    }
+
+    private DbQueryResult tryToRunSqlDiagnose(DiagnoseType diagnoseType, String queryStatement, Statements queryStatements, String dataStore, DiagnoseExecution diagnoseExecution) {
         DbQueryResult dbQueryResult
         try {
-            dbQueryResult = getQueryResult(diagnoseType, queryStatement, queryStatements)
-
-            diagnoseExecution.handleSuccessfulExecution(getResultMessage(dbQueryResult))
+            dbQueryResult = getQueryResult(diagnoseType, queryStatement, queryStatements, dataStore ?: Stores.MAIN)
+            diagnoseExecution.handleSuccessfulExecution(dbQueryResult.resultMessage())
             diagnoseExecutionLogService.logDiagnoseExecution(diagnoseExecution)
         } catch (Exception e) {
             dbQueryResult = selectResultFactory.createFromRows([])
             diagnoseExecution.handleErrorExecution(e)
             diagnoseExecutionLogService.logDiagnoseExecution(diagnoseExecution)
         }
-
         dbQueryResult
     }
 
-    protected String getResultMessage(DbQueryResult dbQueryResult) {
-        String resultMessage = ''
-        if (dbQueryResult.empty) {
-            resultMessage = 'Execution successful'
-        } else {
-            resultMessage = dbQueryResult.entities[0].toString()
-        }
-        resultMessage
-    }
-
-    protected DbQueryResult getQueryResult(DiagnoseType diagnoseType, String queryStatement, Statements queryStatements) {
+    protected DbQueryResult getQueryResult(
+            DiagnoseType diagnoseType,
+            String queryStatement,
+            Statements queryStatements,
+            String dataStore
+    ) {
         DbQueryResult dbQueryResult
         switch (diagnoseType) {
             case DiagnoseType.JPQL:
-                dbQueryResult = executeJpqlStatement(queryStatement, queryStatements)
+                dbQueryResult = executeJpqlStatement(queryStatement, queryStatements, dataStore)
                 break
             case DiagnoseType.SQL:
-                def sql = createSqlConnection(persistence.dataSource)
-                dbQueryResult = executeSqlStatement(sql, queryStatements)
+                dbQueryResult = executeSqlStatement(queryStatements, dataStore)
                 break
             default:
                 throw new IllegalArgumentException('DiagnoseType is not supported (' + diagnoseType + ')')
         }
         dbQueryResult
     }
 
-    protected DbQueryResult executeJpqlStatement(String queryStatement, Statements queryStatements) {
+    protected DbQueryResult executeJpqlStatement(String queryStatement, Statements queryStatements, String storeName) {
         persistence.callInTransaction {
-            Query q = persistence.entityManager.createQuery(queryStatement)
+            Query q = persistence.getEntityManager(storeName).createQuery(queryStatement)
 
             if (dbQueryParser.containsDataManipulation(queryStatements)) {
                 q.executeUpdate()
@@ -111,12 +111,13 @@ class DbDiagnoseServiceBean implements DbDiagnoseService {
         }
     }
 
-    protected DbQueryResult executeSqlStatement(Sql sql, Statements queryStatements) {
+    protected DbQueryResult executeSqlStatement(Statements queryStatements, String dataStore) {
+        Sql sql = createSqlConnection(persistence.getDataSource(dataStore))
         dbSqlExecutor.executeStatement(sql, queryStatements.statements[0])
     }
 
-    private DiagnoseExecution createAdHocDiagnose(String sqlStatement, DiagnoseType diagnoseType) {
-        def diagnoseExecution = diagnoseExecutionFactory.createAdHocDiagnoseExecution(sqlStatement, diagnoseType)
+    private DiagnoseExecution createAdHocDiagnose(String sqlStatement, DiagnoseType diagnoseType, String dataStore) {
+        def diagnoseExecution = diagnoseExecutionFactory.createAdHocDiagnoseExecution(sqlStatement, diagnoseType, dataStore)
         setDiagnoseExecutionMetadata(diagnoseExecution)
         diagnoseExecution
     }
@@ -132,9 +133,8 @@ class DbDiagnoseServiceBean implements DbDiagnoseService {
             setDiagnoseExecutionMetadata(diagnoseExecution)
 
             try {
-                def sqlSelectResult = runSqlDiagnose(diagnoseExecution.diagnoseScript, diagnoseType)
-                // TODO: create CSV file with content
-                diagnoseExecution.handleSuccessfulExecution(sqlSelectResult.entities[0].toString())
+                def sqlSelectResult = runSqlDiagnose(diagnoseExecution.diagnoseScript, diagnoseType, diagnoseExecution.manifest.dataStore)
+                diagnoseExecution.handleSuccessfulExecution(sqlSelectResult.toCSV())
             }
             catch (Exception e) {
                 diagnoseExecution.handleErrorExecution(e)

modules/core/test/de/diedavids/cuba/runtimediagnose/db/DbDiagnoseServiceBeanSpec.groovy

@@ -3,6 +3,7 @@ package de.diedavids.cuba.runtimediagnose.db
 import com.haulmont.cuba.core.EntityManager
 import com.haulmont.cuba.core.Persistence
 import com.haulmont.cuba.core.Transaction
+import com.haulmont.cuba.core.global.Stores
 import com.haulmont.cuba.core.global.TimeSource
 import com.haulmont.cuba.core.global.UserSessionSource
 import com.haulmont.cuba.security.entity.User
@@ -78,7 +79,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         )
 
         dataSource = Mock(DataSource)
-        persistence.getDataSource() >> dataSource
+        persistence.getDataSource(_) >> dataSource
         persistence.getTransaction() >> transaction
 
     }
@@ -88,7 +89,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         given:
         def sqlString = 'SELECT * FROM SEC_USER;'
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL, Stores.MAIN)
         then:
         1 * dbQueryParser.analyseQueryString(sqlString, DiagnoseType.SQL)
     }
@@ -98,7 +99,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         given:
         def sqlString = 'select u from sec$User u'
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL, Stores.MAIN)
         then:
         1 * dbQueryParser.analyseQueryString(sqlString, DiagnoseType.JPQL)
     }
@@ -116,10 +117,10 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_, _) >> statements
 
         and:
-        diagnoseExecutionFactory.createAdHocDiagnoseExecution(_ as String, _ as DiagnoseType) >> new DiagnoseExecution()
+        diagnoseExecutionIsCreated()
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL, Stores.MAIN)
 
         then:
         dbDiagnoseServiceBean.actualDataSource == dataSource
@@ -139,10 +140,10 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_, _) >> statements
 
         and:
-        diagnoseExecutionFactory.createAdHocDiagnoseExecution(_, _) >> new DiagnoseExecution()
+        diagnoseExecutionIsCreated()
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL, Stores.MAIN)
 
         then:
         1 * dbSqlExecutor.executeStatement(_, sqlStatement) >> new DbQueryResult()
@@ -162,15 +163,19 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_ as String, DiagnoseType.JPQL) >> statements
 
         and:
-        diagnoseExecutionFactory.createAdHocDiagnoseExecution(_ as String, _ as DiagnoseType) >> new DiagnoseExecution()
+        diagnoseExecutionIsCreated()
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL, Stores.MAIN)
 
         then:
         1 * persistence.callInTransaction(_ as Transaction.Callable)
     }
 
+    private void diagnoseExecutionIsCreated() {
+        diagnoseExecutionFactory.createAdHocDiagnoseExecution(_ as String, _ as DiagnoseType, Stores.MAIN) >> new DiagnoseExecution()
+    }
+
     def "runSqlDiagnose executes no sql script if there is no result of the sql parser"() {
 
         given:
@@ -183,7 +188,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_, DiagnoseType.SQL) >> statements
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.SQL, Stores.MAIN)
 
         then:
         0 * dbSqlExecutor.executeStatement(_,_)
@@ -201,7 +206,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_, DiagnoseType.JPQL) >> statements
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL, Stores.MAIN)
 
         then:
         0 * dbSqlExecutor.executeStatement(_,_)
@@ -219,7 +224,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         dbQueryParser.analyseQueryString(_, DiagnoseType.JPQL) >> statements
 
         when:
-        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL)
+        dbDiagnoseServiceBean.runSqlDiagnose(sqlString, DiagnoseType.JPQL, Stores.MAIN)
 
         then:
         0 * dbSqlExecutor.executeStatement(_,_)
@@ -257,7 +262,7 @@ class DbDiagnoseServiceBeanSpec extends Specification {
         Statements statements = Mock(Statements)
 
         when:
-        dbDiagnoseServiceBean.getQueryResult(diagnoseType, _ as String, statements)
+        dbDiagnoseServiceBean.getQueryResult(diagnoseType, _ as String, statements, Stores.MAIN)
 
         then:
         thrown(IllegalArgumentException)

modules/global/src/de/diedavids/cuba/runtimediagnose/db/DbDiagnoseService.groovy

@@ -6,7 +6,9 @@ import de.diedavids.cuba.runtimediagnose.diagnose.DiagnoseType
 interface DbDiagnoseService {
     String NAME = 'ddcrd_SqlConsoleService'
 
-    DbQueryResult runSqlDiagnose(String queryString, DiagnoseType diagnoseType)
+    DbQueryResult runSqlDiagnose(String queryString, DiagnoseType diagnoseType, String dataStore)
+
     DiagnoseExecution runSqlDiagnose(DiagnoseExecution diagnoseExecution, DiagnoseType diagnoseType)
+
     String getSqlQuery(String jpqlQuery)
 }

modules/global/src/de/diedavids/cuba/runtimediagnose/db/DbQueryResult.groovy

@@ -9,6 +9,8 @@ class DbQueryResult implements Serializable {
     Collection<String> columns = []
 
     Collection<KeyValueEntity> entities = []
+    private final String NEW_LINE = '\n'
+    private final String CSV_SEPERATOR = ','
 
     boolean isEmpty() {
         columns.empty && entities.empty
@@ -21,4 +23,36 @@ class DbQueryResult implements Serializable {
     void addEntity(KeyValueEntity entity) {
         entities << entity
     }
+
+    String resultMessage() {
+        empty ? 'Execution successful' : entities[0].toString()
+    }
+
+    String toCSV() {
+        [
+                headerString(),
+                entities.collect { entity ->
+                    entityToCSV(entity)
+                }
+        ].flatten().join(NEW_LINE)
+    }
+
+    private String headerString() {
+        columns.collect { "\"$it\"" }.join(CSV_SEPERATOR)
+    }
+
+    String entityToCSV(KeyValueEntity entity) {
+
+        def valueColumn = columns.collect { column ->
+            entityColumnString(entity, column)
+        }
+
+        valueColumn.join(CSV_SEPERATOR)
+    }
+
+    private static String entityColumnString(KeyValueEntity entity, String column) {
+        def value = entity.getValue(column)
+
+        (value && (value != 'null')) ? "\"$value\"" : '""'
+    }
 }

modules/global/src/de/diedavids/cuba/runtimediagnose/diagnose/DiagnoseExecution.groovy

@@ -3,7 +3,7 @@ package de.diedavids.cuba.runtimediagnose.diagnose
 import groovy.transform.CompileStatic
 
 @CompileStatic
-class DiagnoseExecution implements Serializable{
+class DiagnoseExecution implements Serializable {
 
 
     private static final long serialVersionUID = -8288852447591914153L
@@ -39,19 +39,14 @@ class DiagnoseExecution implements Serializable{
     }
 
     String getExecutedScriptFileExtension() {
-        String extension = ''
-        if (manifest) {
-            extension = manifest.diagnoseType.name().toLowerCase()
-        }
-
-        extension
+        manifest ? manifest.diagnoseType.name().toLowerCase() : ''
     }
 
     Map<String, String> getExecutionResultFileMap() {
 
-        def executionResultFileMap = [:]
+        def executionResultFileMap = [:] as Map<String, String>
 
-        addResultFileIfPossible(executionResultFileMap, "diagnose.${executedScriptFileExtension}", diagnoseScript)
+        addResultFileIfPossible(executionResultFileMap, "diagnose.${executedScriptFileExtension}".toString(), diagnoseScript)
         addResultFileIfPossible(executionResultFileMap, 'result.log', getResult(RESULT_NAME))
         addResultFileIfPossible(executionResultFileMap, 'log.log', getResult(RESULT_LOG_NAME))
         addResultFileIfPossible(executionResultFileMap, 'stacktrace.log', getResult(RESULT_STACKTRACE_NAME))

modules/global/src/de/diedavids/cuba/runtimediagnose/diagnose/DiagnoseExecutionFactory.groovy

@@ -20,6 +20,16 @@ interface DiagnoseExecutionFactory {
     DiagnoseExecution createAdHocDiagnoseExecution(String diagnoseScript, DiagnoseType diagnoseType)
 
 
+    /**
+     * creates an ad-hoc diagnose execution
+     * @param diagnoseScript the diagnose script to use
+     * @param diagnoseType the diagnose type to use
+     * @param dataStore the data store to be used (SQL / JPQL)
+     * @return the diagnose execution instance
+     */
+    DiagnoseExecution createAdHocDiagnoseExecution(String diagnoseScript, DiagnoseType diagnoseType, String dataStore)
+
+
     /**
      * creates an execution result (as zip bytes) form a given diagnose exection
      * @param diagnoseExecution the diagnose execution to create a zip file from

modules/global/src/de/diedavids/cuba/runtimediagnose/diagnose/DiagnoseExecutionFactoryBean.groovy

@@ -1,6 +1,7 @@
 package de.diedavids.cuba.runtimediagnose.diagnose
 
 import com.haulmont.cuba.core.global.BuildInfo
+import com.haulmont.cuba.core.global.Stores
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
 import groovy.transform.CompileStatic
@@ -37,11 +38,17 @@ class DiagnoseExecutionFactoryBean implements DiagnoseExecutionFactory {
 
     @Override
     DiagnoseExecution createAdHocDiagnoseExecution(String diagnoseScript, DiagnoseType diagnoseType) {
+        createAdHocDiagnoseExecution(diagnoseScript, diagnoseType, Stores.MAIN)
+    }
+
+    @Override
+    DiagnoseExecution createAdHocDiagnoseExecution(String diagnoseScript, DiagnoseType diagnoseType, String dataStore) {
         new DiagnoseExecution(
             manifest: new DiagnoseManifest(
-                diagnoseType: diagnoseType,
-                appName: buildInfo.content.appName,
-                appVersion: buildInfo.content.version
+                    diagnoseType: diagnoseType,
+                    appName: buildInfo.content.appName,
+                    appVersion: buildInfo.content.version,
+                    dataStore: dataStore
             ),
             diagnoseScript: diagnoseScript,
             executionType: DiagnoseExecutionType.CONSOLE