fix Db 类 批量插入数据发生属性名乱序问题,导致数据无法正常插入

增加测试方法

hutool-db/src/main/java/org/dromara/hutool/db/dialect/impl/AnsiSqlDialect.java

@@ -30,7 +30,10 @@ import org.dromara.hutool.db.sql.QuoteWrapper;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * ANSI SQL 方言
@@ -67,7 +70,8 @@ public class AnsiSqlDialect implements Dialect {
 		}
 		// 批量，根据第一行数据结构生成SQL占位符
 		final SqlBuilder insert = SqlBuilder.of(quoteWrapper).insert(entities[0], this.dialectName());
-		final Set<String> fields = CollUtil.filter(entities[0].keySet(), StrUtil::isNotBlank);
+		final List<String> fields =
+				 entities[0].keySet().stream().filter(StrUtil::isNotBlank).collect(Collectors.toList());
 		return StatementUtil.prepareStatementForBatch(conn, insert.build(), fields, entities);
 	}
 

hutool-db/src/test/java/org/dromara/hutool/db/DbTest.java

@@ -1,5 +1,6 @@
 package org.dromara.hutool.db;
 
+import org.dromara.hutool.core.util.RandomUtil;
 import org.dromara.hutool.db.handler.EntityListHandler;
 import org.dromara.hutool.db.sql.Condition;
 import org.dromara.hutool.log.LogUtil;
@@ -10,148 +11,190 @@ import org.junit.jupiter.api.Test;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
  * Db对象单元测试
- * @author looly
  *
+ * @author looly
  */
 public class DbTest {
 
-	@Test
+    @Test
-	public void queryTest() {
+    public void queryTest() {
-		final List<Entity> find = Db.of().query("select * from user where age = ?", 18);
+        final List<Entity> find = Db.of().query("select * from user where age = ?", 18);
-		Assertions.assertEquals("王五", find.get(0).get("name"));
+        Assertions.assertEquals("王五", find.get(0).get("name"));
-	}
+    }
 
-	@Test
+    @Test
-	public void findTest() {
+    public void findTest() {
-		final List<Entity> find = Db.of().find(Entity.of("user").set("age", 18));
+        final List<Entity> find = Db.of().find(Entity.of("user").set("age", 18));
-		Assertions.assertEquals("王五", find.get(0).get("name"));
+        Assertions.assertEquals("王五", find.get(0).get("name"));
-	}
+    }
 
-	@Test
+    @Test
-	public void pageTest() {
+    public void pageTest() {
-		// 测试数据库中一共4条数据，第0页有3条，第1页有1条
+        // 测试数据库中一共4条数据，第0页有3条，第1页有1条
-		final List<Entity> page0 = Db.of().page(Entity.of("user"),
+        final List<Entity> page0 = Db.of().page(Entity.of("user"),
-				Page.of(0, 3));
+                Page.of(0, 3));
-		Assertions.assertEquals(3, page0.size());
+        Assertions.assertEquals(3, page0.size());
 
-		final List<Entity> page1 = Db.of().page(Entity.of("user"), Page.of(1, 3));
+        final List<Entity> page1 = Db.of().page(Entity.of("user"), Page.of(1, 3));
-		Assertions.assertEquals(1, page1.size());
+        Assertions.assertEquals(1, page1.size());
-	}
+    }
 
-	@Test
+    @Test
-	public void pageBySqlTest() {
+    public void pageBySqlTest() {
-		final String sql = "select * from user order by name";
+        final String sql = "select * from user order by name";
-		// 测试数据库中一共4条数据，第0页有3条，第1页有1条
+        // 测试数据库中一共4条数据，第0页有3条，第1页有1条
-		final List<Entity> page0 = Db.of().page(
+        final List<Entity> page0 = Db.of().page(
-				sql, Page.of(0, 3));
+                sql, Page.of(0, 3));
-		Assertions.assertEquals(3, page0.size());
+        Assertions.assertEquals(3, page0.size());
 
-		final List<Entity> page1 = Db.of().page(
+        final List<Entity> page1 = Db.of().page(
-				sql, Page.of(1, 3));
+                sql, Page.of(1, 3));
-		Assertions.assertEquals(1, page1.size());
+        Assertions.assertEquals(1, page1.size());
-	}
+    }
 
-	@Test
+    @Test
-	public void pageBySqlWithInTest() {
+    public void pageBySqlWithInTest() {
-		// in和其他条件混用
+        // in和其他条件混用
-		final String sql = "select * from user where age > :age and name in (:names) order by name";
+        final String sql = "select * from user where age > :age and name in (:names) order by name";
-		// 测试数据库中一共4条数据，第0页有3条，第1页有1条
+        // 测试数据库中一共4条数据，第0页有3条，第1页有1条
-		final List<Entity> page0 = Db.of().page(
+        final List<Entity> page0 = Db.of().page(
-				sql, Page.of(0, 3),
+                sql, Page.of(0, 3),
-				Entity.of().set("age", 12)
+                Entity.of().set("age", 12)
-						.set("names", new String[]{"张三", "王五"})
+                        .set("names", new String[]{"张三", "王五"})
-		);
+        );
-		Assertions.assertEquals(1, page0.size());
+        Assertions.assertEquals(1, page0.size());
-	}
+    }
 
-	@Test
+    @Test
-	public void pageWithParamsTest() {
+    public void pageWithParamsTest() {
-		final String sql = "select * from user where name = ?";
+        final String sql = "select * from user where name = ?";
-		final PageResult<Entity> result = Db.of().page(
+        final PageResult<Entity> result = Db.of().page(
-				sql, Page.of(0, 3), "张三");
+                sql, Page.of(0, 3), "张三");
 
-		Assertions.assertEquals(2, result.getTotal());
+        Assertions.assertEquals(2, result.getTotal());
-		Assertions.assertEquals(1, result.getTotalPage());
+        Assertions.assertEquals(1, result.getTotalPage());
-		Assertions.assertEquals(2, result.size());
+        Assertions.assertEquals(2, result.size());
-	}
+    }
 
-	@Test
+    @Test
-	public void countTest() {
+    public void countTest() {
-		final long count = Db.of().count("select * from user");
+        final long count = Db.of().count("select * from user");
-		Assertions.assertEquals(4, count);
+        Assertions.assertEquals(4, count);
-	}
+    }
 
-	@Test
+    @Test
-	public void countByQueryTest() {
+    public void countByQueryTest() {
-		final long count = Db.of().count(Entity.of("user"));
+        final long count = Db.of().count(Entity.of("user"));
-		Assertions.assertEquals(4, count);
+        Assertions.assertEquals(4, count);
-	}
+    }
 
-	@Test
+    @Test
-	public void countTest2() {
+    public void countTest2() {
-		final long count = Db.of().count("select * from user order by name DESC");
+        final long count = Db.of().count("select * from user order by name DESC");
-		Assertions.assertEquals(4, count);
+        Assertions.assertEquals(4, count);
-	}
+    }
 
-	@Test
+    @Test
-	public void findLikeTest() {
+    public void findLikeTest() {
-		// 方式1
+        // 方式1
-		List<Entity> find = Db.of().find(Entity.of("user").set("name", "like 王%"));
+        List<Entity> find = Db.of().find(Entity.of("user").set("name", "like 王%"));
-		Assertions.assertEquals("王五", find.get(0).get("name"));
+        Assertions.assertEquals("王五", find.get(0).get("name"));
 
-		// 方式2
+        // 方式2
-		find = Db.of().findLike("user", "name", "王", Condition.LikeType.StartWith);
+        find = Db.of().findLike("user", "name", "王", Condition.LikeType.StartWith);
-		Assertions.assertEquals("王五", find.get(0).get("name"));
+        Assertions.assertEquals("王五", find.get(0).get("name"));
 
-		// 方式3
+        // 方式3
-		find = Db.of().query("select * from user where name like ?", "王%");
+        find = Db.of().query("select * from user where name like ?", "王%");
-		Assertions.assertEquals("王五", find.get(0).get("name"));
+        Assertions.assertEquals("王五", find.get(0).get("name"));
-	}
+    }
 
-	@Test
+    @Test
-	public void findByTest() {
+    public void findByTest() {
-		final List<Entity> find = Db.of().findBy("user",
+        final List<Entity> find = Db.of().findBy("user",
-				Condition.parse("age", "> 18"),
+                Condition.parse("age", "> 18"),
-				Condition.parse("age", "< 100")
+                Condition.parse("age", "< 100")
-		);
+        );
-		for (final Entity entity : find) {
+        for (final Entity entity : find) {
-			LogUtil.debug("{}", entity);
+            LogUtil.debug("{}", entity);
-		}
+        }
-		Assertions.assertEquals("unitTestUser", find.get(0).get("name"));
+        Assertions.assertEquals("unitTestUser", find.get(0).get("name"));
-	}
+    }
 
-	@Test
+    @Test
-	@Disabled
+    @Disabled
-	public void txTest() throws SQLException {
+    public void txTest() throws SQLException {
-		Db.of().tx(db -> {
+        Db.of().tx(db -> {
-			db.insert(Entity.of("user").set("name", "unitTestuser2"));
+            db.insert(Entity.of("user").set("name", "unitTestuser2"));
-			db.update(Entity.of().set("age", 79), Entity.of("user").set("name", "unitTestuser2"));
+            db.update(Entity.of().set("age", 79), Entity.of("user").set("name", "unitTestuser2"));
-			db.del("user", "name", "unitTestuser2");
+            db.del("user", "name", "unitTestuser2");
-		});
+        });
-	}
+    }
 
-	@Test
+    @Test
-	@Disabled
+    public void batchInsert() throws SQLException {
-	public void queryFetchTest() {
+        List<Entity> es = new ArrayList<>();
-		// https://gitee.com/dromara/hutool/issues/I4JXWN
+        String tableName = "act_ge_property";
-		Db.of().query((conn->{
+        Entity e = buildEntity(tableName);
-			final PreparedStatement ps = conn.prepareStatement("select * from table",
+        es.add(e);
-					ResultSet.TYPE_FORWARD_ONLY,
+        Db.of().tx(db -> {
-					ResultSet.CONCUR_READ_ONLY);
+            db.insert(es);
-			ps.setFetchSize(Integer.MIN_VALUE);
+            List<Entity> ens = Db.of().find(e);
-			ps.setFetchDirection(ResultSet.FETCH_FORWARD);
+            Assertions.assertEquals(1, ens.size());
-			return ps;
+            db.del(tableName, "NAME_", "!= null");
-		}), new EntityListHandler());
+        });
-	}
+    }
 
-	@Test
+    @Test
-	@Disabled
+    public void batchInsertBatch() throws SQLException {
-	public void findWithDotTest() {
+        List<Entity> es = new ArrayList<>();
-		// 当字段带有点时，导致被拆分分别wrap了，因此此时关闭自动包装即可
+        String tableName = "act_ge_property";
-		Db.of().disableWrapper().find(Entity.of("user").set("a.b", "1"));
+        Entity e = buildEntity(tableName);
-	}
+        es.add(e);
+        es.add(buildEntity(tableName));
+        es.add(buildEntity(tableName));
+        es.add(buildEntity(tableName));
+        Db.of().tx(db -> {
+            db.insert(es);
+            List<Entity> ens = Db.of().find(e);
+            Assertions.assertEquals(1, ens.size());
+            db.del(tableName, "NAME_", "!= null");
+        });
+
+
+    }
+
+    private Entity buildEntity(String tableName) {
+        Entity entity = Entity.of("act_ge_property");
+        entity.put("NAME_", RandomUtil.randomString(15));
+        entity.put("VALUE_", RandomUtil.randomString(50));
+        entity.put("REV_", RandomUtil.randomInt());
+        return entity;
+    }
+
+    @Test
+    @Disabled
+    public void queryFetchTest() {
+        // https://gitee.com/dromara/hutool/issues/I4JXWN
+        Db.of().query((conn -> {
+            final PreparedStatement ps = conn.prepareStatement("select * from table",
+                    ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_READ_ONLY);
+            ps.setFetchSize(Integer.MIN_VALUE);
+            ps.setFetchDirection(ResultSet.FETCH_FORWARD);
+            return ps;
+        }), new EntityListHandler());
+    }
+
+    @Test
+    @Disabled
+    public void findWithDotTest() {
+        // 当字段带有点时，导致被拆分分别wrap了，因此此时关闭自动包装即可
+        Db.of().disableWrapper().find(Entity.of("user").set("a.b", "1"));
+    }
 }