Retriving SMART data

src/main/java/org/leolo/nrdatad/cron/ReferenceDataJob.java

@@ -27,7 +27,7 @@ public class ReferenceDataJob implements Job {
     @Override
     public void execute(JobExecutionContext context) throws JobExecutionException {
         log.atInfo().log("Load reference data triggered at {}", context.getFireTime());
-        //There are 3 different kind of reference data. Create 3 thread and deal with them
+        //There are 2 different kind of reference data. Create 2 thread and deal with them
         new Thread(()->{processCORPUS();}).start();
         new Thread(()->{processSMART();}).start();
     }

src/main/java/org/leolo/nrdatad/db/ParameterStore.java

@@ -1,5 +1,7 @@
 package org.leolo.nrdatad.db;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -11,6 +13,16 @@ public class ParameterStore extends ArrayList<String> {
         return super.indexOf(o)+1;
     }
 
+    public void addAllObject(@NotNull Collection<?> c){
+        for(Object obj:c){
+            add(c.toString());
+        }
+    }
+
+    public void addObject(Object obj){
+        add(obj==null?null:obj.toString());
+    }
+
     @Override
     public int lastIndexOf(Object o) {
         return super.lastIndexOf(o)+1;

src/main/java/org/leolo/nrdatad/db/SmartDao.java

@@ -1,9 +1,16 @@
 package org.leolo.nrdatad.db;
 
+import org.leolo.nrdatad.model.Corpus;
 import org.leolo.nrdatad.model.Smart;
+import org.leolo.nrdatad.model.SmartEvent;
+import org.leolo.nrdatad.model.SmartStepType;
+import org.leolo.nrdatad.util.Range;
 
 import java.sql.SQLException;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 public abstract class SmartDao extends BaseDao{
 
@@ -21,5 +28,202 @@ public abstract class SmartDao extends BaseDao{
         }
     }
 
+    public abstract Collection<Smart> searchSmartByBerth(String fromBerth, String toBerth) throws SQLException;
+
+    public abstract Collection<Smart> searchFromByBerth(String fromBerth) throws SQLException;
+
+    public abstract Collection<Smart> searchToBerth(String toBerth) throws SQLException;
+
+    public abstract Collection<Smart> searchSmartByBerthLine(String fromBerth, String toBerth, String fromLine, String toLine) throws SQLException;
+    public abstract Collection<Smart> searchSmartByFromBerthLine(String fromBerth,String fromLine) throws SQLException;
+    public abstract Collection<Smart> searchSmartByToBerthLine(String toBerth, String toLine) throws SQLException;
+
+    public abstract Collection<Smart> searchSmartByStanox(String stanox) throws SQLException;
+
+
+    public abstract Collection<Smart> executeQuery(Query query) throws SQLException;
+
+
+    public static class QueryBuilder{
+        private Set<String> td = new HashSet<>();
+        private Set<String> fromBerth = new HashSet<>();
+        private Set<String> toBerth = new HashSet<>();
+        private Set<String> fromLine = new HashSet<>();
+        private Set<String> toLine = new HashSet<>();
+        private Set<Range<Integer>> berthOffset = new HashSet<>();
+        private Set<String> platform = new HashSet<>();
+        private Set<SmartEvent> event = new HashSet<>();
+        private Set<String> route = new HashSet<>();
+        private Set<String> stanox = new HashSet<>();
+        private Set<String> stationName = new HashSet<>();
+        private Set<SmartStepType> stepType = new HashSet<>();
+        private Set<String> comment = new HashSet<>();
+        private SearchMode searchMode = SearchMode.MATCH_ALL_GROUP;
+
+        public QueryBuilder addTd(String td){
+            this.td.add(td);
+            return this;
+        }
+
+        public QueryBuilder addFromBerth(String fromBerth){
+            this.fromBerth.add(fromBerth);
+            return this;
+        }
+
+        public QueryBuilder addToBerth(String toBerth){
+            this.toBerth.add(toBerth);
+            return this;
+        }
+
+        public QueryBuilder addFromLine(String fromLine){
+            this.fromLine.add(fromLine);
+            return this;
+        }
+
+        public QueryBuilder addToLine(String toLine){
+            this.toLine.add(toLine);
+            return this;
+        }
+
+        public QueryBuilder addBerthOffset(int bound1, int bound2){
+            this.berthOffset.add(new Range<>(bound1, bound2));
+            return this;
+        }
+
+        public QueryBuilder addPlatform(String platform){
+            this.platform.add(platform);
+            return this;
+        }
+
+        public QueryBuilder addEvent(SmartEvent event){
+            this.event.add(event);
+            return this;
+        }
+
+        public QueryBuilder addRoute(String route){
+            this.route.add(route);
+            return this;
+        }
+
+        public QueryBuilder addStanox(String stanox){
+            this.stanox.add(stanox);
+            return this;
+        }
+
+        public QueryBuilder addStationName(String stationName){
+            this.stationName.add(stationName);
+            return this;
+        }
+
+        public QueryBuilder addStepType(SmartStepType stepType){
+            this.stepType.add(stepType);
+            return this;
+        }
+
+        public QueryBuilder addComment(String comment){
+            this.comment.add(comment);
+            return this;
+        }
+
+        public QueryBuilder setSearchMode(SearchMode searchMode){
+            this.searchMode=searchMode;
+            return this;
+        }
+
+        public Query build(){
+            return new Query(td, fromBerth, toBerth, fromLine, toLine, berthOffset, platform, event, route, stanox, stationName, stepType, comment, searchMode);
+        }
+    }
+
+    public static class Query{
+
+        private Set<String> td;
+        private Set<String> fromBerth;
+        private Set<String> toBerth;
+        private Set<String> fromLine;
+        private Set<String> toLine;
+        private Set<Range<Integer>> berthOffset;
+        private Set<String> platform;
+        private Set<SmartEvent> event;
+        private Set<String> route;
+        private Set<String> stanox;
+        private Set<String> stationName;
+        private Set<SmartStepType> stepType;
+        private Set<String> comment;
+        private SearchMode searchMode = SearchMode.MATCH_ALL_GROUP;
+
+        public Query(Set<String> td, Set<String> fromBerth, Set<String> toBerth, Set<String> fromLine, Set<String> toLine, Set<Range<Integer>> berthOffset, Set<String> platform, Set<SmartEvent> event, Set<String> route, Set<String> stanox, Set<String> stationName, Set<SmartStepType> stepType, Set<String> comment, SearchMode searchMode) {
+            this.td = Collections.unmodifiableSet(td);
+            this.fromBerth = Collections.unmodifiableSet(fromBerth);
+            this.toBerth = Collections.unmodifiableSet(toBerth);
+            this.fromLine = Collections.unmodifiableSet(fromLine);
+            this.toLine = Collections.unmodifiableSet(toLine);
+            this.berthOffset = Collections.unmodifiableSet(berthOffset);
+            this.platform = Collections.unmodifiableSet(platform);
+            this.event = Collections.unmodifiableSet(event);
+            this.route = Collections.unmodifiableSet(route);
+            this.stanox = Collections.unmodifiableSet(stanox);
+            this.stationName = Collections.unmodifiableSet(stationName);
+            this.stepType = Collections.unmodifiableSet(stepType);
+            this.comment = Collections.unmodifiableSet(comment);
+            this.searchMode = searchMode;
+        }
+
+        public Set<String> getTd() {
+            return td;
+        }
+
+        public Set<String> getFromBerth() {
+            return fromBerth;
+        }
+
+        public Set<String> getToBerth() {
+            return toBerth;
+        }
+
+        public Set<String> getFromLine() {
+            return fromLine;
+        }
+
+        public Set<String> getToLine() {
+            return toLine;
+        }
+
+        public Set<Range<Integer>> getBerthOffset() {
+            return berthOffset;
+        }
+
+        public Set<String> getPlatform() {
+            return platform;
+        }
+
+        public Set<SmartEvent> getEvent() {
+            return event;
+        }
+
+        public Set<String> getRoute() {
+            return route;
+        }
+
+        public Set<String> getStanox() {
+            return stanox;
+        }
+
+        public Set<String> getStationName() {
+            return stationName;
+        }
+
+        public Set<SmartStepType> getStepType() {
+            return stepType;
+        }
+
+        public Set<String> getComment() {
+            return comment;
+        }
+
+        public SearchMode getSearchMode() {
+            return searchMode;
+        }
+    }
 
 }

src/main/java/org/leolo/nrdatad/db/mariadb/SmartDao.java

@@ -1,15 +1,21 @@
 package org.leolo.nrdatad.db.mariadb;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.leolo.nrdatad.db.DatabaseManager;
+import org.leolo.nrdatad.db.ParameterStore;
+import org.leolo.nrdatad.db.SearchMode;
 import org.leolo.nrdatad.model.Smart;
+import org.leolo.nrdatad.model.SmartEvent;
+import org.leolo.nrdatad.model.SmartStepType;
+import org.leolo.nrdatad.util.Range;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.sql.Statement;
+import java.sql.*;
 import java.util.Collection;
+import java.util.Vector;
 
 public class SmartDao extends org.leolo.nrdatad.db.SmartDao {
+    Logger log = LogManager.getLogger();
 
     public SmartDao(DatabaseManager manager) {
         super(manager);
@@ -83,4 +89,234 @@ public class SmartDao extends org.leolo.nrdatad.db.SmartDao {
             stmt.executeUpdate("TRUNCATE TABLE smart");
         }
     }
+
+    private Smart parseResultSet(ResultSet rs) throws SQLException{
+        Smart smart = new Smart();
+        smart.setSmartId(rs.getInt("smart_id"));
+        smart.setTd(rs.getString("td"));
+        smart.setFromBerth(rs.getString("from_berth"));
+        smart.setToBerth(rs.getString("to_berth"));
+        smart.setFromLine(rs.getString("from_line"));
+        smart.setToLine(rs.getString("to_line"));
+        smart.setBerthOffset(rs.getInt("berth_offset"));
+        smart.setPlatform(rs.getString("platform"));
+        smart.setEvent(SmartEvent.parseCode(rs.getString("event")));
+        smart.setRoute(rs.getString("route"));
+        smart.setStanox(rs.getString("stanox"));
+        smart.setStationName(rs.getString("station_name"));
+        smart.setStepType(SmartStepType.parseCode(rs.getString("step_type")));
+        smart.setComment(rs.getString("comment"));
+        return smart;
+    }
+
+    @Override
+    public Collection<Smart> searchSmartByBerth(String fromBerth, String toBerth) throws SQLException {
+        Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM smart WHERE from_berth = ? AND  to_berth = ?");
+        ){
+            pstmt.setString(1, fromBerth);
+            pstmt.setString(2, toBerth);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchFromByBerth(String fromBerth) throws SQLException {
+        Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM smart WHERE from_berth =?");
+        ){
+            pstmt.setString(1, fromBerth);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchToBerth(String toBerth) throws SQLException {Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM smart WHERE to_berth = ?");
+        ){
+            pstmt.setString(1, toBerth);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchSmartByBerthLine(String fromBerth, String toBerth, String fromLine, String toLine) throws SQLException {
+        Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement(
+                        "SELECT * FROM smart WHERE from_berth = ? AND  to_berth = ? AND from_line = ? AND to_line = ?");
+        ){
+            pstmt.setString(1, fromBerth);
+            pstmt.setString(2, toBerth);
+            pstmt.setString(3, fromLine);
+            pstmt.setString(4, toLine);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchSmartByFromBerthLine(String fromBerth, String fromLine) throws SQLException {
+        Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement(
+                        "SELECT * FROM smart WHERE from_berth = ? AND  to_berth = ? AND from_line = ? AND to_line = ?");
+        ){
+            pstmt.setString(1, fromBerth);
+            pstmt.setString(2, fromLine);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchSmartByToBerthLine(String toBerth, String toLine) throws SQLException {
+        Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement(
+                        "SELECT * FROM smart WHERE from_berth = ? AND  to_berth = ? AND from_line = ? AND to_line = ?");
+        ){
+            pstmt.setString(1, toBerth);
+            pstmt.setString(2, toLine);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> searchSmartByStanox(String stanox) throws SQLException {Vector<Smart> vector = new Vector<>();
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement(
+                        "SELECT * FROM smart WHERE stanox = ?");
+        ){
+            pstmt.setString(1, stanox);
+            try(ResultSet rs = pstmt.executeQuery()){
+                vector.add(parseResultSet(rs));
+            }
+        }
+        return vector;
+    }
+
+    @Override
+    public Collection<Smart> executeQuery(Query query) throws SQLException {
+        Vector<Smart> smarts = new Vector<>();
+        ParameterStore ps = new ParameterStore();
+        StringBuilder sql = new StringBuilder();
+        if(query.getSearchMode()== SearchMode.MATCH_ALL_GROUP || query.getSearchMode()==SearchMode.MATCH_ANY){
+            sql.append("SELECT * FROM smart WHERE ");
+            String keyWord;
+            if(query.getSearchMode() == SearchMode.MATCH_ALL_GROUP){
+                sql.append("1=1 ");
+                keyWord = "AND ";
+            }else{
+                sql.append("1=0 ");
+                keyWord = "OR ";
+            }
+            if(query.getTd().size()>0){
+                sql.append(keyWord).append("td IN (").append(getQueryParams(query.getTd().size())).append(") ");
+                ps.addAll(query.getTd());
+            }
+            if(query.getFromBerth().size()>0){
+                sql.append(keyWord).append("from_berth IN(").append(getQueryParams(query.getFromBerth().size())).append(") ");
+                ps.addAll(query.getFromBerth());
+            }
+            if(query.getToBerth().size()>0){
+                sql.append(keyWord).append("to_berth IN(").append(getQueryParams(query.getToBerth().size())).append(") ");
+                ps.addAll(query.getToBerth());
+            }
+            if(query.getFromLine().size()>0){
+                sql.append(keyWord).append("from_line IN(").append(getQueryParams(query.getFromLine().size())).append(") ");
+                ps.addAll(query.getFromLine());
+            }
+            if (query.getToLine().size()>0){
+                sql.append(keyWord).append("to_line (").append(getQueryParams(query.getToLine().size())).append(") ");
+                ps.addAll(query.getToLine());
+            }
+            if (query.getBerthOffset().size()>0){
+                sql.append(keyWord).append("(1=0 ");
+                for(Range<Integer> range: query.getBerthOffset()){
+                    sql.append("OR (berth_offset BETWEEN ? AND ?) ");
+                    ps.addObject(range.getLowerBound());
+                    ps.addObject(range.getUpperBound());
+                }
+                sql.append(") ");
+            }
+            if(query.getPlatform().size()>0){
+                sql.append(keyWord).append("platform IN(").append(getQueryParams(query.getPlatform().size())).append(") ");
+                ps.addAll(query.getPlatform());
+            }
+            if(query.getEvent().size()>0){
+                sql.append(keyWord).append("event IN(").append(getQueryParams(query.getEvent().size())).append(") ");
+                ps.addAllObject(query.getEvent());
+            }
+            if(query.getRoute().size()>0){
+                sql.append(keyWord).append("route IN(").append(getQueryParams(query.getRoute().size())).append(") ");
+                ps.addAll(query.getRoute());
+            }
+            if(query.getStanox().size()>0){
+                sql.append(keyWord).append("stanox IN(").append(getQueryParams(query.getStanox().size())).append(") ");
+                ps.addAll(query.getStanox());
+            }
+            if(query.getStationName().size()>0){
+                sql.append(keyWord).append("(1=0 ");
+                for(String stationName: query.getStationName()){
+                    sql.append("OR station_name LIKE ? ");
+                    ps.add("%"+stationName+"%");
+                }
+                sql.append(") ");
+            }
+            if(query.getStepType().size()>0){
+                sql.append(keyWord).append("step_type IN(").append(getQueryParams(query.getStepType().size())).append(") ");
+                ps.addAllObject(query.getStepType());
+            }
+            if(query.getComment().size()>0){
+                sql.append(keyWord).append("(1=0 ");
+                for(String comment: query.getComment()){
+                    sql.append("OR comment LIKE ? ");
+                    ps.add("%"+comment+"%");
+                }
+                sql.append(") ");
+            }
+        }
+        try(
+                Connection conn = getConnection();
+                PreparedStatement pstmt = conn.prepareStatement(sql.toString())
+        ){
+            for(int i=1;i<=ps.size();i++){
+                log.atDebug().log("Param {} = {}", i, ps.get(i));
+                setString(pstmt, i, ps.get(i));
+            }
+            try(ResultSet rs = pstmt.executeQuery()){
+                while(rs.next()){
+                    smarts.add(parseResultSet(rs));
+                }
+            }
+        }
+        return smarts;
+    }
 }