├── .gitignore
├── README.md
├── pom.xml
└── src
    └── main
        ├── java
            └── ormkids
            │   ├── Column.java
            │   ├── Context.java
            │   ├── DB.java
            │   ├── E.java
            │   ├── GridDB.java
            │   ├── IEntity.java
            │   ├── IGridable.java
            │   ├── Index.java
            │   ├── KidsException.java
            │   ├── Meta.java
            │   ├── Option.java
            │   ├── Q.java
            │   ├── Utils.java
            │   └── demo
            │       ├── BookShelf.java
            │       ├── DemoComplexQuery.java
            │       ├── DemoCompoundPk.java
            │       ├── DemoDB.java
            │       ├── DemoEvent.java
            │       ├── DemoPartitioning.java
            │       ├── DemoSharding.java
            │       ├── DemoSimplePk.java
            │       ├── Exam.java
            │       ├── GridDemoDB.java
            │       ├── Member.java
            │       └── User.java
        └── resources
            └── log4j.properties


/.gitignore:
--------------------------------------------------------------------------------
1 | .settings
2 | .project
3 | .classpath
4 | *.class
5 | target
6 | deploy
7 | dependency-reduced-pom.xml
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | OrmKids
  2 | ==
  3 | 支持分库分表的MySQL单表ORM框架，暂用于学习，后续会在生产环境进行检验
  4 | 
  5 | ```
  6 | <dependency>
  7 |     <groupId>com.github.pyloque</groupId>
  8 |     <artifactId>ormkids</artifactId>
  9 |     <version>0.0.4</version>
 10 | </dependency>
 11 | ```
 12 | 
 13 | 功能特性
 14 | --
 15 | 1. 代码简洁，没有任何依赖项
 16 | 2. 易于使用，无须复杂的配置
 17 | 3. 提供自动创建表功能
 18 | 4. 支持分库又分表，可以只分库，也可以只分表
 19 | 5. 支持groupby/having/order by
 20 | 6. 支持原生SQL
 21 | 7. 支持事件回调，可用于服务跟踪调试和动态sql改写
 22 | 
 23 | 不支持多表关联
 24 | --
 25 | 1. 多表比较复杂，实现成本高，学习成本也高，容易出错
 26 | 2. 常用的多表的操作一般都可以使用多条单表操作组合实现
 27 | 3. 在分库分表的场合，很少使用多表操作
 28 | 4. 不使用外键，专注于sql逻辑
 29 | 
 30 | db.withinTx
 31 | --
 32 | 对于复杂的多表查询和批量数据处理，可以使用该方法。
 33 | 用户可以获得原生的jdbc链接，通过编写jdbc代码来实现。
 34 | 
 35 | Q
 36 | --
 37 | 用户可以使用Q对象构建复杂的SQL查询
 38 | 
 39 | 
 40 | 其它数据库支持
 41 | --
 42 | 暂时没有
 43 | 
 44 | 
 45 | 实体接口
 46 | --
 47 | 
 48 | ```java
 49 | /**
 50 |  * 所有的实体类必须实现该接口
 51 |  */
 52 | public interface IEntity {
 53 | 
 54 | 	/**
 55 | 	 * 表名
 56 | 	 * @return
 57 | 	 */
 58 | 	String table();
 59 | 
 60 | 	/**
 61 | 	 * 分表必须覆盖此方法
 62 | 	 * @return
 63 | 	 */
 64 | 	default String suffix() {
 65 | 		return null;
 66 | 	}
 67 | 
 68 | 	default String tableWithSuffix() {
 69 | 		return tableWith(suffix());
 70 | 	}
 71 | 
 72 | 	default String tableWith(String suffix) {
 73 | 		return Utils.tableWithSuffix(table(), suffix);
 74 | 	}
 75 | 	
 76 | 	/**
 77 | 	 * 定义表的物理结构属性如engine=innodb，用于动态创建表
 78 | 	 * @return
 79 | 	 */
 80 | 	TableOptions options();
 81 | 
 82 | 	/**
 83 | 	 * 定义表的主键和索引信息，用于动态创建表
 84 | 	 * @return
 85 | 	 */
 86 | 	TableIndices indices();
 87 | 
 88 | }
 89 | ```
 90 | 
 91 | 单表单主键
 92 | --
 93 | 
 94 | ```java
 95 | @Table
 96 | public class User implements IEntity {
 97 | 
 98 | 	@Column(name = "id", type = "int", autoincrement = true, nullable = false)
 99 | 	private Integer id;
100 | 	@Column(name = "name", type = "varchar(255)", nullable = false)
101 | 	private String name;
102 | 	@Column(name = "nick", type = "varchar(255)", nullable = false)
103 | 	private String nick;
104 | 	@Column(name = "passwd", type = "varchar(255)")
105 | 	private String passwd;
106 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
107 | 	private Date createdAt;
108 | 
109 | 	public User() {
110 | 	}
111 | 
112 | 	public User(String name, String nick, String passwd) {
113 | 		this.name = name;
114 | 		this.nick = nick;
115 | 		this.passwd = passwd;
116 | 	}
117 | 
118 | 	public Integer getId() {
119 | 		return id;
120 | 	}
121 | 
122 | 	public String getName() {
123 | 		return name;
124 | 	}
125 | 
126 | 	public String getNick() {
127 | 		return nick;
128 | 	}
129 | 
130 | 	public String getPasswd() {
131 | 		return passwd;
132 | 	}
133 | 
134 | 	public Date getCreatedAt() {
135 | 		return createdAt;
136 | 	}
137 | 
138 | 	@Override
139 | 	public TableOptions options() {
140 | 		return new TableOptions().option("engine", "innodb");
141 | 	}
142 | 
143 | 	@Override
144 | 	public TableIndices indices() {
145 | 		return new TableIndices().primary("id").unique("name");
146 | 	}
147 | 
148 | 	@Override
149 | 	public String table() {
150 | 		return "user";
151 | 	}
152 | 
153 | }
154 | 
155 | ```
156 | 
157 | 单表复合主键
158 | --
159 | 
160 | ```java
161 | @Table
162 | public class Member implements IEntity {
163 | 
164 | 	@Column(name = "user_id", type = "int", nullable = false)
165 | 	private Integer userId;
166 | 	@Column(name = "group_id", type = "int", nullable = false)
167 | 	private Integer groupId;
168 | 	@Column(name = "title", type = "varchar(255)")
169 | 	private String title;
170 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
171 | 	private Date createdAt;
172 | 
173 | 	public Member() {
174 | 	}
175 | 
176 | 	public Member(Integer userId, Integer groupId, String title, Date createdAt) {
177 | 		this.userId = userId;
178 | 		this.groupId = groupId;
179 | 		this.title = title;
180 | 		this.createdAt = createdAt;
181 | 	}
182 | 
183 | 	public Integer getUserId() {
184 | 		return userId;
185 | 	}
186 | 
187 | 	public Integer getGroupId() {
188 | 		return groupId;
189 | 	}
190 | 
191 | 	public String getTitle() {
192 | 		return title;
193 | 	}
194 | 
195 | 	public Date getCreatedAt() {
196 | 		return createdAt;
197 | 	}
198 | 
199 | 	@Override
200 | 	public TableOptions options() {
201 | 		return new TableOptions().option("engine", "innodb");
202 | 	}
203 | 
204 | 	@Override
205 | 	public TableIndices indices() {
206 | 		return new TableIndices().primary("user_id", "group_id");
207 | 	}
208 | 
209 | 	@Override
210 | 	public String table() {
211 | 		return "member";
212 | 	}
213 | 
214 | }
215 | ```
216 | 
217 | 分库接口
218 | --
219 | 
220 | ```java
221 | public interface IGridable<T extends IEntity> {
222 | 
223 | 	/**
224 | 	 * 根据实体对象选择分库索引
225 | 	 */
226 | 	int select(int dbs, T t);
227 | 
228 | 	/**
229 | 	 * 根据特定参数选择分库索引
230 | 	 */
231 | 	int select(int dbs, Object... params);
232 | 
233 | }
234 | ```
235 | 
236 | 分库分表
237 | --
238 | 
239 | ```java
240 | @Table
241 | public class BookShelf implements IEntity {
242 | 
243 | 	public final static int PARTITIONS = 4;
244 | 
245 | 	@Column(name = "user_id", type = "varchar(255)", nullable = false)
246 | 	private String userId;
247 | 	@Column(name = "book_id", type = "varchar(255)", nullable = false)
248 | 	private String bookId;
249 | 	@Column(name = "comment", type = "varchar(255)")
250 | 	private String comment;
251 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
252 | 	private Date createdAt;
253 | 
254 | 	public BookShelf() {
255 | 	}
256 | 
257 | 	public BookShelf(String userId, String bookId, String comment, Date createdAt) {
258 | 		this.userId = userId;
259 | 		this.bookId = bookId;
260 | 		this.comment = comment;
261 | 		this.createdAt = createdAt;
262 | 	}
263 | 
264 | 	public String getUserId() {
265 | 		return userId;
266 | 	}
267 | 
268 | 	public String getBookId() {
269 | 		return bookId;
270 | 	}
271 | 
272 | 	public void setComment(String comment) {
273 | 		this.comment = comment;
274 | 	}
275 | 
276 | 	public String getComment() {
277 | 		return comment;
278 | 	}
279 | 
280 | 	public Date getCreatedAt() {
281 | 		return createdAt;
282 | 	}
283 | 
284 | 	@Override
285 | 	public String table() {
286 | 		return "book_shelf";
287 | 	}
288 | 
289 | 	@Override
290 | 	public TableOptions options() {
291 | 		return new TableOptions().option("engine", "innodb");
292 | 	}
293 | 
294 | 	@Override
295 | 	public TableIndices indices() {
296 | 		return new TableIndices().primary("user_id", "book_id");
297 | 	}
298 | 
299 | 	/* 
300 | 	 * 分表策略
301 | 	 */
302 | 	@Override
303 | 	public String suffix() {
304 | 		var crc32 = new CRC32();
305 | 		crc32.update(userId.getBytes(Utils.UTF8));
306 | 		return String.valueOf(Math.abs(crc32.getValue()) % PARTITIONS);
307 | 	}
308 | 
309 | 	/**
310 | 	 * 分库策略
311 | 	 */
312 | 	public static class GridStrategy implements IGridable<BookShelf> {
313 | 
314 | 		@Override
315 | 		public int select(int dbs, BookShelf t) {
316 | 			return Math.abs(t.getUserId().hashCode()) % dbs;
317 | 		}
318 | 
319 | 		@Override
320 | 		public int select(int dbs, Object... params) {
321 | 			String userId = (String) params[0];
322 | 			return Math.abs(userId.hashCode()) % dbs;
323 | 		}
324 | 
325 | 	}
326 | 
327 | }
328 | ```
329 | 
330 | 定义单个数据库
331 | --
332 | 
333 | ```java
334 | public class DemoDB extends DB {
335 | 
336 | 	private DataSource ds;
337 | 
338 | 	public DemoDB(String name, String uri) {
339 | 		this(name, new HashMap<>(), uri);
340 | 	}
341 | 
342 | 	public DemoDB(String name, Map<Class<? extends IEntity>, Meta> metas, String uri) {
343 | 		super(name, metas);
344 | 		var ds = new MysqlConnectionPoolDataSource(); // 连接池
345 | 		ds.setUrl(uri);
346 | 		this.ds = ds;
347 | 	}
348 | 
349 | 	@Override
350 | 	protected Connection conn() {  // 获取链接
351 | 		try {
352 | 			return ds.getConnection();
353 | 		} catch (SQLException e) {
354 | 			throw new KidsException(e);
355 | 		}
356 | 	}
357 | 
358 | }
359 | ```
360 | 
361 | 定义网格数据库——分库
362 | --
363 | 
364 | ```java
365 | public class GridDemoDB extends GridDB<DemoDB> {
366 | 
367 | 	/**
368 | 	 * 传进来多个DB对象
369 | 	 */
370 | 	public GridDemoDB(DemoDB[] dbs) {
371 | 		super(dbs);
372 | 		this.registerGridables();
373 | 	}
374 | 
375 | 	/* 
376 | 	 * 注册实体类的分库策略
377 | 	 */
378 | 	@Override
379 | 	public void registerGridables() {
380 | 		this.gridWith(BookShelf.class, new BookShelf.GridStrategy<DemoDB>());
381 | 	}
382 | 
383 | }
384 | 
385 | ```
386 | 
387 | 单表单主键增删改查
388 | --
389 | 
390 | ```java
391 | public class DemoSimplePk {
392 | 
393 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
394 | 
395 | 	public static void main(String[] args) {
396 | 		var db = new DemoDB("demo", URI);
397 | 		try {
398 | 			db.create(User.class); // 创建表
399 | 			var user = new User("test1", "nick1", "passwd1");
400 | 			db.insert(user); // 插入
401 | 			System.out.println(user.getId());
402 | 			user = db.get(User.class, user.getId());  // 主键查询
403 | 			System.out.printf("%s %s %s %s %s\n", user.getId(), user.getName(), user.getNick(), user.getPasswd(),
404 | 					user.getCreatedAt());
405 | 			user = new User("test2", "nick2", "passwd2");
406 | 			db.insert(user); // 再插入
407 | 			var count = db.count(User.class); // 查询总行数
408 | 			System.out.println(count);
409 | 			var users = db.find(User.class);  // 列出所有行
410 | 			System.out.println(users.size());
411 | 			for (var u : users) {
412 | 				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
413 | 						u.getCreatedAt());
414 | 			}
415 | 			users = db.find(User.class, Q.eq_("nick"), "nick2"); // 条件查询
416 | 			System.out.println(users.size());
417 | 			var setters = new HashMap<String, Object>();
418 | 			setters.put("passwd", "whatever");
419 | 			db.update(User.class, setters, 2); // 修改
420 | 			users = db.find(User.class); // 再列出所有行
421 | 			System.out.println(users.size());
422 | 			for (var u : users) {
423 | 				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
424 | 						u.getCreatedAt());
425 | 			}
426 | 			db.delete(User.class, 1); // 删除
427 | 			db.delete(User.class, 2); // 再删除
428 | 			count = db.count(User.class); // 统计所有行
429 | 			System.out.println(count);
430 | 		} finally {
431 | 			db.drop(User.class); // 删除表
432 | 		}
433 | 	}
434 | 
435 | }
436 | ```
437 | 
438 | 单表复合主键增删改查
439 | --
440 | 
441 | ```java
442 | public class DemoCompoundPk {
443 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
444 | 
445 | 	public static void main(String[] args) {
446 | 		var db = new DemoDB("demo", URI);
447 | 		try {
448 | 			db.create(Member.class);  // 建表
449 | 			var member = new Member(1, 2, "boss", null);
450 | 			db.insert(member); // 插入
451 | 			member = db.get(Member.class, 1, 2); // 主键查询
452 | 			System.out.println(member.getTitle());
453 | 			member = new Member(2, 2, "manager", new Date());
454 | 			db.insert(member); // 再插入
455 | 			var count = db.count(Member.class);  // 获取总行数 
456 | 			System.out.println(count);
457 | 			var members = db.find(Member.class); // 获取全部行
458 | 			for (var m : members) {
459 | 				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
460 | 			}
461 | 			member = new Member(2, 3, "manager", new Date());
462 | 			db.insert(member); // 再插入
463 | 			members = db.find(Member.class, Q.eq_("group_id"), 2);  // 条件查询
464 | 			for (var m : members) {
465 | 				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
466 | 			}
467 | 			var setters = new HashMap<String, Object>();
468 | 			setters.put("title", "employee");
469 | 			db.update(Member.class, setters, 2, 3); // 修改
470 | 			member = db.get(Member.class, 2, 3); // 主键查询
471 | 			System.out.println(member.getTitle());
472 | 			db.delete(Member.class, 1, 2); // 删除
473 | 			db.delete(Member.class, 2, 2); // 删除
474 | 			db.delete(Member.class, 2, 3); // 删除
475 | 			count = db.count(Member.class); // 再获取总行数
476 | 			System.out.println(count);
477 | 		} finally {
478 | 			db.drop(Member.class); // 删表
479 | 		}
480 | 	}
481 | 
482 | }
483 | ```
484 | 
485 | 复杂查询
486 | --
487 | 
488 | ```java
489 | public class DemoComplexQuery {
490 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
491 | 
492 | 	public static void main(String[] args) {
493 | 		var db = new DemoDB("demo", URI);
494 | 		try {
495 | 			db.create(Exam.class); // 建表
496 | 			var random = new Random();
497 | 			for (var i = 0; i < 100; i++) {
498 | 				var userId = Math.abs(random.nextLong());
499 | 				var exam = new Exam(userId, random.nextInt(100), random.nextInt(100), random.nextInt(100),
500 | 						random.nextInt(100), random.nextInt(100), random.nextInt(100));
501 | 				db.insert(exam); // 插入
502 | 			}
503 | 			System.out.println(db.count(Exam.class)); // 查询总行数
504 | 			// math >= 50
505 | 			var exams = db.find(Exam.class, Q.ge_("math"), 50); // 条件查询
506 | 			System.out.println(exams.size());
507 | 			var count = db.count(Exam.class, Q.ge_("math"), 50); // 条件总行数
508 | 			System.out.println(count);
509 | 			// math > 50 & english >= 50
510 | 			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件查询
511 | 			System.out.println(exams.size());
512 | 			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件总行数
513 | 			System.out.println(count);
514 | 			// math > 50 || english >= 50
515 | 			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件查询
516 | 			System.out.println(exams.size());
517 | 			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件总行数
518 | 			System.out.println(count);
519 | 			// math > 50 && (english >= 50 || chinese > 60)
520 | 			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 条件查询
521 | 			System.out.println(exams.size());
522 | 			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 条件总行数
523 | 			System.out.println(count);
524 | 			// math > 50 || physics between 60 and 80 || chemistry < 60
525 | 			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80, 60); // 条件查询
526 | 			System.out.println(exams.size());
527 | 			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80,
528 | 					60); // 条件总行数
529 | 			System.out.println(count);
530 | 			// group by math / 10
531 | 			var q = Q.select().field("(math div 10) * 10 as mathx", "count(1)").table("exam").groupBy("mathx")
532 | 					.having(Q.gt_("count(1)")).orderBy("count(1)", "desc"); // 复杂sql构造
533 | 			var rank = new LinkedHashMap<Integer, Integer>();
534 | 			db.any(Exam.class, q, stmt -> { // 原生sql查询
535 | 				stmt.setInt(1, 0);
536 | 				ResultSet rs = stmt.executeQuery();
537 | 				while (rs.next()) {
538 | 					rank.put(rs.getInt(1), rs.getInt(2));
539 | 				}
540 | 				return rs;
541 | 			});
542 | 			rank.forEach((mathx, c) -> {
543 | 				System.out.printf("[%d-%d) = %d\n", mathx, mathx + 10, c);
544 | 			});
545 | 		} finally {
546 | 			db.drop(Exam.class);
547 | 		}
548 | 	}
549 | 
550 | }
551 | ```
552 | 
553 | 分表
554 | --
555 | 
556 | ```java
557 | public class DemoPartitioning {
558 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
559 | 
560 | 	public static void main(String[] args) {
561 | 		var db = new DemoDB("demo", URI);
562 | 		try {
563 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
564 | 				db.create(BookShelf.class, String.valueOf(i)); // 创建所有分表
565 | 			}
566 | 			var bss = new ArrayList<BookShelf>();
567 | 			for (int i = 0; i < 100; i++) {
568 | 				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
569 | 				bss.add(bs);
570 | 				db.insert(bs); // 插入，自动插入相应分表
571 | 			}
572 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
573 | 				System.out.printf("partition %d count %d\n", i, db.count(BookShelf.class, String.valueOf(i)));
574 | 			}
575 | 			Random random = new Random();
576 | 			for (var bs : bss) {
577 | 				bs.setComment("comment_update_" + random.nextInt(100));
578 | 				db.update(bs); // 更新，自动更新相应分表数据
579 | 			}
580 | 			bss = new ArrayList<BookShelf>();
581 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
582 | 				bss.addAll(db.find(BookShelf.class, String.valueOf(i))); // 指定分表列出所有行
583 | 			}
584 | 			for (var bs : bss) {
585 | 				System.out.println(bs.getComment());
586 | 			}
587 | 			for (var bs : bss) {
588 | 				db.delete(bs); // 挨个删除，自动删除相应分表数据
589 | 			}
590 | 		} finally {
591 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
592 | 				db.drop(BookShelf.class, String.valueOf(i)); // 删除所有分表
593 | 			}
594 | 		}
595 | 	}
596 | 
597 | }
598 | ```
599 | 
600 | 分库
601 | --
602 | 
603 | ```java
604 | public class DemoSharding {
605 | 
606 | 	private static DemoDB[] dbs = new DemoDB[3];
607 | 	static {
608 | 		Map<Class<? extends IEntity>, Meta> metas = new HashMap<>();
609 | 		dbs[0] = new DemoDB("demo-0", metas,
610 | 				"jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
611 | 		dbs[1] = new DemoDB("demo-1", metas,
612 | 				"jdbc:mysql://localhost:3307/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
613 | 		dbs[2] = new DemoDB("demo-2", metas,
614 | 				"jdbc:mysql://localhost:3308/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
615 | 	}
616 | 
617 | 	public static void main(String[] args) {
618 | 		var grid = new GridDemoDB(dbs); // 构造Grid实例
619 | 		try {
620 | 			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
621 | 				grid.create(BookShelf.class, String.valueOf(k)); // 创建所有分库中的分表
622 | 			}
623 | 			var bss = new ArrayList<BookShelf>();
624 | 			for (int i = 0; i < 100; i++) {
625 | 				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
626 | 				bss.add(bs);
627 | 				grid.insert(bs); // 插入，自动分发到相应的分库中的分表
628 | 			}
629 | 			for (int k = 0; k < grid.size(); k++) {
630 | 				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
631 | 					System.out.printf("db %d partition %d count %d\n", k, i,
632 | 							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查询出所有分库的分表的行数
633 | 				}
634 | 			}
635 | 			Random random = new Random();
636 | 			for (var bs : bss) {
637 | 				bs.setComment("comment_update_" + random.nextInt(100));
638 | 				grid.update(bs); // 更新，自动分发到相应的分库中的分表
639 | 			}
640 | 			for (var bs : bss) {
641 | 				bs = grid.get(BookShelf.class, bs.getUserId(), bs.getBookId()); // 主键查询，自动分发到相应的分库中的分表
642 | 				System.out.println(bs.getComment());
643 | 			}
644 | 			for (var bs : bss) {
645 | 				grid.delete(bs); // 删除，自动分发到相应的分库中的分表
646 | 			}
647 | 			for (int k = 0; k < grid.size(); k++) {
648 | 				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
649 | 					System.out.printf("db %d partition %d count %d\n", k, i,
650 | 							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查询出所有分库的分表的行数
651 | 				}
652 | 			}
653 | 		} finally {
654 | 			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
655 | 				grid.drop(BookShelf.class, String.valueOf(k)); // 删除所有分库中的分表
656 | 			}
657 | 		}
658 | 	}
659 | 
660 | }
661 | ```
662 | 
663 | 事件上下文对象
664 | --
665 | 
666 | ```java
667 | public class Context {
668 | 
669 | 	private DB db; // 数据库实例
670 | 	private Connection conn;  // 当前的链接
671 | 	private Class<? extends IEntity> clazz; // 当前的实体类
672 | 	private Q q; // 查询sql
673 | 	private Object[] values; // 查询的绑定参数
674 | 	private boolean before; // before or after
675 | 	private Exception error; // 异常
676 | 	private long duration; // 耗时microsecond
677 | 
678 | }
679 | ```
680 | 
681 | 事件回调
682 | --
683 | 
684 | ```java
685 | public class DemoEvent {
686 | 
687 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
688 | 
689 | 	public static void main(String[] args) {
690 | 		var db = new DemoDB("demo", URI);
691 | 		db.on(ctx -> { // 全局事件回调
692 | 			System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
693 | 			return true; // 返回false会导致事件链终止，后续的ORM操作也不会执行
694 | 		});
695 | 		try {
696 | 			db.create(User.class);
697 | 			db.scope(ctx -> { // 范围回调，execute方法内部的所有ORM操作都会回调
698 | 				System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
699 | 				return true;
700 | 			}).execute(() -> {
701 | 				db.count(User.class);
702 | 				db.find(User.class);
703 | 			});
704 | 		} finally {
705 | 			db.drop(User.class); // 删除表
706 | 		}
707 | 	}
708 | 
709 | }
710 | ```
711 | 
712 | 相关链接
713 | --
714 | 撸web框架 https://github.com/pyloque/httpkids
715 | 
716 | 撸rpc框架 https://github.com/pyloque/rpckids
717 | 
718 | 撸依赖注入框架 https://github.com/pyloque/iockids
719 | 
720 | 讨论
721 | --
722 | 关注公众号「码洞」，跟大佬们一起撸
723 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  2 | 	<modelVersion>4.0.0</modelVersion>
  3 | 	<groupId>com.github.pyloque</groupId>
  4 | 	<artifactId>ormkids</artifactId>
  5 | 	<version>0.0.5-SNAPSHOT</version>
  6 | 
  7 | 	<name>ormkids</name>
  8 | 	<url>http://maven.apache.org</url>
  9 | 	<description>MySQL ORM framework for Java with Sharding supported</description>
 10 | 
 11 | 	<licenses>
 12 | 		<license>
 13 | 			<name>The Apache Software License, Version 2.0</name>
 14 | 			<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
 15 | 		</license>
 16 | 	</licenses>
 17 | 
 18 | 	<developers>
 19 | 		<developer>
 20 | 			<name>pyloque</name>
 21 | 			<email>holycoder@163.com</email>
 22 | 		</developer>
 23 | 	</developers>
 24 | 
 25 | 	<scm>
 26 | 		<connection>scm:git:https://github.com/pyloque/ormkids</connection>
 27 | 		<developerConnection>scm:git:git@github.com:pyloque/ormkids.git</developerConnection>
 28 | 		<url>https://github.com/pyloque/ormkids</url>
 29 | 	  <tag>HEAD</tag>
 30 |   </scm>
 31 | 
 32 | 	<distributionManagement>
 33 | 		<snapshotRepository>
 34 | 			<id>snapshots</id>
 35 | 			<url>https://oss.sonatype.org/content/repositories/snapshots/</url>
 36 | 		</snapshotRepository>
 37 | 		<repository>
 38 | 			<id>releases</id>
 39 | 			<url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
 40 | 		</repository>
 41 | 	</distributionManagement>
 42 | 
 43 | 	<properties>
 44 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 45 | 	</properties>
 46 | 
 47 | 	<build>
 48 | 		<plugins>
 49 | 			<plugin>
 50 | 				<artifactId>maven-compiler-plugin</artifactId>
 51 | 				<version>3.1</version>
 52 | 				<configuration>
 53 | 					<source>10</source>
 54 | 					<target>10</target>
 55 | 					<excludes>
 56 | 						<exclude>ormkids/demo/*</exclude>
 57 | 					</excludes>
 58 | 				</configuration>
 59 | 			</plugin>
 60 | 			<plugin>
 61 | 				<groupId>org.apache.maven.plugins</groupId>
 62 | 				<artifactId>maven-source-plugin</artifactId>
 63 | 				<version>2.2.1</version>
 64 | 				<executions>
 65 | 					<execution>
 66 | 						<phase>package</phase>
 67 | 						<goals>
 68 | 							<goal>jar-no-fork</goal>
 69 | 						</goals>
 70 | 					</execution>
 71 | 				</executions>
 72 | 			</plugin>
 73 | 			<plugin>
 74 | 				<groupId>org.apache.maven.plugins</groupId>
 75 | 				<artifactId>maven-javadoc-plugin</artifactId>
 76 | 				<version>3.0.0</version>
 77 | 				<executions>
 78 | 					<execution>
 79 | 						<phase>package</phase>
 80 | 						<goals>
 81 | 							<goal>jar</goal>
 82 | 						</goals>
 83 | 					</execution>
 84 | 				</executions>
 85 | 			</plugin>
 86 | 			<plugin>
 87 | 				<groupId>org.apache.maven.plugins</groupId>
 88 | 				<artifactId>maven-gpg-plugin</artifactId>
 89 | 				<version>1.5</version>
 90 | 				<executions>
 91 | 					<execution>
 92 | 						<id>sign-artifacts</id>
 93 | 						<phase>verify</phase>
 94 | 						<goals>
 95 | 							<goal>sign</goal>
 96 | 						</goals>
 97 | 					</execution>
 98 | 				</executions>
 99 | 			</plugin>
100 | 			<plugin>
101 | 				<groupId>org.apache.maven.plugins</groupId>
102 | 				<artifactId>maven-release-plugin</artifactId>
103 | 				<version>2.5.3</version>
104 | 				<configuration>
105 | 					<tagNameFormat>v@{project.version}</tagNameFormat>
106 | 				</configuration>
107 | 			</plugin>
108 | 		</plugins>
109 | 	</build>
110 | 
111 | 	<dependencies>
112 | 		<dependency>
113 | 			<groupId>org.slf4j</groupId>
114 | 			<artifactId>slf4j-api</artifactId>
115 | 			<version>1.7.5</version>
116 | 			<optional>true</optional>
117 | 		</dependency>
118 | 		<dependency>
119 | 			<groupId>org.slf4j</groupId>
120 | 			<artifactId>slf4j-log4j12</artifactId>
121 | 			<version>1.7.5</version>
122 | 			<optional>true</optional>
123 | 		</dependency>
124 | 		<dependency>
125 | 			<groupId>mysql</groupId>
126 | 			<artifactId>mysql-connector-java</artifactId>
127 | 			<version>6.0.6</version>
128 | 			<optional>true</optional>
129 | 		</dependency>
130 | 	</dependencies>
131 | </project>
132 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/Column.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.lang.reflect.Field;
 4 | 
 5 | public class Column {
 6 | 	private String name;
 7 | 	private String type;
 8 | 	private boolean primary;
 9 | 	private boolean autoIncrement;
10 | 	private boolean nullable;
11 | 	private String defaultValue;
12 | 
13 | 	private Field field;
14 | 
15 | 	public Column(String name, String type) {
16 | 		this(name, type, false, true, null);
17 | 	}
18 | 
19 | 	public Column(String name, String type, boolean autoIncrement, boolean nullable, String defaultValue) {
20 | 		this.name = name;
21 | 		this.type = type;
22 | 		this.autoIncrement = autoIncrement;
23 | 		this.nullable = nullable;
24 | 		this.defaultValue = defaultValue;
25 | 	}
26 | 
27 | 	public Column field(Field field) {
28 | 		this.field = field;
29 | 		return this;
30 | 	}
31 | 
32 | 	public void primary(boolean primary) {
33 | 		this.primary = primary;
34 | 	}
35 | 
36 | 	public boolean primary() {
37 | 		return this.primary;
38 | 	}
39 | 
40 | 	public Field field() {
41 | 		return this.field;
42 | 	}
43 | 
44 | 	public String s() {
45 | 		StringBuilder builder = new StringBuilder();
46 | 		builder.append(String.format("`%s`", name));
47 | 		builder.append(" ");
48 | 		builder.append(type);
49 | 		if (!nullable) {
50 | 			builder.append(" not null");
51 | 		}
52 | 		if (autoIncrement) {
53 | 			builder.append(" auto_increment");
54 | 		}
55 | 
56 | 		if (defaultValue != null && !defaultValue.isEmpty()) {
57 | 			builder.append(" default ");
58 | 			builder.append(defaultValue);
59 | 		}
60 | 		return builder.toString();
61 | 	}
62 | 
63 | 	public String name() {
64 | 		return name;
65 | 	}
66 | 
67 | 	public String type() {
68 | 		return type;
69 | 	}
70 | 
71 | 	public boolean autoIncrement() {
72 | 		return autoIncrement;
73 | 	}
74 | 
75 | 	public boolean nullable() {
76 | 		return nullable;
77 | 	}
78 | 
79 | 	public String defaultValue() {
80 | 		return defaultValue;
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/Context.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.sql.Connection;
 4 | 
 5 | public class Context {
 6 | 
 7 | 	@FunctionalInterface
 8 | 	public static interface IEventListener {
 9 | 		boolean on(Context ctx);
10 | 	}
11 | 
12 | 	private DB db;
13 | 	private Connection conn;
14 | 	private Class<? extends IEntity> clazz;
15 | 	private Q q;
16 | 	private Object[] values;
17 | 	private boolean before;
18 | 	private Exception error;
19 | 	private long duration; // microsecond
20 | 
21 | 	private final static Object[] EmptyValues = new Object[] {};
22 | 
23 | 	public static Context before(DB db, Connection conn, Class<? extends IEntity> clazz, Q q, Object[] values) {
24 | 		var ctx = new Context();
25 | 		ctx.db = db;
26 | 		ctx.conn = conn;
27 | 		ctx.clazz = clazz;
28 | 		ctx.q = q;
29 | 		ctx.values = values;
30 | 		ctx.before = true;
31 | 		return ctx;
32 | 	}
33 | 
34 | 	public static Context after(DB db, Connection conn, Class<? extends IEntity> clazz, Q q, Object[] values,
35 | 			Exception error, long duration) {
36 | 		var ctx = new Context();
37 | 		ctx.db = db;
38 | 		ctx.conn = conn;
39 | 		ctx.clazz = clazz;
40 | 		ctx.q = q;
41 | 		ctx.values = values;
42 | 		ctx.before = false;
43 | 		ctx.error = error;
44 | 		ctx.duration = duration;
45 | 		return ctx;
46 | 	}
47 | 
48 | 	public Class<? extends IEntity> clazz() {
49 | 		return clazz;
50 | 	}
51 | 
52 | 	public Q q() {
53 | 		return q;
54 | 	}
55 | 
56 | 	public DB db() {
57 | 		return db;
58 | 	}
59 | 
60 | 	public Object[] values() {
61 | 		return values != null ? values : EmptyValues;
62 | 	}
63 | 
64 | 	public boolean before() {
65 | 		return before;
66 | 	}
67 | 
68 | 	public boolean after() {
69 | 		return !before;
70 | 	}
71 | 
72 | 	public Connection conn() {
73 | 		return conn;
74 | 	}
75 | 
76 | 	public Exception error() {
77 | 		return error;
78 | 	}
79 | 
80 | 	public Context error(Exception error) {
81 | 		this.error = error;
82 | 		return this;
83 | 	}
84 | 
85 | 	public long duration() {
86 | 		return duration;
87 | 	}
88 | 
89 | }
90 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/DB.java:
--------------------------------------------------------------------------------
  1 | package ormkids;
  2 | 
  3 | import java.lang.annotation.Annotation;
  4 | import java.lang.reflect.Field;
  5 | import java.sql.Connection;
  6 | import java.sql.PreparedStatement;
  7 | import java.sql.ResultSet;
  8 | import java.sql.SQLException;
  9 | import java.util.ArrayList;
 10 | import java.util.Collections;
 11 | import java.util.HashMap;
 12 | import java.util.LinkedHashMap;
 13 | import java.util.List;
 14 | import java.util.Map;
 15 | 
 16 | import ormkids.Context.IEventListener;
 17 | import ormkids.Q.Filterable;
 18 | 
 19 | public abstract class DB {
 20 | 
 21 | 	private Map<Class<? extends IEntity>, Meta> metas;
 22 | 	private String name;
 23 | 
 24 | 	public DB(String name) {
 25 | 		this(name, new HashMap<>());
 26 | 	}
 27 | 
 28 | 	public DB(String name, Map<Class<? extends IEntity>, Meta> metas) {
 29 | 		this.name = name;
 30 | 		this.metas = Collections.synchronizedMap(metas);
 31 | 	}
 32 | 
 33 | 	public String name() {
 34 | 		return name;
 35 | 	}
 36 | 
 37 | 	private <T extends IEntity> T empty(Class<T> clazz) {
 38 | 		try {
 39 | 			return clazz.getDeclaredConstructor().newInstance();
 40 | 		} catch (Exception e) {
 41 | 			throw new KidsException("entity class should provide default constructor");
 42 | 		}
 43 | 	}
 44 | 
 45 | 	private <T extends IEntity> T empty(Class<T> clazz, Object... ids) {
 46 | 		var empty = empty(clazz);
 47 | 		var meta = meta(clazz);
 48 | 		var i = 0;
 49 | 		for (var name : meta.indices.primary().columns()) {
 50 | 			var column = meta.columns.get(name);
 51 | 			try {
 52 | 				column.field().set(empty, ids[i]);
 53 | 			} catch (Exception e) {
 54 | 				throw new KidsException("access field errror", e);
 55 | 			}
 56 | 			i++;
 57 | 		}
 58 | 		return empty;
 59 | 	}
 60 | 
 61 | 	static class Holder<T> {
 62 | 		T value;
 63 | 	}
 64 | 
 65 | 	private List<IEventListener> listeners = Collections.synchronizedList(new ArrayList<>());
 66 | 	private ThreadLocal<IEventListener> localListener = new ThreadLocal<>();
 67 | 
 68 | 	public DB on(IEventListener listener) {
 69 | 		this.listeners.add(listener);
 70 | 		return this;
 71 | 	}
 72 | 
 73 | 	public DB off(IEventListener listener) {
 74 | 		this.listeners.remove(listener);
 75 | 		return this;
 76 | 	}
 77 | 
 78 | 	@FunctionalInterface
 79 | 	public static interface IExecutor {
 80 | 		void execute(Runnable runnable);
 81 | 	}
 82 | 
 83 | 	public IExecutor scope(IEventListener listener) {
 84 | 		return new IExecutor() {
 85 | 
 86 | 			public void execute(Runnable runnable) {
 87 | 				localListener.set(listener);
 88 | 				try {
 89 | 					runnable.run();
 90 | 				} finally {
 91 | 					localListener.remove();
 92 | 				}
 93 | 			}
 94 | 
 95 | 		};
 96 | 	}
 97 | 
 98 | 	public boolean invokeListeners(Context event) {
 99 | 		if (localListener.get() != null) {
100 | 			if (!localListener.get().on(event)) {
101 | 				return false;
102 | 			}
103 | 		}
104 | 		for (var listener : listeners) {
105 | 			if (!listener.on(event)) {
106 | 				return false;
107 | 			}
108 | 		}
109 | 		return true;
110 | 	}
111 | 
112 | 	@FunctionalInterface
113 | 	public static interface ITransactionOp {
114 | 		void execute(Connection conn);
115 | 	}
116 | 
117 | 	public void withinTx(ITransactionOp op) {
118 | 		withinTx(op, true);
119 | 	}
120 | 
121 | 	public void withinTx(ITransactionOp op, boolean tx) {
122 | 		var conn = conn();
123 | 		try {
124 | 			op.execute(conn);
125 | 			if (tx) {
126 | 				conn.commit();
127 | 			}
128 | 		} catch (SQLException e) {
129 | 			if (tx) {
130 | 				try {
131 | 					conn.rollback();
132 | 				} catch (SQLException e1) {
133 | 				}
134 | 			}
135 | 		} finally {
136 | 			try {
137 | 				conn.close();
138 | 			} catch (SQLException e) {
139 | 			}
140 | 		}
141 | 	}
142 | 
143 | 	@FunctionalInterface
144 | 	public static interface IPrepareOp {
145 | 		void prepare(PreparedStatement stmt) throws SQLException;
146 | 	}
147 | 
148 | 	public void withinPrepare(Connection conn, String sql, IPrepareOp op) {
149 | 		PreparedStatement stmt = null;
150 | 		try {
151 | 			stmt = conn.prepareStatement(sql);
152 | 			op.prepare(stmt);
153 | 		} catch (SQLException e) {
154 | 			throw new KidsException(e);
155 | 		} finally {
156 | 			if (stmt != null) {
157 | 				try {
158 | 					stmt.close();
159 | 				} catch (SQLException e) {
160 | 				}
161 | 			}
162 | 		}
163 | 	}
164 | 
165 | 	@FunctionalInterface
166 | 	public static interface IQueryOp {
167 | 		ResultSet query(PreparedStatement stmt) throws SQLException;
168 | 	}
169 | 
170 | 	public void withinQuery(Connection conn, String sql, IQueryOp op) {
171 | 		PreparedStatement stmt = null;
172 | 		ResultSet result = null;
173 | 		try {
174 | 			stmt = conn.prepareStatement(sql);
175 | 			result = op.query(stmt);
176 | 		} catch (SQLException e) {
177 | 			throw new KidsException(e);
178 | 		} finally {
179 | 			if (result != null) {
180 | 				try {
181 | 					result.close();
182 | 				} catch (SQLException e) {
183 | 				}
184 | 			}
185 | 			if (stmt != null) {
186 | 				try {
187 | 					stmt.close();
188 | 				} catch (SQLException e) {
189 | 				}
190 | 			}
191 | 		}
192 | 	}
193 | 
194 | 	protected abstract Connection conn();
195 | 
196 | 	public void create(Class<? extends IEntity> clazz) {
197 | 		withinTx(conn -> {
198 | 			create(conn, clazz, null);
199 | 		});
200 | 	}
201 | 
202 | 	public void create(Class<? extends IEntity> clazz, String suffix) {
203 | 		withinTx(conn -> {
204 | 			create(conn, clazz, suffix);
205 | 		});
206 | 	}
207 | 
208 | 	public void create(Connection conn, Class<? extends IEntity> clazz, String suffix) {
209 | 		withinPrepare(conn, createSQL(clazz, suffix), stmt -> {
210 | 			stmt.execute();
211 | 		});
212 | 	}
213 | 
214 | 	private String createSQL(Class<? extends IEntity> clazz, String suffix) {
215 | 		var meta = meta(clazz);
216 | 		var q = Q.create().table(meta.name, suffix);
217 | 		meta.columns.forEach((name, column) -> {
218 | 			q.column(column.name(), column.type(), column.autoIncrement(), column.nullable(), column.defaultValue());
219 | 		});
220 | 		meta.indices.indices().forEach(index -> {
221 | 			q.index(index.primaryKey(), index.unique(), index.columns());
222 | 		});
223 | 		meta.options.options().forEach(option -> {
224 | 			q.option(option.key(), option.value());
225 | 		});
226 | 		return q.sql();
227 | 	}
228 | 
229 | 	public void drop(Class<? extends IEntity> clazz) {
230 | 		drop(clazz, null);
231 | 	}
232 | 
233 | 	public void drop(Class<? extends IEntity> clazz, String suffix) {
234 | 		withinTx(conn -> {
235 | 			drop(conn, clazz, suffix);
236 | 		});
237 | 	}
238 | 
239 | 	public void drop(Connection conn, Class<? extends IEntity> clazz, String suffix) {
240 | 		withinPrepare(conn, dropSQL(clazz, suffix), stmt -> {
241 | 			stmt.execute();
242 | 		});
243 | 	}
244 | 
245 | 	private String dropSQL(Class<? extends IEntity> clazz, String suffix) {
246 | 		var meta = meta(clazz);
247 | 		var q = Q.drop().table(meta.name, suffix);
248 | 		return q.sql();
249 | 	}
250 | 
251 | 	public void truncate(Class<? extends IEntity> clazz) {
252 | 		truncate(clazz, null);
253 | 	}
254 | 
255 | 	public void truncate(Class<? extends IEntity> clazz, String suffix) {
256 | 		withinTx(conn -> {
257 | 			truncate(conn, clazz, suffix);
258 | 		});
259 | 	}
260 | 
261 | 	public void truncate(Connection conn, Class<? extends IEntity> clazz, String suffix) {
262 | 		withinPrepare(conn, truncateSQL(clazz, suffix), stmt -> {
263 | 			stmt.execute();
264 | 		});
265 | 	}
266 | 
267 | 	private String truncateSQL(Class<? extends IEntity> clazz, String suffix) {
268 | 		var meta = meta(clazz);
269 | 		var q = Q.truncate().table(meta.name, suffix);
270 | 		return q.sql();
271 | 	}
272 | 
273 | 	private <T extends IEntity> T translate(ResultSet rs, Class<T> clazz) throws SQLException {
274 | 		var meta = this.meta(clazz);
275 | 		var rowMeta = rs.getMetaData();
276 | 		try {
277 | 			var res = empty(clazz);
278 | 			for (int i = 0; i < rowMeta.getColumnCount(); i++) {
279 | 				String name = rowMeta.getColumnName(i + 1);
280 | 				var column = meta.columns.get(name.toLowerCase());
281 | 				if (column != null) {
282 | 					column.field().setAccessible(true);
283 | 					column.field().set(res, rs.getObject(i + 1));
284 | 				}
285 | 			}
286 | 			return res;
287 | 		} catch (Exception e) {
288 | 			throw new KidsException("entity class should provide default constructor");
289 | 		}
290 | 	}
291 | 
292 | 	public <T extends IEntity> T get(Class<T> clazz, Object... ids) {
293 | 		var holder = new Holder<T>();
294 | 		withinTx(conn -> {
295 | 			holder.value = get(conn, clazz, ids);
296 | 		}, false);
297 | 		return holder.value;
298 | 	}
299 | 
300 | 	public <T extends IEntity> T get(Connection conn, Class<T> clazz, Object... ids) {
301 | 		var holder = new Holder<T>();
302 | 		withinQuery(conn, selectSQL(clazz, ids), stmt -> {
303 | 			for (int i = 0; i < ids.length; i++) {
304 | 				stmt.setObject(i + 1, ids[i]);
305 | 			}
306 | 			ResultSet result = stmt.executeQuery();
307 | 			if (!result.next()) {
308 | 				return null;
309 | 			}
310 | 			holder.value = translate(result, clazz);
311 | 			return result;
312 | 		});
313 | 		return holder.value;
314 | 	}
315 | 
316 | 	private String selectSQL(Class<? extends IEntity> clazz, Object... ids) {
317 | 		var meta = meta(clazz);
318 | 		var columns = meta.indices.primary().columns();
319 | 		if (columns.length != ids.length) {
320 | 			throw new KidsException("ids length must match with primary columns");
321 | 		}
322 | 		var filters = new Filterable[ids.length];
323 | 		for (int i = 0; i < ids.length; i++) {
324 | 			filters[i] = Q.eq_(columns[i]);
325 | 		}
326 | 		var empty = empty(clazz, ids);
327 | 		var q = Q.select().field("*").table(empty.table(), empty.suffix()).where(Q.and(filters));
328 | 		return q.sql();
329 | 	}
330 | 
331 | 	public <T extends IEntity> List<T> find(Class<T> clazz) {
332 | 		return this.find(clazz, null, 0, 0, null, new Object[] {});
333 | 	}
334 | 
335 | 	public <T extends IEntity> List<T> find(Class<T> clazz, Filterable filter, Object... values) {
336 | 		return this.find(clazz, null, 0, 0, filter, values);
337 | 	}
338 | 
339 | 	public <T extends IEntity> List<T> find(Class<T> clazz, String suffix, Object... values) {
340 | 		return this.find(clazz, suffix, 0, 0, null, values);
341 | 	}
342 | 
343 | 	public <T extends IEntity> List<T> find(Class<T> clazz, String suffix, Filterable filter, Object... values) {
344 | 		return this.find(clazz, suffix, 0, 0, filter, values);
345 | 	}
346 | 
347 | 	public <T extends IEntity> List<T> find(Class<T> clazz, String suffix, int offset, int limit, Filterable filter,
348 | 			Object... values) {
349 | 		var holder = new Holder<List<T>>();
350 | 		withinTx(conn -> {
351 | 			holder.value = find(conn, clazz, suffix, filter, offset, limit, values);
352 | 		}, false);
353 | 		return holder.value;
354 | 	}
355 | 
356 | 	public <T extends IEntity> List<T> find(Connection conn, Class<T> clazz, String suffix, Filterable filter,
357 | 			Object... values) {
358 | 		return this.find(conn, clazz, suffix, filter, 0, 0, values);
359 | 	}
360 | 
361 | 	public <T extends IEntity> List<T> find(Connection conn, Class<T> clazz, String suffix, Filterable filter,
362 | 			int offset, int limit, Object... values) {
363 | 		var holder = new Holder<List<T>>();
364 | 		withinQuery(conn, findSQL(clazz, suffix, filter, offset, limit), stmt -> {
365 | 			int i = 1;
366 | 			for (; i <= values.length; i++) {
367 | 				stmt.setObject(i, values[i - 1]);
368 | 			}
369 | 			if (offset > 0) {
370 | 				stmt.setObject(i++, offset);
371 | 			}
372 | 			if (limit > 0) {
373 | 				stmt.setObject(i++, limit);
374 | 			}
375 | 			ResultSet res = stmt.executeQuery();
376 | 			var result = new ArrayList<T>();
377 | 			while (res.next()) {
378 | 				result.add(translate(res, clazz));
379 | 			}
380 | 			holder.value = result;
381 | 			return res;
382 | 		});
383 | 		return holder.value;
384 | 	}
385 | 
386 | 	private String findSQL(Class<? extends IEntity> clazz, String suffix, Filterable filter, int offset, int limit) {
387 | 		var meta = meta(clazz);
388 | 		var q = Q.select().field("*").table(meta.name, suffix);
389 | 		if (filter != null) {
390 | 			q.where(filter);
391 | 		}
392 | 		if (offset > 0) {
393 | 			q.offset_();
394 | 		}
395 | 		if (limit > 0) {
396 | 			q.limit_();
397 | 		}
398 | 		return q.sql();
399 | 	}
400 | 
401 | 	public long count(Class<? extends IEntity> clazz) {
402 | 		// eliminate warnings
403 | 		String suffix = null;
404 | 		Filterable filter = null;
405 | 		return count(clazz, suffix, filter);
406 | 	}
407 | 
408 | 	public long count(Class<? extends IEntity> clazz, Filterable filter, Object... values) {
409 | 		return count(clazz, null, filter, values);
410 | 	}
411 | 
412 | 	public long count(Class<? extends IEntity> clazz, String suffix) {
413 | 		return count(clazz, suffix, null);
414 | 	}
415 | 
416 | 	public long count(Class<? extends IEntity> clazz, String suffix, Filterable filter, Object... values) {
417 | 		var holder = new Holder<Long>();
418 | 		withinTx(conn -> {
419 | 			holder.value = count(conn, clazz, suffix, filter, values);
420 | 		}, false);
421 | 		return holder.value;
422 | 	}
423 | 
424 | 	public long count(Connection conn, Class<? extends IEntity> clazz, String suffix, Filterable filter,
425 | 			Object... values) {
426 | 		var holder = new Holder<Long>();
427 | 		var q = countSQL(clazz, suffix, filter);
428 | 		var evt = Context.before(this, conn, clazz, q, values);
429 | 		if (!this.invokeListeners(evt)) {
430 | 			return -1;
431 | 		}
432 | 		long start = System.nanoTime();
433 | 		Exception error = null;
434 | 		try {
435 | 			withinQuery(conn, q.sql(), stmt -> {
436 | 				var i = 1;
437 | 				for (; i <= values.length; i++) {
438 | 					stmt.setObject(i, values[i - 1]);
439 | 				}
440 | 				ResultSet res = stmt.executeQuery();
441 | 				res.next();
442 | 				holder.value = res.getLong(1);
443 | 				return res;
444 | 			});
445 | 		} catch (RuntimeException e) {
446 | 			error = e;
447 | 		}
448 | 		long duration = (System.nanoTime() - start) / 1000;
449 | 		evt = Context.after(this, conn, clazz, q, values, error, duration);
450 | 		this.invokeListeners(evt);
451 | 		return holder.value;
452 | 	}
453 | 
454 | 	private Q countSQL(Class<? extends IEntity> clazz, String suffix, Filterable filter) {
455 | 		var meta = meta(clazz);
456 | 		var q = Q.select().field("count(1)").table(meta.name, suffix);
457 | 		if (filter != null) {
458 | 			q.where(filter);
459 | 		}
460 | 		return q;
461 | 	}
462 | 
463 | 	public void any(Class<? extends IEntity> clazz, Q q, IQueryOp op, Object... values) {
464 | 		this.withinTx(conn -> {
465 | 			any(conn, clazz, q, op, values);
466 | 		}, false);
467 | 	}
468 | 
469 | 	public void any(Connection conn, Class<? extends IEntity> clazz, Q q, IQueryOp op, Object... values) {
470 | 		var evt = Context.before(this, conn, clazz, q, values);
471 | 		if (!this.invokeListeners(evt)) {
472 | 			return;
473 | 		}
474 | 		long start = System.nanoTime();
475 | 		Exception error = null;
476 | 		try {
477 | 			this.withinQuery(conn, q.sql(), op);
478 | 		} catch (RuntimeException e) {
479 | 			error = e;
480 | 		}
481 | 		long duration = (System.nanoTime() - start) / 1000;
482 | 		this.invokeListeners(Context.after(this, conn, clazz, q, values, error, duration));
483 | 	}
484 | 
485 | 	private <T extends IEntity> Object[] ids(T t) {
486 | 		var meta = meta(t.getClass());
487 | 		Object[] ids = new Object[meta.indices.primary().columns().length];
488 | 		var i = 0;
489 | 		for (var name : meta.indices.primary().columns()) {
490 | 			var field = meta.columns.get(name).field();
491 | 			try {
492 | 				ids[i++] = field.get(t);
493 | 			} catch (Exception e) {
494 | 				throw new KidsException("access field errror", e);
495 | 			}
496 | 		}
497 | 		return ids;
498 | 	}
499 | 
500 | 	private <T extends IEntity> Map<String, Object> values(T t) {
501 | 		var meta = meta(t.getClass());
502 | 		var values = new HashMap<String, Object>();
503 | 		meta.columns.forEach((name, column) -> {
504 | 			Field f = column.field();
505 | 			try {
506 | 				values.put(f.getName(), f.get(t));
507 | 			} catch (Exception e) {
508 | 				throw new KidsException("access field errror", e);
509 | 			}
510 | 		});
511 | 		return values;
512 | 	}
513 | 
514 | 	public <T extends IEntity> int delete(T t) {
515 | 		return delete(t.getClass(), ids(t));
516 | 	}
517 | 
518 | 	public int delete(Class<? extends IEntity> clazz, Object... ids) {
519 | 		var holder = new Holder<Integer>();
520 | 		withinTx(conn -> {
521 | 			holder.value = delete(conn, clazz, ids);
522 | 		});
523 | 		return holder.value;
524 | 	}
525 | 
526 | 	public int delete(Connection conn, Class<? extends IEntity> clazz, Object... ids) {
527 | 		var holder = new Holder<Integer>();
528 | 		var q = deleteSQL(clazz, ids);
529 | 		var evt = Context.before(this, conn, clazz, q, ids);
530 | 		if (!this.invokeListeners(evt)) {
531 | 			return -1;
532 | 		}
533 | 		long start = System.nanoTime();
534 | 		Exception error = null;
535 | 		try {
536 | 			withinPrepare(conn, q.sql(), stmt -> {
537 | 				for (int i = 0; i < ids.length; i++) {
538 | 					stmt.setObject(i + 1, ids[i]);
539 | 				}
540 | 				holder.value = stmt.executeUpdate();
541 | 			});
542 | 		} catch (RuntimeException e) {
543 | 			error = e;
544 | 		}
545 | 		long duration = (System.nanoTime() - start) / 1000;
546 | 		this.invokeListeners(Context.after(this, conn, clazz, q, ids, error, duration));
547 | 		return holder.value;
548 | 	}
549 | 
550 | 	private Q deleteSQL(Class<? extends IEntity> clazz, Object... ids) {
551 | 		var meta = meta(clazz);
552 | 		var columns = meta.indices.primary().columns();
553 | 		if (columns.length != ids.length) {
554 | 			throw new KidsException("ids length must match with primary columns");
555 | 		}
556 | 		var filters = new Filterable[ids.length];
557 | 		for (int i = 0; i < ids.length; i++) {
558 | 			filters[i] = Q.eq_(columns[i]);
559 | 		}
560 | 		var empty = empty(clazz, ids);
561 | 		var q = Q.delete().table(empty.table(), empty.suffix()).where(Q.and(filters));
562 | 		return q;
563 | 	}
564 | 
565 | 	public <T extends IEntity> int update(T t) {
566 | 		return update(t.getClass(), values(t), ids(t));
567 | 	}
568 | 
569 | 	public int update(Class<? extends IEntity> clazz, Map<String, Object> values, Object... ids) {
570 | 		var holder = new Holder<Integer>();
571 | 		var valuesModify = new HashMap<>(values); // copy it for modify
572 | 		var meta = meta(clazz);
573 | 		// remove pk values
574 | 		for (var name : meta.indices.primary().fields()) {
575 | 			valuesModify.remove(name);
576 | 		}
577 | 		withinTx(conn -> {
578 | 			holder.value = update(conn, clazz, valuesModify, ids);
579 | 		});
580 | 		return holder.value;
581 | 	}
582 | 
583 | 	public int update(Connection conn, Class<? extends IEntity> clazz, Map<String, Object> values, Object... ids) {
584 | 		var holder = new Holder<Integer>();
585 | 		var q = updateSQL(clazz, values, ids);
586 | 		var hybridValues = new Object[values.size() + ids.length];
587 | 		int i = 0;
588 | 		for (var value : values.values()) {
589 | 			hybridValues[i++] = value;
590 | 		}
591 | 		for (var id : ids) {
592 | 			hybridValues[i++] = id;
593 | 		}
594 | 		var evt = Context.before(this, conn, clazz, q, hybridValues);
595 | 		if (!this.invokeListeners(evt)) {
596 | 			return -1;
597 | 		}
598 | 		long start = System.nanoTime();
599 | 		Exception error = null;
600 | 		try {
601 | 			withinPrepare(conn, q.sql(), stmt -> {
602 | 				for (int k = 0; k < hybridValues.length; k++) {
603 | 					stmt.setObject(k + 1, hybridValues[k]);
604 | 				}
605 | 				holder.value = stmt.executeUpdate();
606 | 			});
607 | 		} catch (RuntimeException e) {
608 | 			error = e;
609 | 		}
610 | 		long duration = (System.nanoTime() - start) / 1000;
611 | 		this.invokeListeners(Context.after(this, conn, clazz, q, hybridValues, error, duration));
612 | 		return holder.value;
613 | 	}
614 | 
615 | 	private Q updateSQL(Class<? extends IEntity> clazz, Map<String, Object> values, Object... ids) {
616 | 		var meta = meta(clazz);
617 | 		var columns = meta.indices.primary().columns();
618 | 		if (columns.length != ids.length) {
619 | 			throw new KidsException("ids length must match with primary columns");
620 | 		}
621 | 		var filters = new Filterable[ids.length];
622 | 		for (int i = 0; i < ids.length; i++) {
623 | 			filters[i] = Q.eq_(columns[i]);
624 | 		}
625 | 
626 | 		var empty = empty(clazz, ids);
627 | 		var q = Q.update().table(empty.table(), empty.suffix()).where(Q.and(filters));
628 | 		values.forEach((name, value) -> {
629 | 			var column = meta.fields.get(name);
630 | 			if (column == null || column.primary()) {
631 | 				return;
632 | 			}
633 | 			q.with_(column.name());
634 | 		});
635 | 		return q;
636 | 	}
637 | 
638 | 	public <T extends IEntity> boolean insert(T t) {
639 | 		var values = new LinkedHashMap<String, Object>();
640 | 		var meta = meta(t.getClass());
641 | 		Holder<Integer> lastInsertId = null;
642 | 		Field lastInsertField = null;
643 | 		for (var entry : meta.columns.entrySet()) {
644 | 			var column = entry.getValue();
645 | 			try {
646 | 				var field = column.field();
647 | 				var o = field.get(t);
648 | 				if (column.autoIncrement() && o == null) {
649 | 					lastInsertId = new Holder<Integer>();
650 | 					lastInsertField = column.field();
651 | 					continue;
652 | 				}
653 | 				values.put(field.getName(), o);
654 | 			} catch (Exception e) {
655 | 				throw new KidsException("access field errror", e);
656 | 			}
657 | 		}
658 | 		boolean res = insert(t, values, lastInsertId);
659 | 		if (res && lastInsertId != null && lastInsertId.value != null) {
660 | 			try {
661 | 				lastInsertField.set(t, lastInsertId.value);
662 | 			} catch (Exception e) {
663 | 				throw new KidsException("access field errror", e);
664 | 			}
665 | 		}
666 | 		return res;
667 | 	}
668 | 
669 | 	public <T extends IEntity> boolean insert(T t, Map<String, Object> values, Holder<Integer> lastInsertId) {
670 | 		var holder = new Holder<Boolean>();
671 | 		withinTx(conn -> {
672 | 			holder.value = insert(conn, t, values);
673 | 			if (lastInsertId != null) {
674 | 				var q = Q.select().field("last_insert_id()");
675 | 				this.any(conn, t.getClass(), q, stmt -> {
676 | 					ResultSet rs = stmt.executeQuery();
677 | 					if (rs.next()) {
678 | 						lastInsertId.value = rs.getInt(1);
679 | 					}
680 | 					return rs;
681 | 				});
682 | 			}
683 | 		});
684 | 		return holder.value;
685 | 	}
686 | 
687 | 	public <T extends IEntity> boolean insert(Connection conn, T t, Map<String, Object> values) {
688 | 		var meta = meta(t.getClass());
689 | 		var q = insertSQL(t, values);
690 | 		var paramsList = new ArrayList<>();
691 | 		for (var entry : meta.columns.entrySet()) {
692 | 			var name = meta.columns.get(entry.getKey()).field().getName();
693 | 			var value = values.get(name);
694 | 			if (value != null) {
695 | 				paramsList.add(value);
696 | 			}
697 | 		}
698 | 		var params = paramsList.toArray();
699 | 		var evt = Context.before(this, conn, t.getClass(), q, params);
700 | 		if (!this.invokeListeners(evt)) {
701 | 			return false;
702 | 		}
703 | 		long start = System.nanoTime();
704 | 		Exception error = null;
705 | 		try {
706 | 			withinPrepare(conn, q.sql(), stmt -> {
707 | 				for (var k = 0; k < params.length; k++) {
708 | 					stmt.setObject(k + 1, params[k]);
709 | 				}
710 | 				stmt.executeUpdate();
711 | 			});
712 | 		} catch (RuntimeException e) {
713 | 			error = e;
714 | 		}
715 | 		long duration = (System.nanoTime() - start) / 1000;
716 | 		this.invokeListeners(Context.after(this, conn, t.getClass(), q, params, error, duration));
717 | 		return true;
718 | 	}
719 | 
720 | 	private <T extends IEntity> Q insertSQL(T t, Map<String, Object> values) {
721 | 		var meta = meta(t.getClass());
722 | 		var q = Q.insert().table(t.table(), t.suffix());
723 | 		for (var entry : meta.columns.entrySet()) {
724 | 			var column = entry.getValue();
725 | 			var value = values.get(column.field().getName());
726 | 			if (value == null) {
727 | 				if (column.autoIncrement()) {
728 | 					continue;
729 | 				}
730 | 				if (column.nullable()) {
731 | 					continue;
732 | 				}
733 | 				if (!column.nullable() && column.defaultValue() != null && !column.defaultValue().isEmpty()) {
734 | 					continue;
735 | 				}
736 | 			}
737 | 			q.with_(entry.getKey());
738 | 		}
739 | 		return q;
740 | 	}
741 | 
742 | 	private Meta meta(Class<? extends IEntity> clazz) {
743 | 		var meta = metas.get(clazz);
744 | 		if (meta != null) {
745 | 			return meta;
746 | 		}
747 | 		var entity = empty(clazz);
748 | 		meta = new Meta();
749 | 		meta.name = entity.table();
750 | 		meta.options = entity.options();
751 | 		meta.indices = entity.indices();
752 | 		if (meta.indices.primary() == null) {
753 | 			throw new KidsException("entity class should provide primary index");
754 | 		}
755 | 		fillMeta(clazz, meta);
756 | 		for (String name : meta.indices.primary().columns()) {
757 | 			var column = meta.columns.get(name);
758 | 			column.primary(true);
759 | 		}
760 | 		for (var index : meta.indices.indices()) {
761 | 			var fields = new String[index.columns().length];
762 | 			var i = 0;
763 | 			for (var column : index.columns()) {
764 | 				fields[i++] = meta.columns.get(column).field().getName();
765 | 			}
766 | 			index.fields(fields);
767 | 		}
768 | 		metas.put(clazz, meta);
769 | 		return meta;
770 | 	}
771 | 
772 | 	private void fillMeta(Class<? extends IEntity> clazz, Meta meta) {
773 | 		for (Field field : clazz.getDeclaredFields()) {
774 | 			for (Annotation anno : field.getDeclaredAnnotations()) {
775 | 				if (anno instanceof E.Column) {
776 | 					if (field.getType().isPrimitive()) {
777 | 						throw new KidsException("column must not be primitive type");
778 | 					}
779 | 					var columnDef = (E.Column) anno;
780 | 					var column = new Column(columnDef.name().toLowerCase(), columnDef.type(), columnDef.autoincrement(),
781 | 							columnDef.nullable(), columnDef.defaultValue());
782 | 					column.field(field);
783 | 					field.setAccessible(true);
784 | 					meta.column(column);
785 | 					break;
786 | 				}
787 | 			}
788 | 		}
789 | 		if (meta.columns.isEmpty()) {
790 | 			throw new KidsException("entity class should provide at least one column");
791 | 		}
792 | 	}
793 | 
794 | }
795 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/E.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.lang.annotation.ElementType;
 4 | import java.lang.annotation.Retention;
 5 | import java.lang.annotation.RetentionPolicy;
 6 | import java.lang.annotation.Target;
 7 | import java.util.ArrayList;
 8 | import java.util.List;
 9 | 
10 | public class E {
11 | 
12 | 	@Retention(RetentionPolicy.RUNTIME)
13 | 	@Target({ ElementType.TYPE })
14 | 	public @interface Table {
15 | 	}
16 | 
17 | 	@Retention(RetentionPolicy.RUNTIME)
18 | 	@Target({ ElementType.FIELD })
19 | 	public @interface Column {
20 | 		String name();
21 | 
22 | 		String type();
23 | 
24 | 		boolean nullable() default true;
25 | 
26 | 		boolean autoincrement() default false;
27 | 
28 | 		String defaultValue() default "";
29 | 	}
30 | 
31 | 	public static class TableOptions {
32 | 		private List<Option> options = new ArrayList<>();
33 | 
34 | 		public TableOptions option(String key, String value) {
35 | 			this.options.add(new Option(key, value));
36 | 			return this;
37 | 		}
38 | 
39 | 		public List<Option> options() {
40 | 			return options;
41 | 		}
42 | 	}
43 | 
44 | 	public static class TableIndices {
45 | 		private List<Index> indices = new ArrayList<>();
46 | 		private Index primary;
47 | 
48 | 		public TableIndices unique(String... columns) {
49 | 			this.indices.add(new Index(false, true, columns));
50 | 			return this;
51 | 		}
52 | 
53 | 		public TableIndices primary(String... columns) {
54 | 			this.primary = new Index(true, false, columns);
55 | 			this.indices.add(primary);
56 | 			return this;
57 | 		}
58 | 
59 | 		public Index primary() {
60 | 			return primary;
61 | 		}
62 | 
63 | 		public TableIndices index(String... columns) {
64 | 			this.indices.add(new Index(false, false, columns));
65 | 			return this;
66 | 		}
67 | 
68 | 		public List<Index> indices() {
69 | 			return indices;
70 | 		}
71 | 	}
72 | 
73 | }
74 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/GridDB.java:
--------------------------------------------------------------------------------
  1 | package ormkids;
  2 | 
  3 | import java.util.HashMap;
  4 | import java.util.Map;
  5 | 
  6 | import ormkids.Context.IEventListener;
  7 | 
  8 | public abstract class GridDB<D extends DB> {
  9 | 
 10 | 	private D[] dbs;
 11 | 	private Map<Class<? extends IEntity>, IGridable<? extends IEntity>> gridables = new HashMap<>();
 12 | 
 13 | 	public GridDB(D[] dbs) {
 14 | 		this.dbs = dbs;
 15 | 	}
 16 | 
 17 | 	public int size() {
 18 | 		return dbs.length;
 19 | 	}
 20 | 
 21 | 	public <T extends IEntity> GridDB<D> gridWith(Class<T> clazz, IGridable<T> gridable) {
 22 | 		this.gridables.put(clazz, gridable);
 23 | 		return this;
 24 | 	}
 25 | 
 26 | 	public D selectIndex(int idx) {
 27 | 		return dbs[idx];
 28 | 	}
 29 | 
 30 | 	@SuppressWarnings("unchecked")
 31 | 	public <T extends IEntity> D select(T t) {
 32 | 		var gridable = (IGridable<T>) (gridables.get(t.getClass()));
 33 | 		int idx = gridable.select(dbs.length, t);
 34 | 		return dbs[idx];
 35 | 	}
 36 | 
 37 | 	@SuppressWarnings("unchecked")
 38 | 	public <T extends IEntity> D select(Class<T> clazz, Object... params) {
 39 | 		var gridable = (IGridable<T>) (gridables.get(clazz));
 40 | 		int idx = gridable.select(dbs.length, params);
 41 | 		return dbs[idx];
 42 | 	}
 43 | 
 44 | 	public GridDB<D> on(IEventListener listener) {
 45 | 		for (D db : dbs) {
 46 | 			db.on(listener);
 47 | 		}
 48 | 		return this;
 49 | 	}
 50 | 
 51 | 	public GridDB<D> off(IEventListener listener) {
 52 | 		for (D db : dbs) {
 53 | 			db.off(listener);
 54 | 		}
 55 | 		return this;
 56 | 	}
 57 | 
 58 | 	public GridDB<D> once(IEventListener listener) {
 59 | 		for (D db : dbs) {
 60 | 			db.scope(listener);
 61 | 		}
 62 | 		return this;
 63 | 	}
 64 | 
 65 | 	public void create(Class<? extends IEntity> clazz, String suffix) {
 66 | 		for (D db : dbs) {
 67 | 			db.create(clazz, suffix);
 68 | 		}
 69 | 	}
 70 | 
 71 | 	public void drop(Class<? extends IEntity> clazz, String suffix) {
 72 | 		for (D db : dbs) {
 73 | 			db.drop(clazz, suffix);
 74 | 		}
 75 | 	}
 76 | 
 77 | 	public void truncate(Class<? extends IEntity> clazz, String suffix) {
 78 | 		for (D db : dbs) {
 79 | 			db.truncate(clazz, suffix);
 80 | 		}
 81 | 	}
 82 | 
 83 | 	public <T extends IEntity> long count(Class<T> clazz, int dbIndex, String suffix) {
 84 | 		var db = selectIndex(dbIndex);
 85 | 		return db.count(clazz, suffix);
 86 | 	}
 87 | 
 88 | 	public <T extends IEntity> T get(Class<T> clazz, Object... ids) {
 89 | 		var db = select(clazz, ids);
 90 | 		return db.get(clazz, ids);
 91 | 	}
 92 | 
 93 | 	public <T extends IEntity> boolean insert(T t) {
 94 | 		var db = select(t);
 95 | 		return db.insert(t);
 96 | 	}
 97 | 
 98 | 	public <T extends IEntity> int update(T t) {
 99 | 		var db = select(t);
100 | 		return db.update(t);
101 | 	}
102 | 
103 | 	public <T extends IEntity> int delete(T t) {
104 | 		var db = select(t);
105 | 		return db.delete(t);
106 | 	}
107 | 
108 | 	public abstract void registerGridables();
109 | 
110 | }
111 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/IEntity.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import ormkids.E.TableIndices;
 4 | import ormkids.E.TableOptions;
 5 | 
 6 | /**
 7 |  * 所有的实体类必须实现该接口
 8 |  */
 9 | public interface IEntity {
10 | 
11 | 	/**
12 | 	 * @return 表名
13 | 	 */
14 | 	String table();
15 | 
16 | 	/**
17 | 	 * 分表必须覆盖此方法
18 | 	 * @return 分表后缀名
19 | 	 */
20 | 	default String suffix() {
21 | 		return null;
22 | 	}
23 | 
24 | 	default String tableWithSuffix() {
25 | 		return tableWith(suffix());
26 | 	}
27 | 
28 | 	default String tableWith(String suffix) {
29 | 		return Utils.tableWithSuffix(table(), suffix);
30 | 	}
31 | 	
32 | 	/**
33 | 	 * 定义表的物理结构属性如engine=innodb，用于动态创建表
34 | 	 * @return 表物理存储选项
35 | 	 */
36 | 	TableOptions options();
37 | 
38 | 	/**
39 | 	 * 定义表的主键和索引信息，用于动态创建表
40 | 	 * @return 表索引结构
41 | 	 */
42 | 	TableIndices indices();
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/IGridable.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | public interface IGridable<T extends IEntity> {
 4 | 
 5 | 	/**
 6 | 	 * 根据实体对象选择分库索引
 7 | 	 * @param dbs db num
 8 | 	 * @param t entity object
 9 | 	 * @return db index
10 | 	 */
11 | 	int select(int dbs, T t);
12 | 
13 | 	/**
14 | 	 * 根据特定参数选择分库索引
15 | 	 * @param dbs db num
16 | 	 * @param params sharding parameters
17 | 	 * @return db index
18 | 	 */
19 | 	int select(int dbs, Object... params);
20 | 
21 | }


--------------------------------------------------------------------------------
/src/main/java/ormkids/Index.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.util.StringJoiner;
 4 | 
 5 | public class Index {
 6 | 	private String[] columns;
 7 | 	private String[] fields;
 8 | 	private boolean primaryKey;
 9 | 	private boolean unique;
10 | 
11 | 	public Index(boolean primaryKey, boolean unique, String... columns) {
12 | 		this.primaryKey = primaryKey;
13 | 		this.unique = unique;
14 | 		this.columns = columns;
15 | 	}
16 | 
17 | 	public Index fields(String[] fields) {
18 | 		this.fields = fields;
19 | 		return this;
20 | 	}
21 | 
22 | 	public String s() {
23 | 		var joiner = new StringJoiner(", ");
24 | 		for (var column : columns) {
25 | 			joiner.add(String.format("`%s`", column));
26 | 		}
27 | 		if (primaryKey) {
28 | 			return String.format("primary key(%s)", joiner.toString());
29 | 		}
30 | 		if (unique) {
31 | 			return String.format("unique key(%s)", joiner.toString());
32 | 		}
33 | 		return String.format("key(%s)", joiner.toString());
34 | 	}
35 | 
36 | 	public String[] columns() {
37 | 		return columns;
38 | 	}
39 | 
40 | 	public String[] fields() {
41 | 		return fields;
42 | 	}
43 | 
44 | 	public boolean primaryKey() {
45 | 		return primaryKey;
46 | 	}
47 | 
48 | 	public boolean unique() {
49 | 		return unique;
50 | 	}
51 | }
52 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/KidsException.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | public class KidsException extends RuntimeException {
 4 | 
 5 | 	private static final long serialVersionUID = 1L;
 6 | 
 7 | 	public KidsException() {
 8 | 		super();
 9 | 	}
10 | 
11 | 	public KidsException(String message, Throwable cause) {
12 | 		super(message, cause);
13 | 	}
14 | 
15 | 	public KidsException(String message) {
16 | 		super(message);
17 | 	}
18 | 
19 | 	public KidsException(Throwable cause) {
20 | 		super(cause);
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/Meta.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.util.LinkedHashMap;
 4 | import java.util.Map;
 5 | 
 6 | import ormkids.E.TableIndices;
 7 | import ormkids.E.TableOptions;
 8 | 
 9 | public class Meta {
10 | 	String name;
11 | 	Map<String, Column> columns = new LinkedHashMap<>(); // column_name => Column case-insensitive
12 | 	Map<String, Column> fields = new LinkedHashMap<>(); // field_name => Column case-sensitive
13 | 	TableOptions options;
14 | 	TableIndices indices;
15 | 
16 | 	public Meta column(Column column) {
17 | 		if (this.columns.put(column.name(), column) != null) {
18 | 			throw new KidsException("duplicated column name " + column.name());
19 | 		}
20 | 		this.fields.put(column.field().getName(), column);
21 | 		return this;
22 | 	}
23 | }


--------------------------------------------------------------------------------
/src/main/java/ormkids/Option.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | public class Option {
 4 | 	private String key;
 5 | 	private String value;
 6 | 
 7 | 	public Option(String key, String value) {
 8 | 		this.key = key;
 9 | 		this.value = value;
10 | 	}
11 | 
12 | 	public String s() {
13 | 		return String.format("%s=%s", key, value);
14 | 	}
15 | 	
16 | 	public String key() {
17 | 		return key;
18 | 	}
19 | 	
20 | 	public String value() {
21 | 		return value;
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/Q.java:
--------------------------------------------------------------------------------
  1 | package ormkids;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.Arrays;
  5 | import java.util.Collection;
  6 | import java.util.List;
  7 | import java.util.StringJoiner;
  8 | 
  9 | public class Q {
 10 | 	static enum Type {
 11 | 		Select, Insert, Update, Delete, Create, Drop, Truncate
 12 | 	}
 13 | 
 14 | 	private Type type;
 15 | 
 16 | 	private List<String> fields = new ArrayList<>();
 17 | 	private String table;
 18 | 	private String suffix;
 19 | 	private Filterable filter;
 20 | 	private List<String> groupBys = new ArrayList<>();
 21 | 	private Filterable having;
 22 | 	private List<OrderBy> orderBys = new ArrayList<>();
 23 | 	private int offset;
 24 | 	private int limit;
 25 | 	private boolean offset_;
 26 | 	private boolean limit_;
 27 | 
 28 | 	private List<Setter> setters = new ArrayList<>();
 29 | 
 30 | 	private List<Column> columns = new ArrayList<>();
 31 | 	private List<Index> indices = new ArrayList<>();
 32 | 	private List<Option> options = new ArrayList<>();
 33 | 
 34 | 	private final static Placeholder __ = new Placeholder();
 35 | 
 36 | 	public static Q select() {
 37 | 		Q q = new Q();
 38 | 		q.type = Type.Select;
 39 | 		return q;
 40 | 	}
 41 | 
 42 | 	public static Q insert() {
 43 | 		Q q = new Q();
 44 | 		q.type = Type.Insert;
 45 | 		return q;
 46 | 	}
 47 | 
 48 | 	public static Q update() {
 49 | 		Q q = new Q();
 50 | 		q.type = Type.Update;
 51 | 		return q;
 52 | 	}
 53 | 
 54 | 	public static Q delete() {
 55 | 		Q q = new Q();
 56 | 		q.type = Type.Delete;
 57 | 		return q;
 58 | 	}
 59 | 
 60 | 	public static Q create() {
 61 | 		Q q = new Q();
 62 | 		q.type = Type.Create;
 63 | 		return q;
 64 | 	}
 65 | 
 66 | 	public static Q drop() {
 67 | 		Q q = new Q();
 68 | 		q.type = Type.Drop;
 69 | 		return q;
 70 | 	}
 71 | 
 72 | 	public static Q truncate() {
 73 | 		Q q = new Q();
 74 | 		q.type = Type.Truncate;
 75 | 		return q;
 76 | 	}
 77 | 
 78 | 	public String sql() {
 79 | 		switch (type) {
 80 | 		case Create:
 81 | 			return createSQL();
 82 | 		case Drop:
 83 | 			return dropSQL();
 84 | 		case Truncate:
 85 | 			return truncateSQL();
 86 | 		case Select:
 87 | 			return selectSQL();
 88 | 		case Insert:
 89 | 			return insertSQL();
 90 | 		case Update:
 91 | 			return updateSQL();
 92 | 		case Delete:
 93 | 			return deleteSQL();
 94 | 		default:
 95 | 			return null;
 96 | 		}
 97 | 	}
 98 | 
 99 | 	public Q field(String... fs) {
100 | 		for (String f : fs) {
101 | 			this.fields.add(f);
102 | 		}
103 | 		return this;
104 | 	}
105 | 
106 | 	public Q table(String table) {
107 | 		this.table = table;
108 | 		return this;
109 | 	}
110 | 
111 | 	public Q table(String table, String suffix) {
112 | 		this.table = table;
113 | 		this.suffix = suffix;
114 | 		return this;
115 | 	}
116 | 
117 | 	public Q suffix(String suffix) {
118 | 		this.suffix = suffix;
119 | 		return this;
120 | 	}
121 | 
122 | 	public String table() {
123 | 		return table;
124 | 	}
125 | 
126 | 	public String suffix() {
127 | 		return suffix;
128 | 	}
129 | 
130 | 	public String tableWithSuffix() {
131 | 		return Utils.tableWithSuffix(table, suffix);
132 | 	}
133 | 
134 | 	public Q groupBy(String... fs) {
135 | 		for (String f : fs) {
136 | 			this.groupBys.add(f);
137 | 		}
138 | 		return this;
139 | 	}
140 | 
141 | 	public Q where(Filterable filter) {
142 | 		this.filter = filter;
143 | 		return this;
144 | 	}
145 | 
146 | 	public Q having(Filterable filter) {
147 | 		this.having = filter;
148 | 		return this;
149 | 	}
150 | 
151 | 	public Q orderBy(String name) {
152 | 		this.orderBys.add(new OrderBy(name));
153 | 		return this;
154 | 	}
155 | 
156 | 	public Q orderBy(String name, String direction) {
157 | 		this.orderBys.add(new OrderBy(name, direction));
158 | 		return this;
159 | 	}
160 | 
161 | 	public Q offset(int offset) {
162 | 		this.offset = offset;
163 | 		return this;
164 | 	}
165 | 
166 | 	public Q offset_() {
167 | 		this.offset_ = true;
168 | 		return this;
169 | 	}
170 | 
171 | 	public Q limit(int limit) {
172 | 		this.limit = limit;
173 | 		return this;
174 | 	}
175 | 
176 | 	public Q limit_() {
177 | 		this.limit_ = true;
178 | 		return this;
179 | 	}
180 | 
181 | 	public Q with(String name, Object value) {
182 | 		this.setters.add(new Setter(name, primitive(value)));
183 | 		return this;
184 | 	}
185 | 
186 | 	public Q with_(String name) {
187 | 		this.setters.add(new Setter(name, __));
188 | 		return this;
189 | 	}
190 | 
191 | 	public static And and(Filterable... filters) {
192 | 		return new And(filters);
193 | 	}
194 | 
195 | 	public static Or or(Filterable... filters) {
196 | 		return new Or(filters);
197 | 	}
198 | 
199 | 	public static Comparator eq(String name, Object o) {
200 | 		return new Comparator(name, "=", primitive(o));
201 | 	}
202 | 
203 | 	public static Comparator eq_(String name) {
204 | 		return new Comparator(name, "=", __);
205 | 	}
206 | 
207 | 	public static Comparator ne(String name, Object o) {
208 | 		return new Comparator(name, "!=", primitive(o));
209 | 	}
210 | 
211 | 	public static Comparator ne_(String name) {
212 | 		return new Comparator(name, "!=", __);
213 | 	}
214 | 
215 | 	public static Comparator lt(String name, Object o) {
216 | 		return new Comparator(name, "<", primitive(o));
217 | 	}
218 | 
219 | 	public static Comparator lt_(String name) {
220 | 		return new Comparator(name, "<", __);
221 | 	}
222 | 
223 | 	public static Comparator le(String name, Object o) {
224 | 		return new Comparator(name, "<=", primitive(o));
225 | 	}
226 | 
227 | 	public static Comparator le_(String name) {
228 | 		return new Comparator(name, "<=", __);
229 | 	}
230 | 
231 | 	public static Comparator gt(String name, Object o) {
232 | 		return new Comparator(name, ">", primitive(o));
233 | 	}
234 | 
235 | 	public static Comparator gt_(String name) {
236 | 		return new Comparator(name, ">", __);
237 | 	}
238 | 
239 | 	public static Comparator ge(String name, Object o) {
240 | 		return new Comparator(name, ">=", primitive(o));
241 | 	}
242 | 
243 | 	public static Comparator ge_(String name) {
244 | 		return new Comparator(name, ">=", __);
245 | 	}
246 | 
247 | 	public static Between between(String name, Object min, Object max) {
248 | 		return new Between(name, primitive(min), primitive(max));
249 | 	}
250 | 
251 | 	public static Between between_(String name) {
252 | 		return new Between(name, __, __);
253 | 	}
254 | 
255 | 	public static In in(String name, Object... os) {
256 | 		return new In(name, set(os));
257 | 	}
258 | 
259 | 	public static In in_(String name, int includes) {
260 | 		var sets = set();
261 | 		for (int i = 0; i < includes; i++) {
262 | 			sets.values.add(__);
263 | 		}
264 | 		return new In(name, sets);
265 | 	}
266 | 
267 | 	public static In in(String name, Collection<Object> os) {
268 | 		return new In(name, set(os));
269 | 	}
270 | 
271 | 	public static In in(String name, SubQuery subQ) {
272 | 		return new In(name, subQ);
273 | 	}
274 | 
275 | 	public static NotIn notin(String name, Object... os) {
276 | 		return new NotIn(name, set(os));
277 | 	}
278 | 
279 | 	public static NotIn notin_(String name, int includes) {
280 | 		var sets = set();
281 | 		for (int i = 0; i < includes; i++) {
282 | 			sets.values.add(__);
283 | 		}
284 | 		return new NotIn(name, sets);
285 | 	}
286 | 
287 | 	public static NotIn notin(String name, Collection<Object> os) {
288 | 		return new NotIn(name, set(os));
289 | 	}
290 | 
291 | 	public static NotIn notin(String name, SubQuery subQ) {
292 | 		return new NotIn(name, subQ);
293 | 	}
294 | 
295 | 	public static Not not(Filterable filter) {
296 | 		return new Not(filter);
297 | 	}
298 | 
299 | 	public static Placeholder placeholder() {
300 | 		return new Placeholder();
301 | 	}
302 | 
303 | 	public static Primitive primitive(Object o) {
304 | 		return new Primitive(o);
305 | 	}
306 | 
307 | 	public static PrimitiveCollection set(Object... os) {
308 | 		var values = new ArrayList<Value>();
309 | 		for (Object o : os) {
310 | 			values.add(primitive(o));
311 | 		}
312 | 		return new PrimitiveCollection(values);
313 | 	}
314 | 
315 | 	public static PrimitiveCollection set(Collection<Object> os) {
316 | 		var values = new ArrayList<Value>();
317 | 		for (Object o : os) {
318 | 			values.add(primitive(o));
319 | 		}
320 | 		return new PrimitiveCollection(values);
321 | 	}
322 | 
323 | 	public static SubQuery subQuery(Q q) {
324 | 		return new SubQuery(q);
325 | 	}
326 | 
327 | 	@Override
328 | 	public String toString() {
329 | 		if (this.type == Type.Select) {
330 | 			return this.selectSQL();
331 | 		} else if (this.type == Type.Insert) {
332 | 			return this.insertSQL();
333 | 		} else if (this.type == Type.Update) {
334 | 			return this.updateSQL();
335 | 		} else if (this.type == Type.Delete) {
336 | 			return this.deleteSQL();
337 | 		} else if (this.type == Type.Create) {
338 | 			return this.createSQL();
339 | 		} else if (this.type == Type.Drop) {
340 | 			return this.dropSQL();
341 | 		} else if (this.type == Type.Truncate) {
342 | 			return this.truncateSQL();
343 | 		}
344 | 		throw new IllegalArgumentException("sql not supported yet");
345 | 	}
346 | 
347 | 	public String selectSQL() {
348 | 		var builder = new StringBuilder();
349 | 		builder.append("select ");
350 | 		for (var i = 0; i < fields.size(); i++) {
351 | 			builder.append(fields.get(i));
352 | 			if (i < fields.size() - 1) {
353 | 				builder.append(", ");
354 | 			}
355 | 		}
356 | 		if (this.table != null) {
357 | 			builder.append(" from ");
358 | 			builder.append(String.format("`%s`", tableWithSuffix()));
359 | 		}
360 | 		if (this.filter != null) {
361 | 			builder.append(" where ");
362 | 			builder.append(this.filter.s(0));
363 | 		}
364 | 		if (!this.groupBys.isEmpty()) {
365 | 			builder.append(" group by ");
366 | 			StringJoiner joiner = new StringJoiner(", ");
367 | 			for (String by : groupBys) {
368 | 				joiner.add(by);
369 | 			}
370 | 			builder.append(joiner.toString());
371 | 		}
372 | 		if (this.having != null) {
373 | 			builder.append(" having ");
374 | 			builder.append(this.having.s(0));
375 | 		}
376 | 		if (!this.orderBys.isEmpty()) {
377 | 			builder.append(" order by ");
378 | 			StringJoiner joiner = new StringJoiner(", ");
379 | 			for (var by : orderBys) {
380 | 				joiner.add(by.s());
381 | 			}
382 | 			builder.append(joiner.toString());
383 | 		}
384 | 		if (this.offset_) {
385 | 			builder.append(" offset ?");
386 | 		} else if (this.offset > 0) {
387 | 			builder.append(" offset ");
388 | 			builder.append(this.offset);
389 | 		}
390 | 		if (this.limit_) {
391 | 			builder.append(" limit ?");
392 | 		} else if (this.limit > 0) {
393 | 			builder.append(" limit ");
394 | 			builder.append(this.limit);
395 | 		}
396 | 		return builder.toString();
397 | 	}
398 | 
399 | 	public String updateSQL() {
400 | 		var builder = new StringBuilder();
401 | 		builder.append("update ");
402 | 		builder.append(String.format("`%s`", tableWithSuffix()));
403 | 		builder.append(" set ");
404 | 		StringJoiner joiner = new StringJoiner(", ");
405 | 		for (var setter : setters) {
406 | 			joiner.add(setter.s());
407 | 		}
408 | 		builder.append(joiner.toString());
409 | 		if (this.filter != null) {
410 | 			builder.append(" where ");
411 | 			builder.append(this.filter.s(0));
412 | 		}
413 | 		return builder.toString();
414 | 	}
415 | 
416 | 	public String insertSQL() {
417 | 		var builder = new StringBuilder();
418 | 		builder.append("insert into ");
419 | 		builder.append(String.format("`%s`", tableWithSuffix()));
420 | 		builder.append("(");
421 | 		var joiner = new StringJoiner(", ");
422 | 		for (var setter : setters) {
423 | 			joiner.add(setter.name);
424 | 		}
425 | 		builder.append(joiner.toString());
426 | 		builder.append(") values(");
427 | 		joiner = new StringJoiner(", ");
428 | 		for (var setter : setters) {
429 | 			joiner.add(setter.value.value());
430 | 		}
431 | 		builder.append(joiner.toString());
432 | 		builder.append(")");
433 | 		return builder.toString();
434 | 	}
435 | 
436 | 	public String deleteSQL() {
437 | 		var builder = new StringBuilder();
438 | 		if (this.filter == null) {
439 | 			builder.append("delete * from ");
440 | 			builder.append(String.format("`%s`", tableWithSuffix()));
441 | 		} else {
442 | 			builder.append("delete from ");
443 | 			builder.append(String.format("`%s`", tableWithSuffix()));
444 | 			builder.append(" where ");
445 | 			builder.append(this.filter.s(0));
446 | 		}
447 | 
448 | 		return builder.toString();
449 | 	}
450 | 
451 | 	public String createSQL() {
452 | 		var builder = new StringBuilder();
453 | 		builder.append(String.format("create table if not exists `%s`(", tableWithSuffix()));
454 | 		var joiner = new StringJoiner(", ");
455 | 		for (var column : columns) {
456 | 			joiner.add(column.s());
457 | 		}
458 | 		for (var index : indices) {
459 | 			joiner.add(index.s());
460 | 		}
461 | 		builder.append(joiner.toString());
462 | 		builder.append(")");
463 | 		if (!options.isEmpty()) {
464 | 			builder.append(" ");
465 | 			joiner = new StringJoiner(" ");
466 | 			for (var option : options) {
467 | 				joiner.add(String.format("%s=%s", option.key(), option.value()));
468 | 			}
469 | 			builder.append(joiner.toString());
470 | 		}
471 | 		return builder.toString();
472 | 	}
473 | 
474 | 	public String dropSQL() {
475 | 		return String.format("drop table if exists `%s`", tableWithSuffix());
476 | 	}
477 | 
478 | 	public String truncateSQL() {
479 | 		return String.format("truncate table `%s`", tableWithSuffix());
480 | 	}
481 | 
482 | 	@FunctionalInterface
483 | 	public static interface Filterable {
484 | 		String s(int depth);
485 | 	}
486 | 
487 | 	static class And implements Filterable {
488 | 		private List<Filterable> filters = new ArrayList<>();
489 | 
490 | 		public And(Filterable... filters) {
491 | 			for (Filterable filter : filters) {
492 | 				this.filters.add(filter);
493 | 			}
494 | 		}
495 | 
496 | 		public And then(Filterable... filters) {
497 | 			for (Filterable filter : filters) {
498 | 				this.filters.add(filter);
499 | 			}
500 | 			return this;
501 | 		}
502 | 
503 | 		@Override
504 | 		public String s(int depth) {
505 | 			var joiner = new StringJoiner(" and ");
506 | 			for (var filter : filters) {
507 | 				joiner.add(filter.s(depth + 1));
508 | 			}
509 | 			if (filters.size() == 1 || depth == 0) {
510 | 				return joiner.toString();
511 | 			}
512 | 			return String.format("(%s)", joiner.toString());
513 | 		}
514 | 
515 | 	}
516 | 
517 | 	static class Or implements Filterable {
518 | 		private List<Filterable> filters = new ArrayList<>();
519 | 
520 | 		public Or(Filterable... filters) {
521 | 			for (Filterable filter : filters) {
522 | 				this.filters.add(filter);
523 | 			}
524 | 		}
525 | 
526 | 		public Or then(Filterable... filters) {
527 | 			for (Filterable filter : filters) {
528 | 				this.filters.add(filter);
529 | 			}
530 | 			return this;
531 | 		}
532 | 
533 | 		@Override
534 | 		public String s(int depth) {
535 | 			var joiner = new StringJoiner(" or ");
536 | 			for (var filter : filters) {
537 | 				joiner.add(filter.s(depth + 1));
538 | 			}
539 | 			if (filters.size() == 1 || depth == 0) {
540 | 				return joiner.toString();
541 | 			}
542 | 			return String.format("(%s)", joiner.toString());
543 | 		}
544 | 
545 | 	}
546 | 
547 | 	static class Comparator implements Filterable {
548 | 		private String field;
549 | 		private String op;
550 | 		private Value value;
551 | 
552 | 		public Comparator(String field, String op, Value value) {
553 | 			this.field = field;
554 | 			this.op = op;
555 | 			this.value = value;
556 | 		}
557 | 
558 | 		@Override
559 | 		public String s(int depth) {
560 | 			return String.format("`%s` %s %s", field, op, value.value());
561 | 		}
562 | 
563 | 	}
564 | 
565 | 	static class Between implements Filterable {
566 | 		private String name;
567 | 		private Value min, max;
568 | 
569 | 		public Between(String name, Value min, Value max) {
570 | 			this.name = name;
571 | 			this.min = min;
572 | 			this.max = max;
573 | 		}
574 | 
575 | 		@Override
576 | 		public String s(int depth) {
577 | 			return String.format("`%s` between %s and %s", name, min.value(), max.value());
578 | 		}
579 | 	}
580 | 
581 | 	static class In implements Filterable {
582 | 		private String name;
583 | 		private Value value;
584 | 
585 | 		public In(String name, Value value) {
586 | 			this.name = name;
587 | 			this.value = value;
588 | 		}
589 | 
590 | 		@Override
591 | 		public String s(int depth) {
592 | 			return String.format("`%s` in %s", name, value.value());
593 | 		}
594 | 
595 | 	}
596 | 
597 | 	static class NotIn implements Filterable {
598 | 		private String name;
599 | 		private Value value;
600 | 
601 | 		public NotIn(String name, Value value) {
602 | 			this.name = name;
603 | 			this.value = value;
604 | 		}
605 | 
606 | 		@Override
607 | 		public String s(int depth) {
608 | 			return String.format("`%s` not in %s", name, value.value());
609 | 		}
610 | 
611 | 	}
612 | 
613 | 	static class Not implements Filterable {
614 | 		private Filterable filter;
615 | 
616 | 		public Not(Filterable filter) {
617 | 			this.filter = filter;
618 | 		}
619 | 
620 | 		@Override
621 | 		public String s(int depth) {
622 | 			return String.format("not %s", filter.s(depth + 1));
623 | 		}
624 | 
625 | 	}
626 | 
627 | 	@FunctionalInterface
628 | 	public static interface Value {
629 | 		String value();
630 | 	}
631 | 
632 | 	static class Placeholder implements Value {
633 | 
634 | 		@Override
635 | 		public String value() {
636 | 			return "?";
637 | 		}
638 | 
639 | 	}
640 | 
641 | 	static class Primitive implements Value {
642 | 		private Object v;
643 | 
644 | 		public Primitive(Object v) {
645 | 			this.v = v;
646 | 		}
647 | 
648 | 		@Override
649 | 		public String value() {
650 | 			if (v == null) {
651 | 				return "null";
652 | 			}
653 | 			if (v instanceof String) {
654 | 				return String.format("'%s'", v);
655 | 			}
656 | 			return v.toString();
657 | 		}
658 | 
659 | 	}
660 | 
661 | 	static class PrimitiveCollection implements Value {
662 | 		private List<Value> values;
663 | 
664 | 		public PrimitiveCollection(List<Value> values) {
665 | 			this.values = values;
666 | 		}
667 | 
668 | 		public PrimitiveCollection(Value... values) {
669 | 			this.values = Arrays.asList(values);
670 | 		}
671 | 
672 | 		@Override
673 | 		public String value() {
674 | 			var builder = new StringBuilder();
675 | 			builder.append("(");
676 | 			var joiner = new StringJoiner(", ");
677 | 			for (var value : values) {
678 | 				joiner.add(value.toString());
679 | 			}
680 | 			builder.append(joiner.toString());
681 | 			builder.append(")");
682 | 			return builder.toString();
683 | 		}
684 | 	}
685 | 
686 | 	static class SubQuery implements Value {
687 | 		private Q q;
688 | 
689 | 		public SubQuery(Q q) {
690 | 			this.q = q;
691 | 		}
692 | 
693 | 		@Override
694 | 		public String value() {
695 | 			return String.format("(%s)", q);
696 | 		}
697 | 
698 | 	}
699 | 
700 | 	static class OrderBy {
701 | 		private String name;
702 | 		private String direction;
703 | 
704 | 		public OrderBy(String name) {
705 | 			this.name = name;
706 | 		}
707 | 
708 | 		public OrderBy(String name, String direction) {
709 | 			this.name = name;
710 | 			this.direction = direction.toLowerCase();
711 | 		}
712 | 
713 | 		public String s() {
714 | 			if (direction == null) {
715 | 				return name;
716 | 			}
717 | 			return String.format("`%s` %s", name, direction);
718 | 		}
719 | 	}
720 | 
721 | 	static class Setter {
722 | 		private String name;
723 | 		private Value value;
724 | 
725 | 		public Setter(String name, Value value) {
726 | 			this.name = name;
727 | 			this.value = value;
728 | 		}
729 | 
730 | 		public String s() {
731 | 			return String.format("`%s` = %s", name, value.value());
732 | 		}
733 | 	}
734 | 
735 | 	public Q option(String key, String value) {
736 | 		this.options.add(new Option(key, value));
737 | 		return this;
738 | 	}
739 | 
740 | 	public Q index(String... columns) {
741 | 		return index(false, false, columns);
742 | 	}
743 | 
744 | 	public Q uniqueIndex(String... columns) {
745 | 		return index(false, true, columns);
746 | 	}
747 | 
748 | 	public Q primaryIndex(String... columns) {
749 | 		return index(true, false, columns);
750 | 	}
751 | 
752 | 	public Q index(boolean primaryKey, boolean unique, String... columns) {
753 | 		this.indices.add(new Index(primaryKey, unique, columns));
754 | 		return this;
755 | 	}
756 | 
757 | 	public Q column(String name, String type) {
758 | 		return column(name, type, false, true, null);
759 | 	}
760 | 
761 | 	public Q column(String name, String type, boolean autoIncrement, boolean nullable, String defaultValue) {
762 | 		this.columns.add(new Column(name, type, autoIncrement, nullable, defaultValue));
763 | 		return this;
764 | 	}
765 | 
766 | }
767 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/Utils.java:
--------------------------------------------------------------------------------
 1 | package ormkids;
 2 | 
 3 | import java.nio.charset.Charset;
 4 | 
 5 | public class Utils {
 6 | 	
 7 | 	public static Charset UTF8 = Charset.forName("utf8");
 8 | 
 9 | 	public static String tableWithSuffix(String table, String suffix) {
10 | 		if (suffix == null) {
11 | 			return table;
12 | 		}
13 | 		return table + "_" + suffix;
14 | 	}
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/BookShelf.java:
--------------------------------------------------------------------------------
  1 | package ormkids.demo;
  2 | 
  3 | import java.util.Date;
  4 | import java.util.zip.CRC32;
  5 | 
  6 | import ormkids.E.Column;
  7 | import ormkids.E.Table;
  8 | import ormkids.E.TableIndices;
  9 | import ormkids.E.TableOptions;
 10 | import ormkids.IEntity;
 11 | import ormkids.IGridable;
 12 | import ormkids.Utils;
 13 | 
 14 | @Table
 15 | public class BookShelf implements IEntity {
 16 | 
 17 | 	public final static int PARTITIONS = 4;
 18 | 
 19 | 	@Column(name = "user_id", type = "varchar(255)", nullable = false)
 20 | 	private String userId;
 21 | 	@Column(name = "book_id", type = "varchar(255)", nullable = false)
 22 | 	private String bookId;
 23 | 	@Column(name = "comment", type = "varchar(255)")
 24 | 	private String comment;
 25 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
 26 | 	private Date createdAt;
 27 | 
 28 | 	public BookShelf() {
 29 | 	}
 30 | 
 31 | 	public BookShelf(String userId, String bookId, String comment, Date createdAt) {
 32 | 		this.userId = userId;
 33 | 		this.bookId = bookId;
 34 | 		this.comment = comment;
 35 | 		this.createdAt = createdAt;
 36 | 	}
 37 | 
 38 | 	public String getUserId() {
 39 | 		return userId;
 40 | 	}
 41 | 
 42 | 	public String getBookId() {
 43 | 		return bookId;
 44 | 	}
 45 | 
 46 | 	public void setComment(String comment) {
 47 | 		this.comment = comment;
 48 | 	}
 49 | 
 50 | 	public String getComment() {
 51 | 		return comment;
 52 | 	}
 53 | 
 54 | 	public Date getCreatedAt() {
 55 | 		return createdAt;
 56 | 	}
 57 | 
 58 | 	@Override
 59 | 	public String table() {
 60 | 		return "book_shelf";
 61 | 	}
 62 | 
 63 | 	@Override
 64 | 	public TableOptions options() {
 65 | 		return new TableOptions().option("engine", "innodb");
 66 | 	}
 67 | 
 68 | 	@Override
 69 | 	public TableIndices indices() {
 70 | 		return new TableIndices().primary("user_id", "book_id");
 71 | 	}
 72 | 
 73 | 	/* 
 74 | 	 * 分表策略
 75 | 	 */
 76 | 	@Override
 77 | 	public String suffix() {
 78 | 		var crc32 = new CRC32();
 79 | 		crc32.update(userId.getBytes(Utils.UTF8));
 80 | 		return String.valueOf(Math.abs(crc32.getValue()) % PARTITIONS);
 81 | 	}
 82 | 
 83 | 	/**
 84 | 	 * 分库策略
 85 | 	 */
 86 | 	public static class GridStrategy implements IGridable<BookShelf> {
 87 | 
 88 | 		@Override
 89 | 		public int select(int dbs, BookShelf t) {
 90 | 			return Math.abs(t.getUserId().hashCode()) % dbs;
 91 | 		}
 92 | 
 93 | 		@Override
 94 | 		public int select(int dbs, Object... params) {
 95 | 			String userId = (String) params[0];
 96 | 			return Math.abs(userId.hashCode()) % dbs;
 97 | 		}
 98 | 
 99 | 	}
100 | 
101 | }
102 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoComplexQuery.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.sql.ResultSet;
 4 | import java.util.LinkedHashMap;
 5 | import java.util.Random;
 6 | 
 7 | import ormkids.Q;
 8 | 
 9 | public class DemoComplexQuery {
10 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
11 | 
12 | 	public static void main(String[] args) {
13 | 		var db = new DemoDB("demo", URI);
14 | 		try {
15 | 			db.create(Exam.class); // 建表
16 | 			var random = new Random();
17 | 			for (var i = 0; i < 100; i++) {
18 | 				var userId = Math.abs(random.nextLong());
19 | 				var exam = new Exam(userId, random.nextInt(100), random.nextInt(100), random.nextInt(100),
20 | 						random.nextInt(100), random.nextInt(100), random.nextInt(100));
21 | 				db.insert(exam); // 插入
22 | 			}
23 | 			System.out.println(db.count(Exam.class)); // 查询总行数
24 | 			// math >= 50
25 | 			var exams = db.find(Exam.class, Q.ge_("math"), 50); // 条件查询
26 | 			System.out.println(exams.size());
27 | 			var count = db.count(Exam.class, Q.ge_("math"), 50); // 条件总行数
28 | 			System.out.println(count);
29 | 			// math > 50 & english >= 50
30 | 			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件查询
31 | 			System.out.println(exams.size());
32 | 			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件总行数
33 | 			System.out.println(count);
34 | 			// math > 50 || english >= 50
35 | 			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件查询
36 | 			System.out.println(exams.size());
37 | 			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 条件总行数
38 | 			System.out.println(count);
39 | 			// math > 50 && (english >= 50 || chinese > 60)
40 | 			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 条件查询
41 | 			System.out.println(exams.size());
42 | 			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 条件总行数
43 | 			System.out.println(count);
44 | 			// math > 50 || physics between 60 and 80 || chemistry < 60
45 | 			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80, 60); // 条件查询
46 | 			System.out.println(exams.size());
47 | 			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80,
48 | 					60); // 条件总行数
49 | 			System.out.println(count);
50 | 			// group by math / 10
51 | 			var q = Q.select().field("(math div 10) * 10 as mathx", "count(1)").table("exam").groupBy("mathx")
52 | 					.having(Q.gt_("count(1)")).orderBy("count(1)", "desc"); // 复杂sql构造
53 | 			var rank = new LinkedHashMap<Integer, Integer>();
54 | 			db.any(Exam.class, q, stmt -> { // 原生sql查询
55 | 				stmt.setInt(1, 0);
56 | 				ResultSet rs = stmt.executeQuery();
57 | 				while (rs.next()) {
58 | 					rank.put(rs.getInt(1), rs.getInt(2));
59 | 				}
60 | 				return rs;
61 | 			});
62 | 			rank.forEach((mathx, c) -> {
63 | 				System.out.printf("[%d-%d) = %d\n", mathx, mathx + 10, c);
64 | 			});
65 | 		} finally {
66 | 			db.drop(Exam.class);
67 | 		}
68 | 	}
69 | 
70 | }
71 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoCompoundPk.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.Date;
 4 | import java.util.HashMap;
 5 | 
 6 | import ormkids.Q;
 7 | 
 8 | public class DemoCompoundPk {
 9 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
10 | 
11 | 	public static void main(String[] args) {
12 | 		var db = new DemoDB("demo", URI);
13 | 		try {
14 | 			db.create(Member.class);  // 建表
15 | 			var member = new Member(1, 2, "boss", null);
16 | 			db.insert(member); // 插入
17 | 			member = db.get(Member.class, 1, 2); // 主键查询
18 | 			System.out.println(member.getTitle());
19 | 			member = new Member(2, 2, "manager", new Date());
20 | 			db.insert(member); // 再插入
21 | 			var count = db.count(Member.class);  // 获取总行数 
22 | 			System.out.println(count);
23 | 			var members = db.find(Member.class); // 获取全部行
24 | 			for (var m : members) {
25 | 				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
26 | 			}
27 | 			member = new Member(2, 3, "manager", new Date());
28 | 			db.insert(member); // 再插入
29 | 			members = db.find(Member.class, Q.eq_("group_id"), 2);  // 条件查询
30 | 			for (var m : members) {
31 | 				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
32 | 			}
33 | 			var setters = new HashMap<String, Object>();
34 | 			setters.put("title", "employee");
35 | 			db.update(Member.class, setters, 2, 3); // 修改
36 | 			member = db.get(Member.class, 2, 3); // 主键查询
37 | 			System.out.println(member.getTitle());
38 | 			db.delete(Member.class, 1, 2); // 删除
39 | 			db.delete(Member.class, 2, 2); // 删除
40 | 			db.delete(Member.class, 2, 3); // 删除
41 | 			count = db.count(Member.class); // 再获取总行数
42 | 			System.out.println(count);
43 | 		} finally {
44 | 			db.drop(Member.class); // 删表
45 | 		}
46 | 	}
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoDB.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.sql.Connection;
 4 | import java.sql.SQLException;
 5 | import java.util.HashMap;
 6 | import java.util.Map;
 7 | 
 8 | import javax.sql.DataSource;
 9 | 
10 | import com.mysql.cj.jdbc.MysqlConnectionPoolDataSource;
11 | 
12 | import ormkids.KidsException;
13 | import ormkids.DB;
14 | import ormkids.IEntity;
15 | import ormkids.Meta;
16 | 
17 | public class DemoDB extends DB {
18 | 
19 | 	private DataSource ds;
20 | 
21 | 	public DemoDB(String name, String uri) {
22 | 		this(name, new HashMap<>(), uri);
23 | 	}
24 | 
25 | 	public DemoDB(String name, Map<Class<? extends IEntity>, Meta> metas, String uri) {
26 | 		super(name, metas);
27 | 		var ds = new MysqlConnectionPoolDataSource();
28 | 		ds.setUrl(uri);
29 | 		this.ds = ds;
30 | 	}
31 | 
32 | 	@Override
33 | 	protected Connection conn() {
34 | 		try {
35 | 			return ds.getConnection();
36 | 		} catch (SQLException e) {
37 | 			throw new KidsException(e);
38 | 		}
39 | 	}
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoEvent.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | public class DemoEvent {
 4 | 
 5 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		var db = new DemoDB("demo", URI);
 9 | 		db.on(ctx -> { // 全局事件回调
10 | 			System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
11 | 			return true; // 返回false会导致事件链终止，后续的ORM操作也不会执行
12 | 		});
13 | 		try {
14 | 			db.create(User.class);
15 | 			db.scope(ctx -> { // 范围回调，execute方法内部的所有ORM操作都会回调
16 | 				System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
17 | 				return true;
18 | 			}).execute(() -> {
19 | 				db.count(User.class);
20 | 				db.find(User.class);
21 | 			});
22 | 		} finally {
23 | 			db.drop(User.class); // 删除表
24 | 		}
25 | 	}
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoPartitioning.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Date;
 5 | import java.util.Random;
 6 | 
 7 | public class DemoPartitioning {
 8 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
 9 | 
10 | 	public static void main(String[] args) {
11 | 		var db = new DemoDB("demo", URI);
12 | 		try {
13 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
14 | 				db.create(BookShelf.class, String.valueOf(i)); // 创建所有分表
15 | 			}
16 | 			var bss = new ArrayList<BookShelf>();
17 | 			for (int i = 0; i < 100; i++) {
18 | 				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
19 | 				bss.add(bs);
20 | 				db.insert(bs); // 插入，自动插入相应分表
21 | 			}
22 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
23 | 				System.out.printf("partition %d count %d\n", i, db.count(BookShelf.class, String.valueOf(i)));
24 | 			}
25 | 			Random random = new Random();
26 | 			for (var bs : bss) {
27 | 				bs.setComment("comment_update_" + random.nextInt(100));
28 | 				db.update(bs); // 更新，自动更新相应分表数据
29 | 			}
30 | 			bss = new ArrayList<BookShelf>();
31 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
32 | 				bss.addAll(db.find(BookShelf.class, String.valueOf(i))); // 指定分表列出所有行
33 | 			}
34 | 			for (var bs : bss) {
35 | 				System.out.println(bs.getComment());
36 | 			}
37 | 			for (var bs : bss) {
38 | 				db.delete(bs); // 挨个删除，自动删除相应分表数据
39 | 			}
40 | 		} finally {
41 | 			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
42 | 				db.drop(BookShelf.class, String.valueOf(i)); // 删除所有分表
43 | 			}
44 | 		}
45 | 	}
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoSharding.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Date;
 5 | import java.util.HashMap;
 6 | import java.util.Map;
 7 | import java.util.Random;
 8 | 
 9 | import ormkids.IEntity;
10 | import ormkids.Meta;
11 | 
12 | public class DemoSharding {
13 | 
14 | 	private static DemoDB[] dbs = new DemoDB[3];
15 | 	static {
16 | 		Map<Class<? extends IEntity>, Meta> metas = new HashMap<>();
17 | 		dbs[0] = new DemoDB("demo-0", metas,
18 | 				"jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
19 | 		dbs[1] = new DemoDB("demo-1", metas,
20 | 				"jdbc:mysql://localhost:3307/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
21 | 		dbs[2] = new DemoDB("demo-2", metas,
22 | 				"jdbc:mysql://localhost:3308/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
23 | 	}
24 | 
25 | 	public static void main(String[] args) {
26 | 		var grid = new GridDemoDB(dbs); // 构造Grid实例
27 | 		try {
28 | 			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
29 | 				grid.create(BookShelf.class, String.valueOf(k)); // 创建所有分库中的分表
30 | 			}
31 | 			var bss = new ArrayList<BookShelf>();
32 | 			for (int i = 0; i < 100; i++) {
33 | 				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
34 | 				bss.add(bs);
35 | 				grid.insert(bs); // 插入，自动分发到相应的分库中的分表
36 | 			}
37 | 			for (int k = 0; k < grid.size(); k++) {
38 | 				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
39 | 					System.out.printf("db %d partition %d count %d\n", k, i,
40 | 							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查询出所有分库的分表的行数
41 | 				}
42 | 			}
43 | 			Random random = new Random();
44 | 			for (var bs : bss) {
45 | 				bs.setComment("comment_update_" + random.nextInt(100));
46 | 				grid.update(bs); // 更新，自动分发到相应的分库中的分表
47 | 			}
48 | 			for (var bs : bss) {
49 | 				bs = grid.get(BookShelf.class, bs.getUserId(), bs.getBookId()); // 主键查询，自动分发到相应的分库中的分表
50 | 				System.out.println(bs.getComment());
51 | 			}
52 | 			for (var bs : bss) {
53 | 				grid.delete(bs); // 删除，自动分发到相应的分库中的分表
54 | 			}
55 | 			for (int k = 0; k < grid.size(); k++) {
56 | 				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
57 | 					System.out.printf("db %d partition %d count %d\n", k, i,
58 | 							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查询出所有分库的分表的行数
59 | 				}
60 | 			}
61 | 		} finally {
62 | 			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
63 | 				grid.drop(BookShelf.class, String.valueOf(k)); // 删除所有分库中的分表
64 | 			}
65 | 		}
66 | 	}
67 | 
68 | }
69 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/DemoSimplePk.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.HashMap;
 4 | 
 5 | import ormkids.Q;
 6 | 
 7 | public class DemoSimplePk {
 8 | 
 9 | 	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";
10 | 
11 | 	public static void main(String[] args) {
12 | 		var db = new DemoDB("demo", URI);
13 | 		try {
14 | 			db.create(User.class); // 创建表
15 | 			var user = new User("test1", "nick1", "passwd1");
16 | 			db.insert(user); // 插入
17 | 			System.out.println(user.getId());
18 | 			user = db.get(User.class, user.getId());  // 主键查询
19 | 			System.out.printf("%s %s %s %s %s\n", user.getId(), user.getName(), user.getNick(), user.getPasswd(),
20 | 					user.getCreatedAt());
21 | 			user = new User("test2", "nick2", "passwd2");
22 | 			db.insert(user); // 再插入
23 | 			var count = db.count(User.class); // 查询总行数
24 | 			System.out.println(count);
25 | 			var users = db.find(User.class);  // 列出所有行
26 | 			System.out.println(users.size());
27 | 			for (var u : users) {
28 | 				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
29 | 						u.getCreatedAt());
30 | 			}
31 | 			users = db.find(User.class, Q.eq_("nick"), "nick2"); // 条件查询
32 | 			System.out.println(users.size());
33 | 			var setters = new HashMap<String, Object>();
34 | 			setters.put("passwd", "whatever");
35 | 			db.update(User.class, setters, 2); // 修改
36 | 			users = db.find(User.class); // 再列出所有行
37 | 			System.out.println(users.size());
38 | 			for (var u : users) {
39 | 				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
40 | 						u.getCreatedAt());
41 | 			}
42 | 			db.delete(User.class, 1); // 删除
43 | 			db.delete(User.class, 2); // 再删除
44 | 			count = db.count(User.class); // 统计所有行
45 | 			System.out.println(count);
46 | 		} finally {
47 | 			db.drop(User.class); // 删除表
48 | 		}
49 | 	}
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/Exam.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import ormkids.E.Column;
 4 | import ormkids.E.Table;
 5 | import ormkids.E.TableIndices;
 6 | import ormkids.E.TableOptions;
 7 | import ormkids.IEntity;
 8 | 
 9 | @Table
10 | public class Exam implements IEntity {
11 | 
12 | 	@Column(name = "user_id", type = "bigint", nullable = false)
13 | 	private Long userId;
14 | 	@Column(name = "math", type = "int")
15 | 	private Integer math;
16 | 	@Column(name = "english", type = "int")
17 | 	private Integer english;
18 | 	@Column(name = "chinese", type = "int")
19 | 	private Integer chinese;
20 | 	@Column(name = "physics", type = "int")
21 | 	private Integer physics;
22 | 	@Column(name = "chemistry", type = "int")
23 | 	private Integer chemistry;
24 | 	@Column(name = "biology", type = "int")
25 | 	private Integer biology;
26 | 
27 | 	public Exam() {
28 | 	}
29 | 
30 | 	public Exam(long userId, int math, int english, int chinese, int physics, int chemistry, int biology) {
31 | 		this.userId = userId;
32 | 		this.math = math;
33 | 		this.english = english;
34 | 		this.chinese = chinese;
35 | 		this.physics = physics;
36 | 		this.chemistry = chemistry;
37 | 		this.biology = biology;
38 | 	}
39 | 
40 | 	public long getUserId() {
41 | 		return userId;
42 | 	}
43 | 
44 | 	public int getMath() {
45 | 		return math;
46 | 	}
47 | 
48 | 	public int getEnglish() {
49 | 		return english;
50 | 	}
51 | 
52 | 	public int getChinese() {
53 | 		return chinese;
54 | 	}
55 | 
56 | 	public int getPhysics() {
57 | 		return physics;
58 | 	}
59 | 
60 | 	public int getChemistry() {
61 | 		return chemistry;
62 | 	}
63 | 
64 | 	public int getBiology() {
65 | 		return biology;
66 | 	}
67 | 
68 | 	@Override
69 | 	public TableOptions options() {
70 | 		return new TableOptions().option("engine", "innodb");
71 | 	}
72 | 
73 | 	@Override
74 | 	public TableIndices indices() {
75 | 		return new TableIndices().primary("user_id");
76 | 	}
77 | 
78 | 	@Override
79 | 	public String table() {
80 | 		return "exam";
81 | 	}
82 | 
83 | }
84 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/GridDemoDB.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import ormkids.GridDB;
 4 | 
 5 | public class GridDemoDB extends GridDB<DemoDB> {
 6 | 
 7 | 	/**
 8 | 	 * 传进来多个DB对象
 9 | 	 * @param dbs db objects
10 | 	 */
11 | 	public GridDemoDB(DemoDB[] dbs) {
12 | 		super(dbs);
13 | 		this.registerGridables();
14 | 	}
15 | 
16 | 	/*
17 | 	 * 注册实体类的分库策略
18 | 	 */
19 | 	@Override
20 | 	public void registerGridables() {
21 | 		this.gridWith(BookShelf.class, new BookShelf.GridStrategy());
22 | 	}
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/Member.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.Date;
 4 | 
 5 | import ormkids.IEntity;
 6 | import ormkids.E.Column;
 7 | import ormkids.E.Table;
 8 | import ormkids.E.TableIndices;
 9 | import ormkids.E.TableOptions;
10 | 
11 | @Table
12 | public class Member implements IEntity {
13 | 
14 | 	@Column(name = "user_id", type = "int", nullable = false)
15 | 	private Integer userId;
16 | 	@Column(name = "group_id", type = "int", nullable = false)
17 | 	private Integer groupId;
18 | 	@Column(name = "title", type = "varchar(255)")
19 | 	private String title;
20 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
21 | 	private Date createdAt;
22 | 
23 | 	public Member() {
24 | 	}
25 | 
26 | 	public Member(Integer userId, Integer groupId, String title, Date createdAt) {
27 | 		this.userId = userId;
28 | 		this.groupId = groupId;
29 | 		this.title = title;
30 | 		this.createdAt = createdAt;
31 | 	}
32 | 
33 | 	public Integer getUserId() {
34 | 		return userId;
35 | 	}
36 | 
37 | 	public Integer getGroupId() {
38 | 		return groupId;
39 | 	}
40 | 
41 | 	public String getTitle() {
42 | 		return title;
43 | 	}
44 | 
45 | 	public Date getCreatedAt() {
46 | 		return createdAt;
47 | 	}
48 | 
49 | 	@Override
50 | 	public TableOptions options() {
51 | 		return new TableOptions().option("engine", "innodb");
52 | 	}
53 | 
54 | 	@Override
55 | 	public TableIndices indices() {
56 | 		return new TableIndices().primary("user_id", "group_id");
57 | 	}
58 | 
59 | 	@Override
60 | 	public String table() {
61 | 		return "member";
62 | 	}
63 | 
64 | }
65 | 


--------------------------------------------------------------------------------
/src/main/java/ormkids/demo/User.java:
--------------------------------------------------------------------------------
 1 | package ormkids.demo;
 2 | 
 3 | import java.util.Date;
 4 | 
 5 | import ormkids.IEntity;
 6 | import ormkids.E.Column;
 7 | import ormkids.E.Table;
 8 | import ormkids.E.TableIndices;
 9 | import ormkids.E.TableOptions;
10 | 
11 | @Table
12 | public class User implements IEntity {
13 | 
14 | 	@Column(name = "id", type = "int", autoincrement = true, nullable = false)
15 | 	private Integer id;
16 | 	@Column(name = "name", type = "varchar(255)", nullable = false)
17 | 	private String name;
18 | 	@Column(name = "nick", type = "varchar(255)", nullable = false)
19 | 	private String nick;
20 | 	@Column(name = "passwd", type = "varchar(255)")
21 | 	private String passwd;
22 | 	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
23 | 	private Date createdAt;
24 | 
25 | 	public User() {
26 | 	}
27 | 
28 | 	public User(String name, String nick, String passwd) {
29 | 		this.name = name;
30 | 		this.nick = nick;
31 | 		this.passwd = passwd;
32 | 	}
33 | 
34 | 	public Integer getId() {
35 | 		return id;
36 | 	}
37 | 
38 | 	public String getName() {
39 | 		return name;
40 | 	}
41 | 
42 | 	public String getNick() {
43 | 		return nick;
44 | 	}
45 | 
46 | 	public String getPasswd() {
47 | 		return passwd;
48 | 	}
49 | 
50 | 	public Date getCreatedAt() {
51 | 		return createdAt;
52 | 	}
53 | 
54 | 	@Override
55 | 	public TableOptions options() {
56 | 		return new TableOptions().option("engine", "innodb");
57 | 	}
58 | 
59 | 	@Override
60 | 	public TableIndices indices() {
61 | 		return new TableIndices().primary("id").unique("name");
62 | 	}
63 | 
64 | 	@Override
65 | 	public String table() {
66 | 		return "user";
67 | 	}
68 | 
69 | }
70 | 


--------------------------------------------------------------------------------
/src/main/resources/log4j.properties:
--------------------------------------------------------------------------------
1 | log4j.rootLogger=DEBUG, stdout
2 | 
3 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender
4 | log4j.appender.stdout.Threshold=DEBUG 
5 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
6 | log4j.appender.stdout.layout.ConversionPattern=%d{yyy-MM-dd HH:mm:ss} [%t] %-5p %c{1} %M %L %x - %m%n


--------------------------------------------------------------------------------