init_08

src/main/java/com/scbfkj/uni/api/LogAop.java

@@ -22,8 +22,6 @@ import java.util.*;
 @Aspect
 public class LogAop {
 
-    @Resource
-    private LoggerService loggerService;
 
     @Resource
     private SecurityService securityService;

src/main/java/com/scbfkj/uni/process/DataBase.java

@@ -2,10 +2,12 @@ package com.scbfkj.uni.process;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.scbfkj.uni.library.DataFormatUtil;
+import com.scbfkj.uni.library.UniReturnUtil;
 import com.scbfkj.uni.system.Config;
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.pool.HikariPool;
 import jakarta.annotation.Nonnull;
+import org.springframework.util.StringUtils;
 
 import java.sql.*;
 import java.time.LocalDateTime;
@@ -18,13 +20,14 @@ public class DataBase {
 
     private final static Map<String, Map<String, Object>> cacheDatas = new HashMap<>();
     private final static List<Map<String, Object>> cacheConfigList = new ArrayList<>();
+    private final static Map<String, HikariPool> dataSourcePools = new HashMap<>();
 
 
     public static List<Map<String, Object>> query(String connectionStr, String sql, List<Object[]> argsList) throws Exception {
 
 //        缓存数据 connectionStr + sql
 
-        String key = "%s;%s;%s".formatted(connectionStr, sql,DataFormatUtil.toString(argsList));
+        String key = "%s;%s;%s".formatted(connectionStr, sql, DataFormatUtil.toString(argsList));
         if (cacheDatas.containsKey(key)) {
             Map<String, Object> cacheData = cacheDatas.get(key);
 
@@ -53,7 +56,15 @@ public class DataBase {
         }).toList();
 
         if (cacheConfigList.isEmpty()) {
-            cacheConfigList.addAll(DataBase.query(Config.centerConnectionStr, "select * from datacache", Collections.emptyList()));
+            HikariPool sourcePool = getDataSourcePool(Config.centerConnectionStr);
+            try (Connection connection = sourcePool.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("select * from datacache")
+            ) {
+                ResultSet resultSet = preparedStatement.executeQuery();
+                cacheConfigList.addAll(getResult(connectionStr, sql, resultSet));
+            } catch (Exception exception) {
+                throw new RuntimeException("数据异常: %s\n sql: select * from datacache ;\n args: null ".formatted(exception.getMessage()));
+            }
         }
         cacheConfigList.stream().filter(it -> Objects.equals(it.get("querysql"), sql) && Objects.equals(it.get("connectset"), connectionStr)).findFirst().ifPresent(it -> {
             Object o = it.get("effectiveduration");
@@ -110,6 +121,227 @@ public class DataBase {
         }
     }
 
+    public static Map<String, Object> exec(String connectionStr, String expression, List<Map<String, Object>> args, Object executionNumber, List<String> filterColumns, Map<String, Object> filterLines) throws Exception {
+
+        if (Objects.isNull(executionNumber) || !StringUtils.hasText(executionNumber.toString())) {
+            throw new RuntimeException("执行编号不能为空");
+        }
+        expression = expression.replaceAll("\\s*(\\r)?\\n\\s*", " ").trim();
+        boolean isTableName = !expression.contains(" ");
+
+        if (Objects.isNull(filterColumns)) filterColumns = new ArrayList<>();
+        if (Objects.isNull(filterLines)) filterLines = new HashMap<>();
+
+//        只有表名
+        if (isTableName) {
+            List<String> valueNames = null;
+            List<String> filterNames = null;
+//            查询
+            if (Objects.equals("0", executionNumber)) {
+                Map<String, Object> map = args.get(0);
+                Map<String, Object> filter = ((Map<String, Object>) map.getOrDefault("filter", map));
+                filterNames = filter.keySet().stream().toList();
+                expression = "select * from %s where %s and  %s".formatted(
+                        expression,
+                        filterNames.stream().map("%s = ?"::formatted).collect(Collectors.joining(" and ")),
+                        Objects.isNull(filterLines) || filterLines.isEmpty() ? " 1=1 " : filterLines.entrySet().stream().map(entry -> "%s = '%s'".formatted(entry.getKey(), entry.getValue())).collect(Collectors.joining(" and ")));
+
+                if(Objects.nonNull(filterColumns) && !filterColumns.isEmpty()){
+                    expression= "select %s from (%s) as T".formatted(String.join(",", filterColumns),expression);
+                }
+
+                List<Object[]> values = new ArrayList<>();
+                for (Map<String, Object> arg : args) {
+                    List<Object> objects = new ArrayList<>();
+                    if (Objects.nonNull(valueNames)) {
+                        Map<String, Object> o1 = ((Map<String, Object>) arg.getOrDefault("value", arg));
+                        objects.addAll(valueNames.stream().map(o1::get).toList());
+                    }
+                    if (Objects.nonNull(filterNames)) {
+                        Map<String, Object> o1 = ((Map<String, Object>) arg.getOrDefault("filter", arg));
+                        objects.addAll(filterNames.stream().map(o1::get).toList());
+                    }
+                    values.add(objects.toArray());
+                }
+                List<Map<String, Object>> result = query(connectionStr, expression, values);
+                return UniReturnUtil.success(result);
+//                更新或新增
+            } else if (Objects.equals("6", executionNumber)) {
+                Map<String, Object> map = args.get(0);
+                Map<String, Object> filter = ((Map<String, Object>) map.get("filter"));
+                filterNames = filter.keySet().stream().toList();
+
+                List<Map<String, Object>> insertValues = new ArrayList<>();
+                List<Map<String, Object>> updateValues = new ArrayList<>();
+
+                String sql = "select count(1) as existscount from %s where %s".formatted(expression, filterNames.stream().map("%s = ?"::formatted).collect(Collectors.joining(" and ")));
+                for (Map<String, Object> arg : args) {
+
+                    Map<String, Object> where = ((Map<String, Object>) arg.get("filter"));
+                    Object[] objects = filterNames.stream().map(where::get).toArray();
+                    if (exists(connectionStr, sql, objects)) {
+                        updateValues.add(arg);
+                    } else {
+                        insertValues.add(arg);
+                    }
+                }
+                Map<String, Object> insertResult = exec(connectionStr, expression, insertValues, "1", filterColumns, filterLines);
+                Map<String, Object> updateResult = exec(connectionStr, expression, updateValues, "2", filterColumns, filterLines);
+
+                return UniReturnUtil.success(new HashMap<>() {{
+                    put("insert", insertResult);
+                    put("update", updateResult);
+                }});
+
+            } else {
+
+//                新增
+                if (Objects.equals("1", executionNumber)) {
+                    Map<String, Object> map = args.get(0);
+                    Map<String, Object> value = ((Map<String, Object>) map.getOrDefault("value", map));
+                    valueNames = value.keySet().stream().toList();
+                    expression = "insert into %s ( %s) values(%s)".formatted(expression, String.join(",", valueNames), valueNames.stream().map(it -> "?").collect(Collectors.joining(",")));
+//                    更新
+                } else if (Objects.equals("2", executionNumber)) {
+                    Map<String, Object> map = args.get(0);
+                    Map<String, Object> value = ((Map<String, Object>) map.get("value"));
+                    valueNames = value.keySet().stream().toList();
+                    Map<String, Object> filter = ((Map<String, Object>) map.get("filter"));
+                    filterNames = filter.keySet().stream().toList();
+                    expression = "update %s set %s where %s and %s".formatted(expression, valueNames.stream().map("%s = ?"::formatted).collect(Collectors.joining(",")),
+                            filterNames.stream().map("%s = ?"::formatted).collect(Collectors.joining(" and ")),
+                            Objects.isNull(filterLines) || filterLines.isEmpty() ? " 1=1 " : filterLines.entrySet().stream().map(entry -> "%s = '%s'".formatted(entry.getKey(), entry.getValue())).collect(Collectors.joining(" and ")));
+//                    删除
+                } else if (Objects.equals("3", executionNumber)) {
+                    Map<String, Object> map = args.get(0);
+                    Map<String, Object> filter = ((Map<String, Object>) map.getOrDefault("filter", map));
+                    filterNames = filter.keySet().stream().toList();
+                    expression = "delete from %s where %s and  %s".formatted(expression,
+                            filterNames.stream().map("%s = ?"::formatted).collect(Collectors.joining(" and ")),
+                            Objects.isNull(filterLines) || filterLines.isEmpty() ? " 1=1 " : filterLines.entrySet().stream().map(entry -> "%s = '%s'".formatted(entry.getKey(), entry.getValue())).collect(Collectors.joining(" and ")));
+                }
+                List<Object[]> values = new ArrayList<>();
+//                按照名称 和过滤条件取值
+                final List<String> finalFilterColumns = filterColumns;
+                for (Map<String, Object> arg : args) {
+                    List<Object> objects = new ArrayList<>();
+                    if (Objects.nonNull(valueNames)) {
+                        Map<String, Object> o1 = ((Map<String, Object>) arg.getOrDefault("value", arg));
+                        objects.addAll(valueNames.stream().map(it -> {
+
+//                            新增 更新 对列过滤
+                            if (finalFilterColumns.contains(it)) {
+                                return o1.get(it);
+                            } else {
+                                return null;
+                            }
+                        }).toList());
+                    }
+                    if (Objects.nonNull(filterNames)) {
+                        Map<String, Object> o1 = ((Map<String, Object>) arg.getOrDefault("filter", arg));
+                        objects.addAll(filterNames.stream().map(o1::get).toList());
+                    }
+                    values.add(objects.toArray());
+                }
+                int[] ints = updateBatch(connectionStr, expression, values);
+                return UniReturnUtil.success(ints);
+            }
+
+//         目前只支持查询
+        } else if (expression.contains("《whereStr》")) {
+
+            String whereStr = " ";//初始化条件字符串
+            List<Object> dbFilter = new ArrayList<>();//初始化条件执行参数
+            Map<String, Object> map = args.get(0);
+            Object filter = map.get("filter");
+            if (filter instanceof List filterList && !filterList.isEmpty()) {//如果存在上传的条件参数或者存在行权限
+                Map<String, Object> filterMap = (Map<String, Object>) filterList.get(0);
+                if (filterMap.containsKey("column")) {
+                    for (Object f : filterList) {
+                        Map<String, Object> it = ((Map<String, Object>) f);
+                        whereStr = " %s %s %s %s %s %s %s".formatted(
+                                whereStr,
+                                it.getOrDefault("left", ""),
+                                it.get("column"),
+                                it.get("comparator"),
+                                Objects.equals(it.get("comparator"), " is null ") ? "" : "?",
+                                it.getOrDefault("right", ""),
+                                it.getOrDefault("connector", " and ")
+                        );
+                        if (!Objects.equals(it.get("comparator"), " is null ")) {
+                            dbFilter.add(it.get("value"));
+                        }
+                    }
+                } else {
+                    List<Map.Entry<String, Object>> list = filterMap.entrySet().stream().toList();
+                    whereStr += list.stream().map("%s = ?"::formatted).collect(Collectors.joining(" and "));
+                    dbFilter.addAll(list.stream().map(Map.Entry::getValue).toList());
+                }
+            }else if(filter instanceof Map<?,?> filterMap && !filterMap.isEmpty()){
+                    List<? extends Map.Entry<?, ?>> list = filterMap.entrySet().stream().toList();
+                    whereStr += list.stream().map(it->"%s = ?".formatted(it.getKey())).collect(Collectors.joining(" and "));
+                    dbFilter.addAll(list.stream().map(Map.Entry::getValue).toList());
+            }
+            whereStr = " %s and  %s".formatted(whereStr, Objects.isNull(filterLines) || filterLines.isEmpty() ? " 1=1 " : filterLines.entrySet().stream().map(entry -> "%s = '%s'".formatted(entry.getKey(), entry.getValue())).collect(Collectors.joining(" and ")));
+            String sql = expression.replaceAll("《whereStr》", " " + whereStr);
+
+            if(Objects.nonNull(filterColumns) && !filterColumns.isEmpty()){
+                sql= "select %s from (%s) as T".formatted(String.join(",", filterColumns),sql);
+            }
+
+            List<Map<String, Object>> queryResult = query(connectionStr, sql, Collections.singletonList(dbFilter.toArray()));
+            return UniReturnUtil.success(queryResult);
+
+        } else {
+            if (Objects.equals(executionNumber, "0")) {
+                List<Map<String, Object>> queryResult = query(connectionStr, expression, args, filterColumns, filterLines);
+                return UniReturnUtil.success(queryResult);
+            } else if (Objects.equals(executionNumber, "1")) {
+                if (sqlStrVarList.containsKey(expression)) {
+                    getSQLVarList(expression);
+                }
+                List<String> names = sqlStrVarList.get(expression);
+                String sql = sqlStrNewSQL.get(expression);
+                int[] updateResult = updateBatch(connectionStr, sql, args.stream().map(it -> names.stream().map(it::get).toArray()).toList());
+                return UniReturnUtil.success(updateResult);
+            } else {
+                if (sqlStrVarList.containsKey(expression)) {
+                    getSQLVarList(expression);
+                }
+                List<String> names = sqlStrVarList.get(expression);
+                String sql = " %s %s".formatted(sqlStrNewSQL.get(expression), Objects.isNull(filterLines) || filterLines.isEmpty() ? "" : " and " + filterLines.entrySet().stream().map(entry -> "%s = '%s'".formatted(entry.getKey(), entry.getValue())).collect(Collectors.joining(" and ")));
+                int[] updateResult = updateBatch(connectionStr, sql, args.stream().map(it -> names.stream().map(it::get).toArray()).toList());
+                return UniReturnUtil.success(updateResult);
+            }
+        }
+    }
+
+    private static Pattern regExpression = Pattern.compile("(?<=《)([^》]+)?(?=》)");//提取书名号变量的正则表达式
+    public static Map<String, List<String>> sqlStrVarList = new HashMap<>();//SQL语句的书名号变量列表
+    public static Map<String, String> sqlStrNewSQL = new HashMap<>();//SQL语句更换书名号变量后的可执行SQL
+
+    private static List<String> getSQLVarList(String sqlStr) {
+        String newSqlStr = sqlStr;//不破坏之前SQL语句
+        List<String> sqlvarList = sqlStrVarList.containsKey(sqlStr) ? sqlStrVarList.get(sqlStr) : new ArrayList<>();//优先从缓存中取
+        if (!sqlStrNewSQL.containsKey(sqlStr)) {//缓存不存在则重新获取
+            Matcher matcher = regExpression.matcher(sqlStr);//正则提取
+            while (matcher.find()) {//循环提取到的所有书名号变量
+                String varName = matcher.group();
+                sqlvarList.add(varName.trim());
+                newSqlStr = newSqlStr.replaceFirst("《".concat(varName).concat("》"), " ? "); //修订SQL
+            }
+            sqlStrVarList.put(sqlStr, sqlvarList);//添加到缓存
+            sqlStrNewSQL.put(sqlStr, newSqlStr);//添加到缓存
+        }
+        return sqlvarList;
+    }
+
+    private static boolean exists(String connectionStr, String sql, Object[] args) throws Exception {
+        List<Map<String, Object>> mapList = query(connectionStr, sql, Collections.singletonList(args));
+        if (mapList.isEmpty()) return false;
+        return !Objects.equals(mapList.get(0).get("existscount").toString(), "0");
+    }
+
     public static List<Map<String, Object>> query(String connectionStr, String sql, List<Map<String, Object>> argsList, List<String> filterColumns, Map<String, Object> filterLines) throws Exception {
 
         sql = sql.replaceAll("(\\r)?\\n", " ");
@@ -125,7 +357,7 @@ public class DataBase {
 
         List<List<Object>> result = new ArrayList<>();
         List<String> names = new ArrayList<>();
-        if (sql.matches("《.*》")) {
+        if (sql.matches("《.+?》")) {
             Pattern compile = Pattern.compile("(?=《).*(?=》)");
             Matcher matcher = compile.matcher(sql);
             int index = 0;
@@ -168,9 +400,6 @@ public class DataBase {
     }
 
 
-    private final static Map<String, HikariPool> dataSourcePools = new HashMap<>();
-
-
     private static HikariPool getDataSourcePool(String connectionStr) throws Exception {
         if (dataSourcePools.containsKey(connectionStr)) {
             return dataSourcePools.get(connectionStr);
@@ -251,4 +480,5 @@ public class DataBase {
         return result;
     }
 
+
 }

src/main/java/com/scbfkj/uni/service/DataProcessService.java

@@ -38,6 +38,14 @@ public class DataProcessService {
         return UniReturnUtil.success(null);
     }
 
+    /**
+     * @param algorithmLibrary 算法配置
+     * @param args 算法参数
+     * @param filterColumns 数据库执行的列权限
+     * @param filterLines 数据库执行的行权限
+     * @return
+     * @throws Exception
+     */
     public static Map<String, Object> processByAlgorithm(Map<String, Object> algorithmLibrary, List<Map<String, Object>> args, List<String> filterColumns, Map<String, Object> filterLines) throws Exception {
 
         Object type = algorithmLibrary.get("algorithmtype");
@@ -48,7 +56,6 @@ public class DataProcessService {
         Object dataSourceId = algorithmLibrary.get("datasourceid");
         List<Map<String, Object>> datasourceList = DataBase.query(Config.centerConnectionStr, "select * from datasource where datasourceid=?", Collections.singletonList(new Object[]{dataSourceId}));
         Map<String, Object> datasource = datasourceList.get(0);
-
         if (Objects.nonNull(preConditions)) {
             String result = preConditionScript(preConditions.toString(), args);
             if (Objects.equals("1", result) || Objects.equals("2", result)) {
@@ -131,12 +138,22 @@ public class DataProcessService {
         return UniReturnUtil.fail("");
     }
 
+    /**
+     * @param script  前置表达式 不能为空
+     * @param args 表达式参数
+     * @return
+     * @throws Exception
+     */
     private static String preConditionScript(String script, List<Map<String, Object>> args) throws Exception {
         return ScriptEngineUtil.eval(script, args);
     }
 
-    //    参数使用标准的jsonPath表达式 $.a.b[0].c,多个参数之间使用;;分隔
-    private static List<Object> getParams(String parameterSet, Object source) {
+    /**
+     * @param parameterSet 使用标准的jsonPath表达式 $.a.b[0].c,多个参数之间使用;;分隔
+     * @param source jsonpath需要取值的数据源
+     * @return
+     */
+    public static List<Object> getParams(String parameterSet, Object source) {
         String[] paths = parameterSet.split(";;");
         return Arrays.stream(paths).map(it -> JsonPath.read(source, it.trim())).toList();
     }

src/main/java/com/scbfkj/uni/system/ScheduleTask.java

@@ -16,16 +16,6 @@ public class ScheduleTask implements Runnable {
     Integer loopCount = 0;
     int count = 0;
 
-    private DataProcessService service;
-
-
-    /**
-     * @param id 任务ID
-     */
-    public ScheduleTask(String id) {
-        this.id = id;
-    }
-
     public ScheduleTask(String id, Integer loopCount) {
         this.id = id;
         this.loopCount = loopCount;
@@ -35,9 +25,13 @@ public class ScheduleTask implements Runnable {
     public void run() {
 
         do {
-            count++;
+            if (loopCount > 0) {
+                count++;
+            }
             try {
-                service.process(new HashMap<>());
+                DataProcessService.process(new HashMap<>() {{
+                    put("serviceid", id);
+                }});
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }

src/main/java/com/scbfkj/uni/system/SystemInit.java

@@ -3,8 +3,12 @@ package com.scbfkj.uni.system;
 import com.scbfkj.uni.library.DataEncryptionUtil;
 import jakarta.annotation.PostConstruct;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
 import org.springframework.stereotype.Component;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.List;
 
 
@@ -46,6 +50,15 @@ public class SystemInit {
 
     private void initializeTheSystemEnvironment() {
 //        运行环境初始化
+        File resource = new File("logs");
+        boolean exists = resource.exists();
+        if (!exists){
+            if(!resource.mkdirs()){
+                throw new RuntimeException("创建日志目录失败");
+            }else {
+                System.out.println("创建目录成功:"+resource.getAbsolutePath());
+            }
+        }
     }
 
 }

src/main/resources/application.properties

@@ -2,4 +2,5 @@ db.center.config=hLcDKcDr4MgqYdb8j0gF0nF806yUy1UdEp1nmztEdo5rNL8IZliDj7/feOp2Fc7
 db.security.config=Jnj84d14EmSgKEXyAbSH+bratWGkpV89/VA5Er4yQOt7qlnKtGYJzBVJNNYMBdmSlW0G+nqDHMhJQcmHrwbjjChYuGeDcmKSRmvFQ9u7LwqmgEfazzKKoVawXmJ40dMsec2yaFyNnCM92xn1hzHvle5BL7x3kza2htGm+iOqO7Y=
 log.target=B7xSbq4imA5zapX8kEO42mU/5sA2TyF/Ba2Y/++F3z9Np7iT4ywDUkbRC4w/Xrxv1kMSR8PQMJ4dfYwc3mYj0SJJivN5A5/6hI+ZSQBabfZZrYwaIIRdM1XIk4wo1SIrSCXKzef8X6YUH70R2tnh+Uq6KNNp08KaZ2ZXM8vX5Ss=
 server.port=8085
+app.container.code=001
 #app.debug=true

src/test/java/com/scbfkj/uni/library/DataFormatUtilTest.java

@@ -0,0 +1,22 @@
+package com.scbfkj.uni.library;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.jayway.jsonpath.JsonPath;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DataFormatUtilTest {
+
+    @Test
+    void toJsonNode() throws JsonProcessingException {
+        String json = "[{\"name\": \"Alice\", \"age\": 25}, {\"name\": \"Bob\", \"age\": 30}]";
+        ObjectMapper mapper = new ObjectMapper();
+        JsonNode rootNode = mapper.readTree(json);
+        Object read = JsonPath.read(json, "$[0]");
+        System.out.println(read);
+
+    }
+}

src/test/java/com/scbfkj/uni/process/DataBaseTest.java

@@ -3,13 +3,94 @@ package com.scbfkj.uni.process;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.scbfkj.uni.library.DataFormatUtil;
 import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 import static org.junit.jupiter.api.Assertions.*;
 
+@SpringBootTest
 class DataBaseTest {
+    static String connectionStr = """
+                            {
+              "jdbcUrl": "jdbc:mysql://120.26.64.82:3306/mid_log",
+              "username": "root",
+              "password": "123@bigdata",
+              "driverClassName": "com.mysql.cj.jdbc.Driver"
+            }""";
+    public static String tableName = "log_error";
 
+  static    List<Map<String, Object>> insert = Collections.singletonList(new HashMap<>() {{
+        put("filter", new HashMap<>() {{
+            put("id", 15);
+        }});
+        put("value", new HashMap<>() {{
+            put("id", 15);
+        }});
+    }});
+
+    static List<Map<String, Object>> update = Collections.singletonList(new HashMap<>() {{
+        put("filter", new HashMap<>() {{
+            put("id", 15);
+        }});
+        put("value", new HashMap<>() {{
+            put("serviceid", 999);
+            put("id", 15);
+        }});
+    }});
+
+  static   List<Map<String, Object>> insertOrupdate = new ArrayList<>() {{
+        add(new HashMap<>() {{
+            put("filter", new HashMap<>() {{
+                put("id", 15);
+            }});
+            put("value", new HashMap<>() {{
+                put("serviceid", 1000);
+                put("id", 15);
+            }});
+        }});
+        add(new HashMap<>() {{
+            put("filter", new HashMap<>() {{
+                put("id", 16);
+            }});
+            put("value", new HashMap<>() {{
+                put("serviceid", 1000);
+                put("id", 16);
+            }});
+        }});
+    }};
+   static List<String> filterColumns = new ArrayList<>() {{
+        add("id");
+        add("serviceid");
+    }};
+   static HashMap<String, Object> filterLines = new HashMap<>() {{
+        put("id", 15);
+    }};
+
+    @Test
+    void exec() throws Exception {
+
+
+
+        Map<String, Object> exec = DataBase.exec(connectionStr, tableName, insert, "3", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, insert, "1", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, insert, "0", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, update, "2", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, update, "0", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, insertOrupdate, "6", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+        exec = DataBase.exec(connectionStr, tableName, insertOrupdate, "0", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+    }
+
+    @Test
+    public void test() throws Exception {
+        Map<String, Object> exec = DataBase.exec(connectionStr, "select * from %s where 《whereStr》".formatted(tableName), insert, "0", filterColumns, filterLines);
+        System.out.println(DataFormatUtil.toString(exec));
+    }
 }