/**
 * 精确匹配查询，需要实现PreciseShardingAlgorithm，可以实现对 `=`以及`in`的查询
 */
public class MyPreciseShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    /**
     * 精确匹配查询
     *
     * @param tbNames       数据库中所有的事实表
     * @param shardingValue 分片相关信息
     * @return 返回匹配的数据源
     */
    @Override
    public String doSharding(Collection<String> tbNames, PreciseShardingValue<Long> shardingValue) {
        for (String tableName : tbNames) {
            /*
             * shardingValue.getValue() 为分片建的值，比如 id=2时，value就是 2
             * 比如：表分为user_1到user_6，id=1操作user_1表，id=6操作user_6表
             *
             * `+ 6`的目的是为了保证，id=6操作user_6表，运维6%6=0，需要再进行`+6`
             */
            long index = shardingValue.getValue() % tbNames.size();
            //String value = String.valueOf(index == 0 ? index + 6 : index);
            // 匹配满足当前分片规则的表名称
            if (tableName.endsWith(String.valueOf(index))) {
                return tableName;
            }
        }
        throw new RuntimeException("数据库不存在");
    }
}

public class MyRangeShardingAlgorithm implements RangeShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(Collection<String> tbNames, RangeShardingValue<Long> rangeShardingValue) {
        // 获取逻辑表名称
        String logicTableName = rangeShardingValue.getLogicTableName();

        // between and 的起始值，需要处理只有最大值或者只有最小值的情况
        boolean hasLowerBound = rangeShardingValue.getValueRange().hasLowerBound();
        boolean hasUpperBound = rangeShardingValue.getValueRange().hasUpperBound();

        // 只有最小值，比如：id > x
        if (hasLowerBound && !hasUpperBound) {
            // 直接返回所有表名称
            return tbNames;
        }

        // 只有最大值，比如：id < x
        if (!hasLowerBound && hasUpperBound) {
            long upper = rangeShardingValue.getValueRange().upperEndpoint();
            if (upper < tbNames.size()) {
                // 如果最大值小于表的总数，则返回需要的表名
                return matchMinAndMax(1, upper, logicTableName, tbNames);
            } else {
                // 如果最大值大于表的总数，则返回所有
                return tbNames;
            }
        }

        long lower = Long.valueOf(rangeShardingValue.getValueRange().lowerEndpoint());
        long upper = Long.valueOf(rangeShardingValue.getValueRange().upperEndpoint());

        // 拼接事实表名称
        return matchMinAndMax(lower, upper, logicTableName, tbNames);
    }

    private List<String> matchMinAndMax(long lower, long upper, String logicTableName, Collection<String> tbNames) {
        List<String> tableNameList = new ArrayList<>();
        for (long index = lower; index <= upper; index++) {
            long tableNum = index % tbNames.size();
            // 事实表后缀
            //String suffix = String.valueOf(tableNum == 0 ? tableNum + 6 : tableNum);
            String tableName = logicTableName + tableNum;
            if (tbNames.contains(tableName)) {
                // 添加满足要求的表名称
                tableNameList.add(tableName);
            }

            // 如果满足要求的表已经覆盖了所有表，此处处理是为了方式查询区间过大，而分表不多，导致的过度遍历
            if (tableNameList.size() == tbNames.size()) {
                return tableNameList;
            }
        }
        return tableNameList;
    }
}