Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/MybatisParameterUtil.java

@@ -1,21 +1,134 @@
package com.vci.ubcs.starter.util;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import org.springblade.core.mp.support.SqlKeyword;
import org.springblade.core.tool.utils.BeanUtil;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * in 参数截取，返回wrapper
 * in 参数截取，返回wrapper/或者where条件字符串
 *
 * @author ludc
 * @date 2023/5/5
 */
public class MybatisParameterUtil {

   /**
    * Oracle IN 查询的最大参数限制
     */
   private static final int MAX_IN_CLAUSE_SIZE = 1000;

   /**
    * 将给定的 ID 列表转换为适合 Oracle 的查询条件
    *
    * @param ids ID 列表
    * @return 适合 Oracle 的查询条件
    */
   public static String convertToOrConditions(String filed,List<String> ids) {
      if (ids == null || ids.isEmpty()) {
         return "";
      }

      StringBuilder queryBuilder = new StringBuilder();
      int size = ids.size();

      // 分批处理，避免超过 Oracle IN 查询的最大限制
      for (int i = 0; i < size; i += MAX_IN_CLAUSE_SIZE) {
         int end = Math.min(i + MAX_IN_CLAUSE_SIZE, size);
         List<String> subList = ids.subList(i, end);
         if (queryBuilder.length() > 0) {
            queryBuilder.append(" OR ");
         }
         queryBuilder.append("(")
            .append(getInClause(filed,subList)).append(")");
      }

      return queryBuilder.toString();
   }

   /*
    * 获取 IN 查询条件字符串
    * @param ids ID 列表
    * @return IN 查询条件字符串
    */
   private static String getInClause(String filed,List<String> ids) {
      StringBuilder inClauseBuilder = new StringBuilder();
      inClauseBuilder.append(filed + " IN (");

      for (int i = 0; i < ids.size(); i++) {
         inClauseBuilder.append("'").append(ids.get(i)).append("'");
         if (i < ids.size() - 1) {
            inClauseBuilder.append(", ");
         }
      }
      inClauseBuilder.append(")");

      return inClauseBuilder.toString();
   }

   /**
    * 获取 IN 查询条件字符串（不包含in）
    *
    * @param ids ID 列表
    * @return IN 查询条件字符串
    */
   public static String getInClause(List<String> ids) {
      StringBuilder inClauseBuilder = new StringBuilder();
      for (int i = 0; i < ids.size(); i++) {
         inClauseBuilder.append("'").append(ids.get(i)).append("'");
         if (i < ids.size() - 1) {
            inClauseBuilder.append(", ");
         }
      }
      return inClauseBuilder.toString();
   }

   /**
    * in作为查询条件时，防止大于1000出现报错，对条件进行截取，连表查询的wrapper
    * @param wrapper MPJLambdaWrapper,不进行连表查询时使用
    * @param column 作为in的条件列
    * @param coll 查询参数
    * @param <T> LambdaQueryWrapper的泛型
    * @param <F> 查询参数类型
    * @return
    * @throws VciBaseException
    */
   public static <T, F> MPJLambdaWrapper<T> cutInParameter(MPJLambdaWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
      List<List<F>> newList = splitList(coll, 900);
      if (ObjectUtils.isEmpty(newList)) {
         throw new VciBaseException("参数错误");
      } else if (newList.size() == 1) {
         wrapper.in(column, newList.get(0));
         return wrapper;
      }
      wrapper.and(i -> {
         i.in(column, newList.get(0));
         newList.remove(0);
         for (List<F> objects : newList) {
            i.or().in(column, objects);
         }
      });
      return wrapper;
   }

   /**
    * in作为查询条件时，防止大于1000出现报错，对条件进行截取，不具备连表查询的wrapper
    * @param wrapper LambdaQueryWrapper,不进行连表查询时使用
    * @param column 作为in的条件列
    * @param coll 查询参数
    * @param <T> LambdaQueryWrapper的泛型
    * @param <F> 查询参数类型
    * @return
    * @throws VciBaseException
    */
   public static <T, F> LambdaQueryWrapper<T> cutInParameter(LambdaQueryWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
      List<List<F>> newList = splitList(coll, 900);
      if (ObjectUtils.isEmpty(newList)) {
@@ -34,6 +147,44 @@
      return wrapper;
   }

   /**
    * notin作为查询条件时，防止大于1000出现报错，对条件进行截取，连表查询的wrapper
    * @param wrapper MPJLambdaWrapper,不进行连表查询时使用
    * @param column 作为in的条件列
    * @param coll 查询参数
    * @param <T> LambdaQueryWrapper的泛型
    * @param <F> 查询参数类型
    * @return
    * @throws VciBaseException
    */
   public static <T, F> MPJLambdaWrapper<T> cutNotInParameter(MPJLambdaWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
      List<List<F>> newList = splitList(coll, 900);
      if (ObjectUtils.isEmpty(newList)) {
         throw new VciBaseException("参数错误");
      } else if (newList.size() == 1) {
         wrapper.notIn(column, newList.get(0));
         return wrapper;
      }
      wrapper.and(i -> {
         i.in(column, newList.get(0));
         newList.remove(0);
         for (List<F> objects : newList) {
            i.or().notIn(column, objects);
         }
      });
      return wrapper;
   }

   /**
    * notin作为查询条件时，防止大于1000出现报错，对条件进行截取，不具备连表查询的wrapper
    * @param wrapper LambdaQueryWrapper,不进行连表查询时使用
    * @param column 作为in的条件列
    * @param coll 查询参数
    * @param <T> LambdaQueryWrapper的泛型
    * @param <F> 查询参数类型
    * @return
    * @throws VciBaseException
    */
   public static <T, F> LambdaQueryWrapper<T> cutNotInParameter(LambdaQueryWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
      List<List<F>> newList = splitList(coll, 900);
      if (ObjectUtils.isEmpty(newList)) {