Feature/adding some generics

liquibase-maven-plugin/src/main/java/org/liquibase/maven/plugins/MavenUtils.java

@@ -49,8 +49,8 @@ public static ClassLoader getArtifactClassloader(MavenProject project,
         // Find project dependencies, including the transitive ones.
         Set<Artifact> dependencies = project.getArtifacts();
         if ((dependencies != null) && !dependencies.isEmpty()) {
-            for (Iterator it = dependencies.iterator(); it.hasNext(); ) {
-                addArtifact(uris, (Artifact) it.next(), log, verbose);
+            for (Artifact artifact : dependencies) {
+                addArtifact(uris, artifact, log, verbose);
             }
         } else {
             log.info("there are no resolved artifacts for the Maven project.");

liquibase-standard/src/main/java/liquibase/changelog/StandardChangeLogHistoryService.java

@@ -309,7 +309,7 @@ public List<RanChangeSet> getRanChangeSets() throws DatabaseException {
             if (hasDatabaseChangeLogTable()) {
                 Scope.getCurrentScope().getLog(getClass()).info("Reading from " + databaseChangeLogTableName);
                 List<Map<String, ?>> results = queryDatabaseChangeLogTable(database);
-                for (Map rs : results) {
+                for (Map<String, ?> rs : results) {
                     String storedFileName = rs.get("FILENAME").toString();
                     String fileName = DatabaseChangeLog.normalizePath(storedFileName);
                     String author = rs.get("AUTHOR").toString();

liquibase-standard/src/main/java/liquibase/command/core/HistoryCommand.java

@@ -12,7 +12,7 @@
 /**
  * @deprecated Implement commands with {@link liquibase.command.CommandStep} and call them with {@link liquibase.command.CommandFactory#getCommandDefinition(String...)}.
  */
-public class HistoryCommand extends AbstractCommand {
+public class HistoryCommand extends AbstractCommand<CommandResult> {
 
     private Database database;
     private final DateFormat dateFormat;

liquibase-standard/src/main/java/liquibase/command/core/helpers/AbstractChangelogCommandStep.java

@@ -37,7 +37,7 @@ public abstract class AbstractChangelogCommandStep extends AbstractCommandStep {
     }
 
     protected static void validateRunOnChangeTypes(final CommandScope commandScope) throws CommandValidationException {
-        final Collection<String> runOnChangeTypes = new ArrayList(Arrays.asList(commandScope.getArgumentValue(RUN_ON_CHANGE_TYPES_ARG).split("\\s*,\\s*")));
+        final Collection<String> runOnChangeTypes = new ArrayList<>(Arrays.asList(commandScope.getArgumentValue(RUN_ON_CHANGE_TYPES_ARG).split("\\s*,\\s*")));
         final Collection<String> supportedRunOnChangeTypes = supportedRunOnChangeTypes().collect(Collectors.toList());
         supportedRunOnChangeTypes.add("none");
         runOnChangeTypes.removeAll(supportedRunOnChangeTypes);
@@ -46,7 +46,7 @@ protected static void validateRunOnChangeTypes(final CommandScope commandScope)
     }
 
     protected static void validateReplaceIfExistsTypes(final CommandScope commandScope) throws CommandValidationException {
-        final Collection<String> replaceIfExistsTypes = new ArrayList(Arrays.asList(commandScope.getArgumentValue(REPLACE_IF_EXISTS_TYPES_ARG).split("\\s*,\\s*")));
+        final Collection<String> replaceIfExistsTypes = new ArrayList<>(Arrays.asList(commandScope.getArgumentValue(REPLACE_IF_EXISTS_TYPES_ARG).split("\\s*,\\s*")));
         final Collection<String> supportedReplaceIfExistsTypes = supportedReplaceIfExistsTypes().collect(Collectors.toList());
         supportedReplaceIfExistsTypes.add("none");
         replaceIfExistsTypes.removeAll(supportedReplaceIfExistsTypes);

liquibase-standard/src/main/java/liquibase/diff/Difference.java

@@ -3,7 +3,7 @@
 import liquibase.serializer.AbstractLiquibaseSerializable;
 import liquibase.serializer.LiquibaseSerializable;
 
-public class Difference extends AbstractLiquibaseSerializable implements Comparable, LiquibaseSerializable {
+public class Difference extends AbstractLiquibaseSerializable implements Comparable<Difference>, LiquibaseSerializable {
     private final String message;
     private final String field;
     private final Object referenceValue;
@@ -55,7 +55,7 @@
     }
 
     @Override
-    public int compareTo(Object o) {
-        return this.getField().compareTo(((Difference) o).getField());
+    public int compareTo(Difference o) {
+        return this.getField().compareTo(o.getField());
     }
 }

liquibase-standard/src/main/java/liquibase/executor/Executor.java

@@ -126,9 +126,9 @@ public interface Executor extends Plugin {
      */
     int queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException;
 
-    List queryForList(SqlStatement sql, Class elementType) throws DatabaseException;
+    <T> List<T> queryForList(SqlStatement sql, Class<T> elementType) throws DatabaseException;
 
-    List queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors) throws DatabaseException;
+    <T> List<T> queryForList(SqlStatement sql, Class<T> elementType, List<SqlVisitor> sqlVisitors) throws DatabaseException;
 
     /**
      * Executes a given SQL statement and returns a List of rows. Each row is represented a a Map<String, ?>,

liquibase-standard/src/main/java/liquibase/executor/LoggingExecutor.java

@@ -222,12 +222,12 @@ public int queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws Da
     }
 
     @Override
-    public List queryForList(SqlStatement sql, Class elementType) throws DatabaseException {
+    public <T> List<T> queryForList(SqlStatement sql, Class<T> elementType) throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql, elementType);
     }
 
     @Override
-    public List queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
+    public <T> List<T> queryForList(SqlStatement sql, Class<T> elementType, List<SqlVisitor> sqlVisitors)
             throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql, elementType, sqlVisitors);
     }
@@ -265,6 +265,4 @@ public void close() throws IOException {
         }
 
     }
-
-
 }

liquibase-standard/src/main/java/liquibase/executor/jvm/CallableStatementCallback.java

@@ -14,7 +14,7 @@
  *
  * @author Spring Framework
  */
-interface CallableStatementCallback {
+interface CallableStatementCallback<T> {
 
     /**
      * Gets called by <code>JdbcTemplate.execute</code> with an active JDBC
@@ -27,7 +27,7 @@ interface CallableStatementCallback {
      *                             into a DataAccessException by a SQLExceptionTranslator
      * @throws liquibase.exception.DatabaseException in case of custom exceptions
      */
-    Object doInCallableStatement(CallableStatement cs) throws SQLException, DatabaseException;
+    T doInCallableStatement(CallableStatement cs) throws SQLException, DatabaseException;
 
     SqlStatement getStatement();
 }

liquibase-standard/src/main/java/liquibase/executor/jvm/ColumnMapRowMapper.java

@@ -22,7 +22,7 @@
  * @author Spring Framework
  */
 @SuppressWarnings({"unchecked"})
-public class ColumnMapRowMapper implements RowMapper {
+public class ColumnMapRowMapper implements RowMapper<Map<String,?>> {
 
     private final boolean caseSensitiveDatabase;
 
@@ -31,7 +31,7 @@ public ColumnMapRowMapper(boolean caseSensitiveDatabase) {
     }
 
     @Override
-    public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
+    public Map<String,?> mapRow(ResultSet rs, int rowNum) throws SQLException {
         ResultSetMetaData rsmd = rs.getMetaData();
         int columnCount = rsmd.getColumnCount();
         Map mapOfColValues = createColumnMap(columnCount);
@@ -49,8 +49,8 @@ public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
      *                    capacity for the Map
      * @return the new Map instance
      */
-    protected Map createColumnMap(int columnCount) {
-        return new LinkedHashMap(columnCount);
+    protected Map<String,?> createColumnMap(int columnCount) {
+        return new LinkedHashMap<>(columnCount);
     }
 
     /**
@@ -80,5 +80,4 @@ protected String getColumnKey(String columnName) {
     protected Object getColumnValue(ResultSet rs, int index) throws SQLException {
         return JdbcUtil.getResultSetValue(rs, index);
     }
-
 }

liquibase-standard/src/main/java/liquibase/executor/jvm/JdbcExecutor.java

@@ -67,7 +67,7 @@
         return true;
     }
 
-    public Object execute(StatementCallback action, List<SqlVisitor> sqlVisitors) throws DatabaseException {
+    public <T> T execute(StatementCallback<T> action, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         DatabaseConnection con = database.getConnection();
         Statement stmt = null;
         try {
@@ -77,7 +77,7 @@
             stmt = ((JdbcConnection) con).getUnderlyingConnection().createStatement();
             Statement stmtToUse = stmt;
 
-            Object object = action.doInStatement(stmtToUse);
+            T object = action.doInStatement(stmtToUse);
             if (stmtToUse.getWarnings() != null) {
                 showSqlWarnings(stmtToUse);
             }
@@ -121,7 +121,7 @@
     // into a query. Instead, we process a whole query. The check should be performed at the places where
     // the query is composed.
     @SuppressWarnings("squid:S2077")
-    public Object execute(CallableStatementCallback action, List<SqlVisitor> sqlVisitors) throws DatabaseException {
+    public <T> T execute(CallableStatementCallback<T> action, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         DatabaseConnection con = database.getConnection();
 
         if (con instanceof OfflineConnection) {
@@ -167,7 +167,6 @@
             }
         }
 
-
         if (sql instanceof ExecutablePreparedStatement) {
             ((ExecutablePreparedStatement) sql).execute(new PreparedStatementFactory((JdbcConnection) database.getConnection()));
             return;
@@ -202,11 +201,11 @@
     }
 
 
-    public Object query(final SqlStatement sql, final ResultSetExtractor rse) throws DatabaseException {
+    public <T> List<T> query(final SqlStatement sql, final ResultSetExtractor<T> rse) throws DatabaseException {
         return query(sql, rse, new ArrayList<>());
     }
 
-    public Object query(final SqlStatement sql, final ResultSetExtractor rse, final List<SqlVisitor> sqlVisitors) throws DatabaseException {
+    public <T> List<T> query(final SqlStatement sql, final ResultSetExtractor<T> rse, final List<SqlVisitor> sqlVisitors) throws DatabaseException {
         if (sql instanceof RawParameterizedSqlStatement) {
             PreparedStatementFactory factory = new PreparedStatementFactory((JdbcConnection) database.getConnection());
 
@@ -221,26 +220,26 @@
         }
 
         if (sql instanceof CallableSqlStatement) {
-            return execute(new QueryCallableStatementCallback(sql, rse), sqlVisitors);
+            return execute(new QueryCallableStatementCallback<>(sql, rse), sqlVisitors);
         }
 
-        return execute(new QueryStatementCallback(sql, rse, sqlVisitors), sqlVisitors);
+        return execute(new QueryStatementCallback<>(sql, rse, sqlVisitors), sqlVisitors);
     }
 
-    public List query(SqlStatement sql, RowMapper rowMapper) throws DatabaseException {
+    public <T> List<T> query(SqlStatement sql, RowMapper<T> rowMapper) throws DatabaseException {
         return query(sql, rowMapper, new ArrayList<>());
     }
 
-    public List query(SqlStatement sql, RowMapper rowMapper, List<SqlVisitor> sqlVisitors) throws DatabaseException {
-        return (List) query(sql, new RowMapperResultSetExtractor(rowMapper), sqlVisitors);
+    public <T> List<T> query(SqlStatement sql, RowMapper<T> rowMapper, List<SqlVisitor> sqlVisitors) throws DatabaseException {
+        return query(sql, new RowMapperResultSetExtractor<>(rowMapper), sqlVisitors);
     }
 
-    public Object queryForObject(SqlStatement sql, RowMapper rowMapper) throws DatabaseException {
+    public <T> T queryForObject(SqlStatement sql, RowMapper<T> rowMapper) throws DatabaseException {
         return queryForObject(sql, rowMapper, new ArrayList<>());
     }
 
-    public Object queryForObject(SqlStatement sql, RowMapper rowMapper, List<SqlVisitor> sqlVisitors) throws DatabaseException {
-        List results = query(sql, rowMapper, sqlVisitors);
+    public <T> T queryForObject(SqlStatement sql, RowMapper<T> rowMapper, List<SqlVisitor> sqlVisitors) throws DatabaseException {
+        List<T> results = query(sql, rowMapper, sqlVisitors);
         try {
             return JdbcUtil.requiredSingleResult(results);
         } catch (DatabaseException e) {
@@ -281,12 +280,12 @@
     }
 
     @Override
-    public List queryForList(SqlStatement sql, Class elementType) throws DatabaseException {
+    public <T> List<T> queryForList(SqlStatement sql, Class<T> elementType) throws DatabaseException {
         return queryForList(sql, elementType, new ArrayList<>());
     }
 
     @Override
-    public List queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors) throws DatabaseException {
+    public <T> List<T> queryForList(SqlStatement sql, Class<T> elementType, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         return query(sql, getSingleColumnRowMapper(elementType), sqlVisitors);
     }
 
@@ -315,9 +314,9 @@
             throw new DatabaseException("Direct update using CallableSqlStatement not currently implemented");
         }
 
-        class UpdateStatementCallback implements StatementCallback {
+        class UpdateStatementCallback implements StatementCallback<Integer> {
             @Override
-            public Object doInStatement(Statement stmt) throws SQLException, DatabaseException {
+            public Integer doInStatement(Statement stmt) throws SQLException, DatabaseException {
                 String[] sqlToExecute = applyVisitors(sql, sqlVisitors);
                 if (sqlToExecute.length != 1) {
                     throw new DatabaseException("Cannot call update on Statement that returns back multiple Sql objects");
@@ -343,7 +342,7 @@
      * @return the RowMapper to use
      * @see ColumnMapRowMapper
      */
-    protected RowMapper getColumnMapRowMapper() {
+    protected RowMapper<Map<String,?>> getColumnMapRowMapper() {
         return new ColumnMapRowMapper(database.isCaseSensitive());
     }
 
@@ -354,8 +353,8 @@
      * @return the RowMapper to use
      * @see SingleColumnRowMapper
      */
-    protected RowMapper getSingleColumnRowMapper(Class requiredType) {
-        return new SingleColumnRowMapper(requiredType);
+    protected <T> RowMapper<T> getSingleColumnRowMapper(Class<T> requiredType) {
+        return new SingleColumnRowMapper<>(requiredType);
     }
 
     @Override
@@ -430,7 +429,7 @@
         return "";
     }
 
-    private class ExecuteStatementCallback implements StatementCallback {
+    private class ExecuteStatementCallback implements StatementCallback<Void> {
 
         private final SqlStatement sql;
         private final List<SqlVisitor> sqlVisitors;
@@ -441,7 +440,7 @@
         }
 
         @Override
-        public Object doInStatement(Statement stmt) throws SQLException, DatabaseException {
+        public Void doInStatement(Statement stmt) throws SQLException, DatabaseException {
             Logger log = Scope.getCurrentScope().getLog(getClass());
 
             for (String statement : applyVisitors(sql, sqlVisitors)) {
@@ -507,13 +506,13 @@
         }
     }
 
-    private class QueryStatementCallback implements StatementCallback {
+    private class QueryStatementCallback<T> implements StatementCallback<List<T>> {
 
         private final SqlStatement sql;
         private final List<SqlVisitor> sqlVisitors;
-        private final ResultSetExtractor rse;
+        private final ResultSetExtractor<T> rse;
 
-        private QueryStatementCallback(SqlStatement sql, ResultSetExtractor rse, List<SqlVisitor> sqlVisitors) {
+        private QueryStatementCallback(SqlStatement sql, ResultSetExtractor<T> rse, List<SqlVisitor> sqlVisitors) {
             this.sql = sql;
             this.rse = rse;
             this.sqlVisitors = sqlVisitors;
@@ -535,7 +534,7 @@
         // parameter into a query. Instead, we process a whole query. The check should be performed at the places where
         // the query is composed.
         @SuppressWarnings("squid:S2077")
-        public Object doInStatement(Statement stmt) throws SQLException, DatabaseException {
+        public List<T> doInStatement(Statement stmt) throws SQLException, DatabaseException {
             ResultSet rs = null;
             try {
                 String[] sqlToExecute = applyVisitors(sql, sqlVisitors);
@@ -567,19 +566,19 @@
         }
     }
 
-    private class QueryCallableStatementCallback implements CallableStatementCallback {
+    private class QueryCallableStatementCallback<T> implements CallableStatementCallback<List<T>> {
 
         private final SqlStatement sql;
-        private final ResultSetExtractor rse;
+        private final ResultSetExtractor<T> rse;
 
-        private QueryCallableStatementCallback(SqlStatement sql, ResultSetExtractor rse) {
+        private QueryCallableStatementCallback(SqlStatement sql, ResultSetExtractor<T> rse) {
             this.sql = sql;
             this.rse = rse;
         }
 
 
         @Override
-        public Object doInCallableStatement(CallableStatement cs) throws SQLException, DatabaseException {
+        public List<T> doInCallableStatement(CallableStatement cs) throws SQLException, DatabaseException {
             ResultSet rs = null;
             try {
                 rs = cs.executeQuery();

liquibase-standard/src/main/java/liquibase/executor/jvm/ResultSetExtractor.java

@@ -2,6 +2,7 @@
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.List;
 
 /**
  * Callback interface used by {@link liquibase.executor.Executor}'s query methods.
@@ -16,7 +17,7 @@
  * @see RowCallbackHandler
  * @see RowMapper
  */
-interface ResultSetExtractor {
+interface ResultSetExtractor<T> {
 
     /**
      * Implementations must implement this method to process the entire ResultSet.
@@ -29,6 +30,5 @@ interface ResultSetExtractor {
      *                               values or navigating (that is, there's no need to catch SQLException)
      * @throws liquibase.exception.DatabaseException         in case of custom exceptions
      */
-    Object extractData(ResultSet rs) throws SQLException;
-
+    List<T> extractData(ResultSet rs) throws SQLException;
 }

liquibase-standard/src/main/java/liquibase/executor/jvm/RowMapper.java

@@ -17,7 +17,7 @@
  * @see RowCallbackHandler
  * @see ResultSetExtractor
  */
-public interface RowMapper {
+public interface RowMapper<T> {
 
     /**
      * Implementations must implement this method to map each row of data
@@ -30,6 +30,5 @@ public interface RowMapper {
      * @throws java.sql.SQLException if a SQLException is encountered getting
      *                               column values (that is, there's no need to catch SQLException)
      */
-    Object mapRow(ResultSet rs, int rowNum) throws SQLException;
-
+    T mapRow(ResultSet rs, int rowNum) throws SQLException;
 }