BeetlSql 單表查詢工具（Query）使用說明

本文轉自BeetlSQL開發者 Gavin-King的博客

在實際應用場景中大部分時候是在針對單表進行操做，單獨的寫一條單表操做的SQL較爲繁瑣，爲了能進行高效、快捷、優雅的進行單表操做，Query查詢器誕生了。

Query使用方式和風格介紹

咱們以一個 User表爲例，查詢模糊查詢用戶名包含 "t" ，而且delete_time 不爲空的數據庫，按照id 倒序。

Query<User> query = sqlManager.query(User.class);
List<User> list = query.andLike("name", "%t%")
	.andIsNotNull("delete_time")
	.orderBy("id desc").select();

從上面的例子能夠看出，Query是使用鏈式調用，看起來就像一個完整的sql通常，使用方式聽從用戶平時SQL編寫習慣，因此用戶在使用過程當中需遵循SQL格式。 全部的條件列完以後，再調用select（要執行的方法：select，insert，update，count 等等）；

這裏有的同窗能夠看出來，直接使用數據庫字段，這樣不妥啊！要是重構怎麼辦。雖然大部分時候創建的數據庫字段不會重命名，BeetlSql 仍是支持列名重構，代碼以下：

List<User> list1  = sql.query(User.class).lamdba()
	.andEq(User::getName, "hi")
	.orderBy(User::getCreateDate)
	.select();

使用LamdbaQuery 必須使用Java8，且引入了對jaque庫依賴，maven引入下面的包

<dependency>
  <groupId>com.trigersoft</groupId>
  <artifactId>jaque</artifactId>
  <version>2.1.2</version>
  <scope>provided</scope>
</dependency>

爲了方便，下面的例子都採用數據庫字段的形式進行，示例數據庫爲MySql；

Query主要操做簡介

Query接口分爲倆類：

一部分是觸發查詢和更新操做，api分別是

• select 觸發查詢，返回指定的對象列表
• single 觸發查詢，返回一個對象，若是沒有，返回null
• unique 觸發查詢，返回一個對象，若是沒有，或者有多個，拋出異常
• count 對查詢結果集求總數
• delete 刪除符合條件的結果集
• update 所有字段更新，包括更新null值
• updateSelective 更新選中的結果集（null不更新）
• insert 所有字段插入，包括插入null值
• insertSelective 有選擇的插入，null不插入

另一部分是各類條件：

標準sql操做符	and操做	or操做
==,!=	andEq,andNotEq	orEq,orNotEq
>,>=	andGreat,andGreatEq	orGreat,orGreatEq
<,<=	andLess,andLessEq	orLess,orLessEq
LIKE,NOT LIKE	andLike,andNotLike	orLike,orNotLike
IS NULL,IS NOT NULL	andIsNull,andIsNotNull	orIsNull,orIsNotNull
	andIn ,andNotIn	orIn ,orNotIn
BETWEEN ,NOT BETWEEN	andBetween,andNotBetween	orBetween,orNotBetween
and ( .....)	and	or

標準sql	Query方法
限制結果結範圍，依賴於不一樣數據庫翻頁	limit
ORDER BY	orderBY
GROUP BY	groupBy
HAVING	having

---

查詢器獲取

查詢器直接經過 sqlManager 獲取，多個sqlManager 能夠獲取各自 的Query。 獲取查詢器時，咱們泛型一下咱們是針對哪一個對象（對應的哪張表）進行的操做。

Query<User> query = sqlManager.query(User.class);

SELECT簡單的條件查詢

咱們仍是以User爲例，咱們須要查詢這條SQL

SELECT * FROM `user` WHERE `id` BETWEEN 1 AND 1640 AND `name` LIKE '%t%' AND `create_time` IS NOT NULL ORDER BY id desc

直接上代碼：

Query<User> query = sqlManager.query(User.class);
List<User> list = query.andBetween("id", 1, 1640)
	.andLike("name", "%t%")
	.andIsNotNull("create_time")
	.orderBy("id desc").select();

是否是感受和寫SQL同樣爽。

若是咱們只要查詢其中的幾個字段怎麼辦？好比我只要name和id字段，SQL以下：

SELECT name,id FROM `user`

Query也提供了定製字段的方法，只要傳入你須要的字段名便可：

Query<User> query = sqlManager.query(User.class);
List<User> list = query.select("name", "id");

好比時間比較大小：

SELECT name,id FROM `user` WHERE `id` = 1637 AND `create_time` < now() AND `name` = 'test'

Query<User> query = sqlManager.query(User.class);
List<User> list = query.andEq("id", 1637)
	.andLess("create_time", new Date())
	.andEq("name", "test")
	.select("name", "id");

有的同窗會說，OR子句怎麼用，和AND同樣簡單：

SELECT * FROM `user` WHERE `name` = 'new name' OR `id` = 1637 limit 0 , 10

query.andEq("name", "new name")
	.orEq("id", 1637)
	.limit(1, 10)
	.select();

爲了兼容其餘數據庫，這裏limit都是統一從1開始哦，後面也會提到。

複雜的條件查詢

下面就開始進階了，要進行一條複雜的條件查詢SQL，就要用到 query.condition() 方法，產生一個新的條件，好比咱們要查詢下面這條SQL

SQL：SELECT * FROM `user` WHERE ( `id` IN( ? , ? , ? ) AND `name` LIKE ? )OR ( `id` = ? )
參數：[1637, 1639, 1640, %t%, 1640]

Query<User> query = sqlManager.query(User.class);
List<User> list = query
	.or(query.condition()
		.andIn("id", Arrays.asList(1637, 1639, 1640))
    	.andLike("name", "%t%"))
	.or(query.condition().andEq("id", 1640))
	.select();

複雜的條件查詢，只須要調用 or() 方法 和 and()方法 ，而後使用 query.condition()生成一個新的條件傳入就行； 好比下面這條SQL

SQL：SELECT * FROM `user` WHERE ( `id` IN( ? , ? , ? ) AND `name` LIKE ? )AND `id` = ? OR ( `name` = ? )
參數：[1637, 1639, 1640, %t%, 1640, new name2]

Query<User> query = sqlManager.query(User.class);
List<User> list = query
	.and(query.condition()
	.andIn("id", Arrays.asList(1637, 1639, 1640))
	.andLike("name", "%t%"))
	.andEq("id", 1640)
	.or(query.condition().andEq("name","new name2"))
    .select();

INSERT操做

學會條件查詢以後，其餘操做就簡單了，咱們看下insert。

全量插入insert 方法

SQL：insert into `user` (`name`,`department_id`,`create_time`) VALUES (?,?,?)
參數：[new name, null, null]

User record = new User();
	record.setName("new name");
	Query<User> query = sqlManager.query(User.class);
	int count = query.insert(record);

全量插入，會對全部的值進行插入，即便這個值是NULL；返回影響的行數；

選擇插入insertSelective方法

SQL： insert into `user` ( `name`,`create_time` ) VALUES ( ?,? )
參數：[new name2, now()]

User record = new User();
record.setName("new name2");
record.setCreateTime(new Date());
Query<User> query = sqlManager.query(User.class);
int count = query.insertSelective(record);

insertSelective方法，對user進行了一次有選擇性的插入。NULL值的字段不插入；返回影響的行數；

UPDATE操做

update和insert相似,有全量更新和選擇更新的方法；

全量更新 update 方法

SQL：update `user` set `name`=?,`department_id`=?,`create_time`=? WHERE `id` = ? AND `create_time` < ? AND `name` = ? 
參數：[new name, null, null, 1637, now(), test]

User record = new User();
record.setName("new name");
Query<User> query = sqlManager.query(User.class);
int count = query.andEq("id", 1637)
	.andLess("create_time", new Date())
	.andEq("name", "test")
	.update(record);

全量更新，會對全部的值進行更新，即便這個值是NULL；返回影響的行數；

選擇更新 updateSelective 方法

SQL：update `user` set `name`=? WHERE `id` = ? AND `create_time` < ? AND `name` = ? 
參數：[new name, 1637, now(), test]

User record = new User();
record.setName("new name");
Query<User> query = sqlManager.query(User.class);
int count = query.andEq("id", 1637)
	.andLess("create_time", new Date())
	.andEq("name", "test")
	.updateSelective(record);

updateSelective方法，對user進行了一次有選擇性的更新。不是null的值都更新，NULL值不更新；返回影響的行數；

DELETE操做

delete操做很是簡單，拼接好條件，調用delete方法便可；返回影響的行數。

DELETE FROM `user` WHERE `id` = ?

Query<User> query = sqlManager.query(User.class);
int count = query.andEq("id", 1642).delete();

single查詢和unique

在beetlSql中還提供了兩個用來查詢單條數據的方法，single和unique；

single單條查詢

single查詢，查詢出一條，若是沒有，返回null；

SELECT * FROM `user` WHERE `id` = 1642 limit 0 , 1

Query<User> query = sqlManager.query(User.class);
User user = query.andEq("id", 1642).single();

unique單條查詢

unique查詢和single稍微不一樣，他是查詢一條，若是沒有或者有多條，拋異常；

SELECT * FROM `user` WHERE `id` = 1642 limit 0 , 2

Query<User> query = sqlManager.query(User.class);
User user = query.andEq("id", 1642).unique();

若是存在多條，或者沒有則拋出異常：

org.beetl.sql.core.BeetlSQLException: unique查詢，但數據庫未找到結果集

COUNT查詢

count查詢主要用於統計行數，以下面的SQL：

SQL：	 SELECT COUNT(1) FROM `user` WHERE `name` = ? OR `id` = ? limit 0 , 10
參數：	 [new name, 1637]

Query<User> query = sqlManager.query(User.class);
long count = query.andEq("name", "new name")
             .orEq("id", 1637).limit(1, 10)
             .count();

拼接條件，調用count方法，返回總行數。

GROUP分組查詢和Having子句

有時候咱們要進行分組查詢，如如下SQL：

SELECT * FROM `user` WHERE `id` IN(1637, 1639, 1640 ) GROUP BY name

在BeetlSql中直接拼條件調用group方法，傳入字段便可：

Query<User> query = sqlManager.query(User.class);
List<User> list = query
	.andIn("id", Arrays.asList(1637, 1639, 1640))
 	.groupBy("name")
	.select();

在分組查詢以後，咱們可能還要進行having篩選，只須要在後面調用having方法，傳入條件便可。

SELECT * FROM `user` WHERE `id` IN( 1637, 1639, 1640 ) GROUP BY name HAVING `create_time` IS NOT NULL

Query<User> query = sqlManager.query(User.class);
List<User> list = query
	.andIn("id", Arrays.asList(1637, 1639, 1640))
	.groupBy("name")
	.having(query.condition().andIsNotNull("create_time"))
	.select();

分頁查詢

分頁查詢是咱們常常要使用的功能，beetlSql支持多數據，會自動適配當前數據庫生成分頁語句，在beeltSql中調用limit方法進行分頁。以下面的SQL：

SQL： SELECT * FROM `user` WHERE `name` = ? OR `id` = ? limit 0 , 10
參數： [new name, 1637]

User record = new User();
record.setName("new name");
Query<User> query = sqlManager.query(User.class);
long count = query.andEq("name", "new name")
	.orEq("id", 1637)
	.limit(1, 10)
	.select();

這裏須要注意，limit方法傳入的參數是開始行，和查詢的行數。（開始行從1開始計數），beetlSql會根據不一樣的數據生成相應的SQL語句。

ORDER BY 排序

進行排序查詢時，只要調用orderBy方法，傳入要排序的字段以及排序方式便可。

SQL： SELECT * FROM `user` WHERE `id` BETWEEN ? AND ? AND `name` LIKE ? AND `create_time` IS NOT NULL ORDER BY id desc 
參數： [1, 1640, %t%]

Query<User> query = sqlManager.query(User.class);
List<User> list = query.andBetween("id", 1, 1640)
	.andLike("name", "%t%")
	.andIsNotNull("create_time")
	.orderBy("id desc").select();