feat: 优化逻辑

backend/src/main/java/com/yfd/platform/env/wq/controller/EnvWqDataController.java

@@ -29,6 +29,18 @@ public class EnvWqDataController {
         return ResponseResult.successData(envWqDataService.processKendoList(dataSourceRequest));
     }
 
+    @PostMapping("/GetStbprpYsByStcd")
+    @Operation(summary = "水质统计分析")
+    public ResponseResult GetStbprpYsByStcd(@RequestBody DataSourceRequest dataSourceRequest) {
+        return ResponseResult.successData(null);
+    }
+
+    @PostMapping("/GetStTbYsBVoKendoListCust")
+    @Operation(summary = "水质统计分析")
+    public ResponseResult GetStTbYsBVoKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
+        return ResponseResult.successData(null);
+    }
+
     @PostMapping("/data/noAuth/GetKendoListCust")
     @Operation(summary = "水质统计分析")
     public ResponseResult getNoAuthKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {

backend/src/main/java/com/yfd/platform/env/wq/service/impl/EnvWqDataServiceImpl.java

@@ -1,21 +1,30 @@
 package com.yfd.platform.env.wq.service.impl;
 
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.yfd.platform.common.CommonConstant;
 import com.yfd.platform.common.DataSourceLoadOptionsBase;
 import com.yfd.platform.common.DataSourceRequest;
 import com.yfd.platform.common.DataSourceResult;
+import com.yfd.platform.common.GroupHelper;
+import com.yfd.platform.common.GroupingInfo;
 import com.yfd.platform.common.MicroservicDynamicSQLMapper;
 import com.yfd.platform.common.PageInfo;
 import com.yfd.platform.common.exception.BizException;
+import com.yfd.platform.env.wq.entity.vo.EnvWqVo;
 import com.yfd.platform.env.wq.entity.vo.WqBaseInfoVo;
 import com.yfd.platform.env.wq.entity.vo.WqVmsstbprptVo;
 import com.yfd.platform.env.wq.service.EnvWqDataService;
+import com.yfd.platform.utils.KendoUtil;
 import com.yfd.platform.utils.QgcQueryWrapperUtil;
+import com.yfd.platform.utils.RequestHolder;
+import com.yfd.platform.utils.SecurityUtils;
 import jakarta.annotation.Resource;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -28,7 +37,50 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
 
     @Override
     public DataSourceResult processKendoList(DataSourceRequest dataSourceRequest) {
-        return emptyResult();
+        boolean calculated = CommonConstant.CALCULATE_SUCCESS.equals(
+                RequestHolder.getHttpServletRequest().getParameter(CommonConstant.CALCULATE_FLAG)
+        );
+
+        StringBuilder sql = new StringBuilder(buildEnvWqProcessBaseSql(calculated));
+        Map<String, Object> paramMap = new HashMap<>();
+        if (calculated) {
+            paramMap.put("recordUser", SecurityUtils.getUserId());
+        }
+
+        String filterSql = buildEnvWqFilterCondition(dataSourceRequest == null ? null : dataSourceRequest.getFilter(),
+                paramMap, new int[]{0});
+        if (StrUtil.isNotBlank(filterSql)) {
+            sql.append(" AND ").append(filterSql).append(" ");
+        }
+
+        DataSourceLoadOptionsBase loadOptions = dataSourceRequest.toDevRequest();
+        String groupBy = KendoUtil.getGroupBy(dataSourceRequest);
+        GroupingInfo[] groupInfos = loadOptions.getGroup();
+        if (StrUtil.isNotBlank(groupBy) && groupInfos != null && groupInfos.length > 0) {
+            String groupedSql = buildEnvWqGroupSql(sql.toString(), dataSourceRequest, groupInfos);
+            List<Map<String, Object>> list = microservicDynamicSQLMapper.pageAllList(null, groupedSql, paramMap);
+            DataSourceResult result = new DataSourceResult();
+            if (Boolean.TRUE.equals(dataSourceRequest.getGroupResultFlat())) {
+                result.setData(new GroupHelper().faltGroup(list, Arrays.asList(groupInfos)));
+            } else {
+                result.setData(new GroupHelper().group(list, Arrays.asList(groupInfos)));
+            }
+            result.setTotal(0L);
+            result.setAggregates(new HashMap<>());
+            return result;
+        }
+
+        sql.append(buildEnvWqOrderBySql(dataSourceRequest.getSort()));
+        PageInfo pageInfo = QgcQueryWrapperUtil.getPageInfo(loadOptions);
+        Page<?> page = pageInfo.getHasPageInfo() ? pageInfo.getPage() : null;
+        List<EnvWqVo> list = microservicDynamicSQLMapper.pageAllListWithResultType(page, sql.toString(), paramMap, EnvWqVo.class);
+        fillEnvWqDerivedFields(list, calculated);
+
+        DataSourceResult<EnvWqVo> result = new DataSourceResult<>();
+        result.setData(list);
+        result.setTotal(page != null ? page.getTotal() : list.size());
+        result.setAggregates(new HashMap<>());
+        return result;
     }
 
     @Override
@@ -101,7 +153,7 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
             sql.append("AND CASE WHEN recent.STCD IS NOT NULL THEN 1 ELSE 0 END = #{map.coenvwState} ");
         }
 
-        sql.append(buildVmsstbprptOrderBySql(dataSourceRequest.getSort()));
+//        sql.append(buildEnvWqOrderBySql(dataSourceRequest.getSort()));
         PageInfo pageInfo = QgcQueryWrapperUtil.getPageInfo(loadOptions);
         Page<?> page = pageInfo.getHasPageInfo() ? pageInfo.getPage() : null;
         List<WqVmsstbprptVo> list = microservicDynamicSQLMapper.pageAllListWithResultType(page, sql.toString(), paramMap, WqVmsstbprptVo.class);
@@ -187,6 +239,298 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
         return list.get(0);
     }
 
+    private String buildEnvWqProcessBaseSql(boolean calculated) {
+        StringBuilder sql = new StringBuilder();
+        sql.append("SELECT ")
+                .append("T.STCD AS stcd, ")
+                .append("T.STNM AS stnm, ")
+                .append("T.RSTCD AS rstcd, ")
+                .append("T.ENNM AS ennm, ")
+                .append("T.DTINTYPE AS dtinType, ")
+                .append("T.BASE_ID AS baseId, ")
+                .append("T.BASE_NAME AS baseName, ")
+                .append("T.RVCD_NAME AS rvcdName, ")
+                .append("T.ADDVCD_NAME AS addvcdName, ")
+                .append("T.HBRVCD AS hbrvcd, ")
+                .append("T.HBRVCD_NAME AS hbrvcdName, ")
+                .append("T.WWQTG AS wwqtg, ")
+                .append("T.RSTCDSTEPSORT AS rstcdStepSort, ")
+                .append("T.BASESTEPSORT AS baseStepSort, ")
+                .append("T.RVCDSTEPSORT AS rvcdStepSort, ")
+                .append("T.SITESTEPSORT AS siteStepSort, ")
+                .append("T.ID AS id, ")
+                .append("T.TM AS tm, ")
+                .append("T.TYPE AS type, ")
+                .append("T.STTYPE AS sttype, ")
+                .append("T.SFDB AS sfdb, ")
+                .append("T.DR_MONTH AS drMonth, ")
+                .append("T.DR_YEAR AS drYear, ")
+                .append("T.WQ_SFDB_HY AS wqSfdbHy, ")
+                .append("T.WQ_SFDB_COUNT AS wqSfdbCount, ")
+                .append("T.WQ_SFDB_HO AS wqSfdbHo, ")
+                .append("T.WQ_RATE AS wqRate, ")
+                .append("T.WQ_SFDB_HN AS wqSfdbHn, ")
+                .append("T.WQGRD AS wqGrd, ")
+                .append("T.BEFOREWQGRD AS beforeWqGrd ")
+                .append("FROM (SELECT ")
+                .append("MSB.STCD, MSB.STNM, MSB.RSTCD, MSB.ENNM, MSB.DTIN_TYPE AS dtinType, ")
+                .append("MSB.BASE_ID, MSB.BASE_NAME, MSB.RVCD_NAME, MSB.ADDVCD_NAME, MSB.HBRVCD, MSB.HBRVCD_NAME, ")
+                .append("MSB.WWQTG, MSB.RSTCDSTEPSORT, MSB.BASESTEPSORT, MSB.RVCDSTEPSORT, MSB.SITESTEPSORT, ")
+                .append("MWT.ID, MWT.TM, MWT.TYPE, TO_CHAR(MWT.STTYPE) AS STTYPE, MWT.SFDB, MWT.DR_MONTH, MWT.DR_YEAR, ")
+                .append("MWT.WQ_SFDB_HY, MWT.WQ_SFDB_COUNT, MWT.WQ_SFDB_HO, MWT.WQ_RATE, MWT.WQ_SFDB_HN, ");
+        if (calculated) {
+            sql.append("CAST(NULL AS VARCHAR2(16)) AS WQGRD, CAST(NULL AS VARCHAR2(16)) AS BEFOREWQGRD ");
+        } else {
+            sql.append("WQD.WQGRD AS WQGRD, WQD2.WQGRD AS BEFOREWQGRD ");
+        }
+        sql.append("FROM (").append(buildStationBaseSql()).append(") MSB ");
+        if (calculated) {
+            sql.append("INNER JOIN MS_WQCALCULATION_T MWT ON MWT.STCD = MSB.STCD ")
+                    .append("WHERE MWT.RECORD_USER = #{map.recordUser} ");
+        } else {
+            sql.append("INNER JOIN MS_WQ_T MWT ON MWT.STCD = MSB.STCD ")
+                    .append("LEFT JOIN SD_WQDAY_S WQD ON WQD.DT = MWT.TM AND MSB.STCD = WQD.STCD AND NVL(WQD.IS_DELETED, 0) = 0 ")
+                    .append("LEFT JOIN SD_WQDAY_S WQD2 ON ADD_MONTHS(WQD2.DT, 12) = WQD.DT AND WQD2.STCD = WQD.STCD AND NVL(WQD2.IS_DELETED, 0) = 0 ");
+        }
+        sql.append(") T WHERE 1 = 1 ");
+        return sql.toString();
+    }
+
+    private String buildStationBaseSql() {
+        return "SELECT " +
+                "wq.STCD, " +
+                "wq.STNM, " +
+                "wq.RSTCD, " +
+                "eng.ENNM, " +
+                "eng.BASE_ID, " +
+                "hb.BASENAME AS BASE_NAME, " +
+                "eng.HBRVCD, " +
+                "hbrv.HBRVNM AS HBRVCD_NAME, " +
+                "rv.RVNM AS RVCD_NAME, " +
+                "addv.ADDVNM AS ADDVCD_NAME, " +
+                "wq.WWQTG, " +
+                "wq.DTIN_TYPE, " +
+                "rstAlong.SORT AS RSTCDSTEPSORT, " +
+                "hb.ORDER_INDEX AS BASESTEPSORT, " +
+                "rvAlong.ORDER_INDEX AS RVCDSTEPSORT, " +
+                "siteAlong.SORT AS SITESTEPSORT " +
+                "FROM SD_WQ_B_H wq " +
+                "LEFT JOIN SD_ENGINFO_B_H eng ON eng.STCD = wq.RSTCD " +
+                "LEFT JOIN SD_HYDROBASE hb ON hb.BASEID = eng.BASE_ID AND NVL(hb.IS_DELETED, 0) = 0 " +
+                "LEFT JOIN SD_HBRV_DIC hbrv ON hbrv.HBRVCD = eng.HBRVCD AND hbrv.BASEID = eng.BASE_ID AND NVL(hbrv.IS_DELETED, 0) = 0 AND NVL(hbrv.ENABLED, 1) = 1 " +
+                "LEFT JOIN SD_RVCD_DIC rv ON rv.RVCD = eng.RVCD " +
+                "LEFT JOIN SD_ADDVCD_DIC addv ON addv.ADDVCD = eng.ADDVCD " +
+                "LEFT JOIN MS_ALONG_B rvAlong ON rvAlong.RVCD = eng.HBRVCD AND rvAlong.CODE = 'common' AND NVL(rvAlong.IS_DELETED, 0) = 0 " +
+                "LEFT JOIN (SELECT det.SORT, along.RVCD, det.STCD " +
+                "           FROM MS_ALONGDET_B det " +
+                "           INNER JOIN MS_ALONG_B along ON det.ALONG_ID = along.ID " +
+                "           WHERE NVL(det.IS_DELETED, 0) = 0 AND NVL(along.IS_DELETED, 0) = 0 AND along.CODE = 'common') rstAlong " +
+                "       ON rstAlong.RVCD = eng.HBRVCD AND rstAlong.STCD = wq.RSTCD " +
+                "LEFT JOIN (SELECT det.SORT, along.RVCD, det.STCD " +
+                "           FROM MS_ALONGDET_B det " +
+                "           INNER JOIN MS_ALONG_B along ON det.ALONG_ID = along.ID " +
+                "           WHERE NVL(det.IS_DELETED, 0) = 0 AND NVL(along.IS_DELETED, 0) = 0 AND along.CODE = 'common') siteAlong " +
+                "       ON siteAlong.RVCD = eng.HBRVCD AND siteAlong.STCD = wq.STCD " +
+                "WHERE wq.STTP = 'WQ' AND NVL(wq.IS_DELETED, 0) = 0";
+    }
+
+    private String buildEnvWqFilterCondition(DataSourceRequest.FilterDescriptor filter,
+                                             Map<String, Object> paramMap,
+                                             int[] indexHolder) {
+        if (filter == null) {
+            return "";
+        }
+        if (StrUtil.isNotBlank(filter.getField())) {
+            return buildEnvWqLeafCondition(filter, paramMap, indexHolder);
+        }
+        if (CollUtil.isEmpty(filter.getFilters())) {
+            return "";
+        }
+        List<String> conditions = new ArrayList<>();
+        for (DataSourceRequest.FilterDescriptor child : filter.getFilters()) {
+            String childSql = buildEnvWqFilterCondition(child, paramMap, indexHolder);
+            if (StrUtil.isNotBlank(childSql)) {
+                conditions.add(childSql);
+            }
+        }
+        if (conditions.isEmpty()) {
+            return "";
+        }
+        String logic = "or".equalsIgnoreCase(filter.getLogic()) ? " OR " : " AND ";
+        return "(" + String.join(logic, conditions) + ")";
+    }
+
+    private String buildEnvWqLeafCondition(DataSourceRequest.FilterDescriptor filter,
+                                           Map<String, Object> paramMap,
+                                           int[] indexHolder) {
+        String column = mapEnvWqColumn(filter.getField());
+        if (StrUtil.isBlank(column) || filter.getValue() == null) {
+            return "";
+        }
+        String operator = StrUtil.blankToDefault(filter.getOperator(), "eq").toLowerCase();
+        String key = "envWqParam" + indexHolder[0]++;
+        boolean isDateField = "tm".equals(filter.getField());
+        switch (operator) {
+            case "eq":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " = TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " = #{map." + key + "}";
+            case "neq":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " <> TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " <> #{map." + key + "}";
+            case "gt":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " > TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " > #{map." + key + "}";
+            case "gte":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " >= TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " >= #{map." + key + "}";
+            case "lt":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " < TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " < #{map." + key + "}";
+            case "lte":
+                paramMap.put(key, filter.getValue());
+                return isDateField
+                        ? column + " <= TO_DATE(#{map." + key + "}, 'YYYY-MM-DD HH24:MI:SS')"
+                        : column + " <= #{map." + key + "}";
+            case "contains":
+                paramMap.put(key, "%" + filter.getValue() + "%");
+                return column + " LIKE #{map." + key + "}";
+            default:
+                return "";
+        }
+    }
+
+    private String mapEnvWqColumn(String field) {
+        if (StrUtil.isBlank(field)) {
+            return null;
+        }
+        return switch (field) {
+            case "stcd" -> "T.STCD";
+            case "stnm" -> "T.STNM";
+            case "rstcd" -> "T.RSTCD";
+            case "ennm" -> "T.ENNM";
+            case "baseId" -> "T.BASE_ID";
+            case "baseName" -> "T.BASE_NAME";
+            case "rvcdName" -> "T.RVCD_NAME";
+            case "addvcdName" -> "T.ADDVCD_NAME";
+            case "hbrvcd" -> "T.HBRVCD";
+            case "hbrvcdName" -> "T.HBRVCD_NAME";
+            case "wwqtg" -> "T.WWQTG";
+            case "id" -> "T.ID";
+            case "tm" -> "T.TM";
+            case "type" -> "T.TYPE";
+            case "sttype" -> "T.STTYPE";
+            case "sfdb" -> "T.SFDB";
+            case "rstcdStepSort" -> "T.RSTCDSTEPSORT";
+            case "baseStepSort" -> "T.BASESTEPSORT";
+            case "rvcdStepSort" -> "T.RVCDSTEPSORT";
+            case "siteStepSort" -> "T.SITESTEPSORT";
+            case "drMonth" -> "T.DR_MONTH";
+            case "drYear" -> "T.DR_YEAR";
+            case "wqSfdbHy" -> "T.WQ_SFDB_HY";
+            case "wqSfdbHn" -> "T.WQ_SFDB_HN";
+            case "wqSfdbCount" -> "T.WQ_SFDB_COUNT";
+            case "wqSfdbHo" -> "T.WQ_SFDB_HO";
+            case "wqRate" -> "T.WQ_RATE";
+            default -> null;
+        };
+    }
+
+    private String buildEnvWqGroupSql(String baseSql,
+                                      DataSourceRequest dataSourceRequest,
+                                      GroupingInfo[] groupInfos) {
+        List<String> groupFields = new ArrayList<>();
+        for (GroupingInfo item : groupInfos) {
+            if (item != null && StrUtil.isNotBlank(item.getSelector())) {
+                groupFields.add(item.getSelector());
+            }
+        }
+        StringBuilder sql = new StringBuilder("SELECT ");
+        sql.append(String.join(", ", groupFields));
+
+        List<DataSourceRequest.AggregateDescriptor> aggregates = dataSourceRequest.getAggregate();
+        boolean hasWqRateAggregate = CollUtil.isNotEmpty(aggregates)
+                && aggregates.stream().anyMatch(i -> "wqRate".equals(i.getField()));
+        if (hasWqRateAggregate && groupInfos.length > 0) {
+            sql.append(", CASE ")
+                    .append("WHEN SUM(wqSfdbCount) = 0 THEN NULL ")
+                    .append("WHEN SUM(wqSfdbCount) = SUM(wqSfdbHo) THEN NULL ")
+                    .append("WHEN (SUM(wqSfdbHy) + SUM(wqSfdbHn)) = 0 THEN NULL ")
+                    .append("ELSE (SUM(wqSfdbHy) / (SUM(wqSfdbHy) + SUM(wqSfdbHn))) * 100 END AS count_")
+                    .append(groupInfos[groupInfos.length - 1].getSelector()).append(" ");
+        } else {
+            for (GroupingInfo item : groupInfos) {
+                sql.append(", COUNT(*) AS count_").append(item.getSelector()).append(" ");
+            }
+        }
+        sql.append("FROM (").append(baseSql).append(") T ");
+        String groupBy = KendoUtil.getGroupBy(dataSourceRequest);
+        if (StrUtil.isNotBlank(groupBy)) {
+            sql.append(groupBy);
+        }
+        return sql.toString();
+    }
+
+    private void fillEnvWqDerivedFields(List<EnvWqVo> list, boolean calculated) {
+        for (EnvWqVo item : list) {
+            item.setCalculateFlag(calculated ? CommonConstant.CALCULATE_SUCCESS : "0");
+            item.setWqGrdName(getWqLevelName(item.getWqGrd()));
+            item.setBeforeWqGrdName(getWqLevelName(item.getBeforeWqGrd()));
+            item.setWwqtgName(getWqLevelName(item.getWwqtg()));
+            item.setSttypeName(getSttypeName(item.getSttype()));
+            item.setSfdbName(getSfdbName(item.getSfdb()));
+        }
+    }
+
+    private String getWqLevelName(String level) {
+        if (StrUtil.isBlank(level)) {
+            return null;
+        }
+        return switch (level) {
+            case "1" -> "I类";
+            case "2" -> "II类";
+            case "3" -> "III类";
+            case "4" -> "IV类";
+            case "5" -> "V类";
+            case "6" -> "劣V类";
+            case "0" -> "无数据";
+            default -> null;
+        };
+    }
+
+    private String getSttypeName(String sttype) {
+        if (StrUtil.isBlank(sttype)) {
+            return null;
+        }
+        return switch (sttype) {
+            case "0" -> "自建站";
+            case "1" -> "国家站";
+            case "2" -> "人工站";
+            default -> null;
+        };
+    }
+
+    private String getSfdbName(Integer sfdb) {
+        if (sfdb == null) {
+            return null;
+        }
+        return switch (sfdb) {
+            case 0 -> "不达标";
+            case 1 -> "达标";
+            case 2 -> "无数据";
+            default -> null;
+        };
+    }
+
     private DataSourceResult emptyResult() {
         DataSourceResult result = new DataSourceResult();
         result.setData(new ArrayList<>());
@@ -195,9 +539,9 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
         return result;
     }
 
-    private String buildVmsstbprptOrderBySql(List<DataSourceRequest.SortDescriptor> sortList) {
+    private String buildEnvWqOrderBySql(List<DataSourceRequest.SortDescriptor> sortList) {
         if (sortList == null || sortList.isEmpty()) {
-            return " ORDER BY hb.ORDER_INDEX ASC, eng.HBRVCD ASC, eng.ORDER_INDEX ASC, wq.ORDER_INDEX ASC";
+            return "";
         }
         StringBuilder sql = new StringBuilder(" ORDER BY ");
         boolean appended = false;
@@ -206,13 +550,33 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
                 continue;
             }
             String column = switch (sortDescriptor.getField()) {
-                case "baseStepSort" -> "hb.ORDER_INDEX";
+                case "stcd" -> "T.STCD";
-                case "hbrvcd" -> "eng.HBRVCD";
+                case "stnm" -> "T.STNM";
-                case "rstcdStepSort" -> "eng.ORDER_INDEX";
+                case "rstcd" -> "T.RSTCD";
-                case "siteStepSort" -> "wq.ORDER_INDEX";
+                case "ennm" -> "T.ENNM";
-                case "stnm" -> "wq.STNM";
+                case "baseId" -> "T.BASE_ID";
-                case "ennm" -> "eng.ENNM";
+                case "baseName" -> "T.BASE_NAME";
-                case "stcd" -> "wq.STCD";
+                case "rvcdName" -> "T.RVCD_NAME";
+                case "addvcdName" -> "T.ADDVCD_NAME";
+                case "hbrvcd" -> "T.HBRVCD";
+                case "hbrvcdName" -> "T.HBRVCD_NAME";
+                case "wwqtg" -> "T.WWQTG";
+                case "id" -> "T.ID";
+                case "tm" -> "T.TM";
+                case "type" -> "T.TYPE";
+                case "sttype" -> "T.STTYPE";
+                case "sfdb" -> "T.SFDB";
+                case "rstcdStepSort" -> "T.RSTCDSTEPSORT";
+                case "baseStepSort" -> "T.BASESTEPSORT";
+                case "rvcdStepSort" -> "T.RVCDSTEPSORT";
+                case "siteStepSort" -> "T.SITESTEPSORT";
+                case "drMonth" -> "T.DR_MONTH";
+                case "drYear" -> "T.DR_YEAR";
+                case "wqSfdbHy" -> "T.WQ_SFDB_HY";
+                case "wqSfdbHn" -> "T.WQ_SFDB_HN";
+                case "wqSfdbCount" -> "T.WQ_SFDB_COUNT";
+                case "wqSfdbHo" -> "T.WQ_SFDB_HO";
+                case "wqRate" -> "T.WQ_RATE";
                 default -> null;
             };
             if (column == null) {
@@ -225,9 +589,6 @@ public class EnvWqDataServiceImpl implements EnvWqDataService {
                     .append("desc".equalsIgnoreCase(sortDescriptor.getDir()) ? "DESC" : "ASC");
             appended = true;
         }
-        if (!appended) {
+        return appended ? sql.toString() : "";
-            return " ORDER BY hb.ORDER_INDEX ASC, eng.HBRVCD ASC, eng.ORDER_INDEX ASC, wq.ORDER_INDEX ASC";
-        }
-        return sql.toString();
     }
 }