├── .gitignore ├── LICENSE ├── README.md ├── README.zh.md ├── data └── sqlite.db ├── pom.xml └── src ├── main └── java │ └── io │ └── vertx │ └── ext │ └── sql │ └── assist │ ├── CommonSQL.java │ ├── CommonSQLClinet.java │ ├── SQLCommand.java │ ├── SQLCommandImpl.java │ ├── SQLExecute.java │ ├── SQLExecuteBase.java │ ├── SQLExecuteImplDB2.java │ ├── SQLExecuteImplJDBC.java │ ├── SQLExecuteImplMySQL.java │ ├── SQLExecuteImplPg.java │ ├── SQLStatement.java │ ├── SqlAndParams.java │ ├── SqlAssist.java │ ├── SqlLimitResult.java │ ├── SqlPropertyValue.java │ ├── SqlWhereCondition.java │ ├── Table.java │ ├── TableColumn.java │ ├── TableId.java │ └── sql │ ├── AbstractStatementSQL.java │ ├── DB2StatementSQL.java │ ├── MySQLStatementSQL.java │ ├── OracleStatementSQL.java │ ├── PostgreSQLStatementSQL.java │ ├── SQLiteStatementSQL.java │ └── SqlServerStatementSQL.java └── test ├── java └── io │ └── vertx │ └── ext │ └── sql │ └── assist │ ├── JdbcPoolTest.java │ ├── MySQLPoolTest.java │ ├── TestSuite.java │ ├── entity │ ├── Classes.java │ └── Student.java │ └── sql │ ├── ClassesSQL.java │ ├── JsonObjectSQL.java │ └── StudentSQL.java └── resources └── vertx-default-jul-logging.properties /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled class file 2 | *.class 3 | 4 | # Log file 5 | *.log 6 | 7 | # BlueJ files 8 | *.ctxt 9 | 10 | # Mobile Tools for Java (J2ME) 11 | .mtj.tmp/ 12 | 13 | # Package Files # 14 | *.jar 15 | *.war 16 | *.nar 17 | *.ear 18 | *.zip 19 | *.tar.gz 20 | *.rar 21 | 22 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 23 | hs_err_pid* 24 | /.settings/ 25 | /.classpath 26 | /.project 27 | /target/ 28 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 MirrenTools 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # vertx-sql-assist 2 | Read this in other languages: [English](./README.md), [简体中文](./README.zh.md). 3 | 4 | vertx-sql-assist is the SQL operation help tool of [Vert.x](https://vertx.io/), which provides the support of insert, delete, update, query, join, paging query, cooperate with SqlAssist help class, it basically does not need to write a line of SQL code. 5 | 6 | We recommend that you use [ScrewDriver](https://github.com/MirrenTools/screw-driver) to generate code, so you will find the world very beautiful! 7 | ## Dependencies 8 | To use vertx-sql-assist, add the following dependency to the dependencies section of your build descriptor 9 | 10 | ``` XML 11 | 12 | org.mirrentools 13 | vertx-sql-assist 14 | RELEASE 15 | 16 | ``` 17 | ## SQL class method description 18 | * **getCount** Get the total number of data rows 19 | * **selectAll** Query multiple rows of data 20 | * **limitAll** Paging query 21 | * **selectById** Query data by ID 22 | * **selectByObj** Query data by attributes that are not empty in the object 23 | * **selectSingleByObj** Query the first row of data returned by data withdrawal through the attribute not empty in the object 24 | * **insertBatch** Batch add insert 25 | * **insertAll** Insert an object including a value with a null property value 26 | * **insertNonEmpty** Insert an object, only the property whose value is not null 27 | * **insertNonEmptyGeneratedKeys** Insert an object, only the property whose value is not null,and get result id 28 | * **replace** Insert an object. If the object does not exist, create a new one. If the object already exists, update it 29 | * **updateAllById** Update all properties in an object, including null value, if it is the primary key value in the object 30 | * **updateAllByAssist** Update all properties in an object including null value, by SqlAssist 31 | * **updateNonEmptyById** Update a non null value of a property in an object, by ID 32 | * **updateNonEmptyByAssist** Update a non null value of a property in an object, by SqlAssist 33 | * **updateSetNullById** Set the column to null by ID 34 | * **updateSetNullByAssist** Set the column to null by SqlAssist 35 | * **deleteById** Delete by ID 36 | * **deleteByAssist** Delete by SqlAssist 37 | * **queryAsObj** Execution query result is JsonObject 38 | * **queryAsList** Execution query result is List 39 | * **update** Execution update result is number of affected rows 40 | * **updateResult** Execution update and get result 41 | * **batch** Batch Execution 42 | * **execute** Pool Execution 43 | 44 | ## SqlAssist method description 45 | * **setOrders** Set OrderBy with SqlAssist.order(column,mode) 46 | * **setGroupBy** Set GroupBy 47 | * **setHaving** Set Having 48 | * **setDistincts** Set distinct or not, true De duplicate 49 | * **setPage** Set the page number. The value is only valid in the limitAll method , finally will be converted to startRow 50 | * **setStartRow** Set data start row 51 | * **setRowSize** Set how many rows of data to get 52 | * **setResultColumn** Set to return column, Multiple columns are separated by , 53 | * **setJoinOrReference** Set join query or multi table query statement 54 | * **and** Add and condition 55 | * **or** Add or condition 56 | * **andEq** Add and equal condition 57 | * **orEq** Add or equal condition 58 | * **andNeq** Add and not equal condition 59 | * **orNeq** Add or not equal condition 60 | * **andLt** Add and less than condition 61 | * **orLt** Add or less than condition 62 | * **andLte** Add and less than or equal to condition 63 | * **orLte** Add or less than or equal to condition 64 | * **andGt** Add and greater than condition 65 | * **orGt** Add or greater than condition 66 | * **andGte** Add and greater than or equal to condition 67 | * **orGte** Add or greater than or equal to condition 68 | * **andLike** Add and like condition 69 | * **orLike** Add or like condition 70 | * **andNotLike** Add and not like condition 71 | * **orNotLike** Add or not like condition 72 | * **andIsNull** Add and is null condition 73 | * **orIsNull** Add or is null condition 74 | * **andIsNotNull** Add and is not null condition 75 | * **orIsNotNull** Add or is not null condition 76 | * **setConditions** Add query condition 77 | * **customCondition** Add custom query condition 78 | 79 | ## SqlAssist Use example 80 | [Example project](https://github.com/shenzhenMirren/vertx-sql-assist-examples) 81 | 82 | ``` java 83 | // (1)Create SqlAssist 84 | SqlAssist assist = new SqlAssist(); 85 | // (2)Add condition type=1 or 3,equivalent to SQL: where type=1 or type=3 86 | assist.orEq("type", 1).orEq("type", 3); 87 | // (3)Eliminating duplicate data ,equivalent to SQL: select distinct ... 88 | assist.setDistincts(true); 89 | // (4)Custom return column only [id,type,name,seq] 90 | assist.setResultColumn("id,type,name,seq"); 91 | // (5)order by seq desc 92 | assist.setOrders(SqlAssist.order("seq", false)); 93 | // (6)To get the data of lines 20-35 in the database, you can also use setpage (page number) to get the data by page,equivalent to SQL: limit 20,15 94 | assist.setStartRow(20).setRowSize(15); 95 | // (7)Execute get data 96 | Future future=Promise.promise().future(); 97 | future.setHandler(//Processed results); 98 | itemsSQL.selectAll(assist,future); 99 | ``` 100 | For more help, see the method notes for SqlAssist class 101 | 102 | 103 | ## How use it? 104 | 105 | **Example** 106 | 107 | 1.Create entity class 108 | 109 | ``` java 110 | @Table("table name") 111 | public class User { 112 | @TableId("primary key") 113 | private Long id; 114 | @TableColumn("column name") 115 | private String name; 116 | @TableColumn(value = "column name", alias = "column name,is not required") 117 | private Integer type; 118 | //Other necessary 119 | } 120 | ``` 121 | 2.Create SQL class and extends CommonSQL 122 | 123 | ``` java 124 | public class UserSQL extends CommonSQL {//(1) 125 | public UserSQL(SQLExecute execute) { 126 | super(execute); 127 | } 128 | //(1) 129 | //The User must be an entity class annotation with @Table, @TableId, @TableColumn,Or rewrite a SQLStatement that implements the table name, ID, and returns the column to pass to CommonSQL 130 | //JDBCPool can be another database client 131 | //Override other methods 132 | } 133 | ``` 134 | 3.Execute 135 | 136 | ``` java 137 | public static void main(String[] args) { 138 | // Other necessary 139 | UserSQL userSQL = new UserSQL(SQLExecute.createJDBC(JDBCPool)); 140 | // Query Example 141 | // Create SqlAssist 142 | SqlAssist assist = new SqlAssist(); 143 | assist.setStartRow(0).setRowSize(15); 144 | assist.andEq("type", 1); 145 | assist.setOrders(SqlAssist.order("id", true)); 146 | // Execution query 147 | userSQL.selectAll(assist,res->{ 148 | if (res.succeeded()) { 149 | System.out.println(res.result()); 150 | }else { 151 | System.err.println(res.cause()); 152 | } 153 | }); 154 | //Save Example 155 | User user =new User(); 156 | user.setId(1001L); 157 | user.setName("org.mirrentools"); 158 | user.setType(1); 159 | userSQL.insertNonEmpty(user,res->{//Processed results}); 160 | 161 | } 162 | ``` 163 | ## common setting 164 | **Set different database SQL statements** SQL statement uses MySQL standard statement by default,You can set different database SQL statements through SQLStatement,support : MySQL、PostgreSQL、Oracle、DB2、SQL Server、SQLite,For example, if you set it to Oracle, you can: 165 | ``` java 166 | SQLStatement.register(OracleStatementSQL.class); 167 | ``` 168 | **Set limit data return result name** The default value of data return result name is:totals=Total data rows,pages=Total data pages ,page=Current page number,size=How many rows of data are displayed per page,data=Result data,If you want to change the data result name to something else, you can: 169 | ``` java 170 | SqlLimitResult.registerResultKey("totals", "counts"); 171 | ``` 172 | -------------------------------------------------------------------------------- /README.zh.md: -------------------------------------------------------------------------------- 1 | # vertx-sql-assist 2 | 其他语言版本: [English](./README.md), [简体中文](./README.zh.md). 3 | 4 | vertx-sql-assist是 [Vert.x](https://vertx.io/) 的SQL操作帮助工具,它提供了增删改查、连接、分页等支持,配合SqlAssist帮助类自己基本不用写一行SQL代码。 5 | 6 | 我们推荐你使用 [ScrewDriver](https://github.com/MirrenTools/screw-driver) 来生成代码,这样你会发现世界非常美好! 7 | ## 添加依赖 8 | ``` XML 9 | 10 | org.mirrentools 11 | vertx-sql-assist 12 | RELEASE 13 | 14 | ``` 15 | ## SQL类方法说明 16 | * **getCount** 获取数据总行数 17 | * **selectAll** 查询多行数据 18 | * **limitAll** 分页查询 19 | * **selectById** 通过id查询数据 20 | * **selectByObj** 通过对象中不为空的属性查询数据 21 | * **selectSingleByObj** 通过对象中不为空的属性查询数据只取返回的第一行数据 22 | * **insertBatch** 批量添加插入对象 23 | * **insertAll** 插入一个对象包括属性值为null的值 24 | * **insertNonEmpty** 插入一个对象,只插入对象中值不为null的属性 25 | * **insertNonEmptyGeneratedKeys** 插入一个对象,只插入对象中值不为null的属性,并返回自增的id 26 | * **replace** 插入一个对象,如果该对象不存在就新建如果该对象已经存在就更新 27 | * **updateAllById** 更新一个对象中所有的属性包括null值,条件为对象中的主键值 28 | * **updateAllByAssist** 更新一个对象中所有的属性包括null值,条件为SqlAssist帮助类 29 | * **updateNonEmptyById** 更新一个对象中属性不为null值,条件为对象中的主键值 30 | * **updateNonEmptyByAssist** 更新一个对象中属性不为null值,条件为SqlAssist帮助类 31 | * **updateSetNullById** 通过主键值设置指定的列为空 32 | * **updateSetNullByAssist** 通过Assist作为条件设置指定的列为空 33 | * **deleteById** 通过主键值删除对应的数据行 34 | * **deleteByAssist** 通过SqlAssist条件集删除对应的数据行 35 | * **queryAsObj** 执行查询结果为JsonObject 36 | * **queryAsList** 执行查询结果为List 37 | * **update** 执行更新等操作得到受影响的行数 38 | * **updateResult** 执行更新等操作得到想要的结果,比如自增的id 39 | * **batch** 批量执行 40 | * **execute** 原生执行 41 | 42 | ## SqlAssist方法说明 43 | * **setOrders** 设置排序,通过SqlAssist.order(列名,排序方式) 44 | * **setGroupBy** 设置分组 45 | * **setHaving** 设置分组条件 46 | * **setDistincts** 设置是否去重,true去重 47 | * **setPage** 设置第几页,该值仅在limitAll方法中有效,最终会被转换为startRow 48 | * **setStartRow** 设置从第几行开始取数据 49 | * **setRowSize** 设置每次取多少行数据 50 | * **setResultColumn** 设置自定义返回列,多个列以,逗号隔开 51 | * **setJoinOrReference** 设置连接查询或多表查询语句 52 | * **and** 添加并且条件 53 | * **or** 添加或者条件 54 | * **andEq** 添加并且等于条件 55 | * **orEq** 添加或者等于条件 56 | * **andNeq** 添加并且不等于条件 57 | * **orNeq** 添加或者不等于条件 58 | * **andLt** 添加并且小于条件 59 | * **orLt** 添加或者小于条件 60 | * **andLte** 添加并且小于等于条件 61 | * **orLte** 添加或者小于等于条件 62 | * **andGt** 添加并且大于条件 63 | * **orGt** 添加或者大于条件 64 | * **andGte** 添加并且大于等于条件 65 | * **orGte** 添加或者大于等于条件 66 | * **andLike** 添加并且like条件 67 | * **orLike** 添加或者like条件 68 | * **andNotLike** 添加并且not like条件 69 | * **orNotLike** 添加或者not like条件 70 | * **andisNull** 添加并且is null条件 71 | * **orisNull** 添加或者is null条件 72 | * **andIsNotNull** 添加并且is not null条件 73 | * **orIsNotNull** 添加或者is not null条件 74 | * **setConditions** 添加查询条件 75 | * **customCondition** 添加自定义查询条件 76 | 77 | ## SqlAssist使用示例 78 | [示例项目](https://github.com/shenzhenMirren/vertx-sql-assist-examples) 79 | 80 | 81 | ``` java 82 | // (1)创建Assist帮助类 83 | SqlAssist assist = new SqlAssist(); 84 | // (2)添加条件type=1或3,相当于SQL: where type=1 or type=3 85 | assist.orEq("type", 1).orEq("type", 3); 86 | // (3)去掉重复的数据,相当于SQL: select distinct ... 87 | assist.setDistincts(true); 88 | // (4)自定义只返回id,type,name,seq列 89 | assist.setResultColumn("id,type,name,seq"); 90 | // (5)通过seq类倒序排序,相当于SQL: order by seq desc 91 | assist.setOrders(SqlAssist.order("seq", false)); 92 | // (6)获取数据库中第20-35行的数据,你也可以使用setPage(第几页)的方式进行分页获取,相当于SQL: limit 20,15 93 | assist.setStartRow(20).setRowSize(15); 94 | // (7)执行获取数据 95 | Future future=Promise.promise().future(); 96 | future.setHandler(//处理结果); 97 | itemsSQL.selectAll(assist,future); 98 | ``` 99 | 具体使用方式可以查看SqlAssist类的方法注释,如果不清楚的可以在ScrewDriver群里咨询 100 | 101 | 102 | ## 使用方法 103 | 104 | **示例** 105 | 106 | 1.创建实体类 107 | 108 | ``` java 109 | //添加表注释 110 | @Table("表的名称") 111 | public class User { 112 | @TableId("主键id") 113 | private Long id; 114 | @TableColumn("列的名称") 115 | private String name; 116 | @TableColumn(value = "列的名称", alias = "列的别名,不是必须") 117 | private Integer type; 118 | //其他必须的 119 | } 120 | ``` 121 | 2.创建SQL类并继承CommonSQL 122 | 123 | ``` java 124 | public class UserSQL extends CommonSQL {//(1) 125 | public UserSQL(SQLExecute execute) { 126 | super(execute); 127 | } 128 | // (1) 129 | // User 必须是有@Table, @TableId,@TableColumn注解的实体类,或重写一个实现了表名,id,返回列的SQLStatement传给CommonSQL 130 | // JDBCPool 可以是别的数据库客户端 131 | //实现其他的方法 132 | } 133 | ``` 134 | 3.执行 135 | 136 | ``` java 137 | public static void main(String[] args) { 138 | // 其他已省略的变量 139 | UserSQL userSQL = new UserSQL(SQLExecute.createJDBC(JDBCPool)); 140 | // 查询示例 141 | // 创建帮助类 142 | SqlAssist assist = new SqlAssist(); 143 | assist.setStartRow(0).setRowSize(15); 144 | assist.andEq("type", 1); 145 | assist.setOrders(SqlAssist.order("id", true)); 146 | // 执行查询 147 | userSQL.selectAll(assist,res->{ 148 | if (res.succeeded()) { 149 | System.out.println(res.result()); 150 | }else { 151 | System.err.println(res.cause()); 152 | } 153 | }); 154 | //保存示例 155 | User user =new User(); 156 | user.setId(1001L); 157 | user.setName("org.mirrentools"); 158 | user.setType(1); 159 | userSQL.insertNonEmpty(user,res->{//Processed results}); 160 | } 161 | ``` 162 | ## 通用设置 163 | **设置不同数据库SQL语句** 默认使用MySQL标准的SQL语句,你可以通过SQLStatement设置为不同的数据库SQL语句,支持MySQL、PostgreSQL、Oracle、DB2、SQL Server、SQLite,比如设置为Oracle你可以这样: 164 | ``` java 165 | SQLStatement.register(OracleStatementSQL.class); 166 | ``` 167 | **设置分页返回结果名称** 分页获取数据返回的名称默认为:totals=数据总行数,pages=数据总页数 ,page=当前是第几页,size=每页显示多少行数据,data=数据,如果你要将名称改为其他的你可以这样: 168 | ``` java 169 | SqlLimitResult.registerResultKey("totals", "counts"); 170 | ``` -------------------------------------------------------------------------------- /data/sqlite.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MirrenTools/vertx-sql-assist/1e652bee31318cf257ba352100e753da319f122a/data/sqlite.db -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 4 | 4.0.0 5 | 6 | org.mirrentools 7 | vertx-sql-assist 8 | 4.1.5 9 | jar 10 | vertx-sql-assist 11 | vertx-sql-assist is the SQL operation help tool of Vert.x, 12 | which provides the support of insert, delete, update, query, join, 13 | paging query, cooperate with SqlAssist help class, it basically does 14 | not need to write a line of SQL code. 15 | https://mirrentools.org 16 | 17 | 18 | UTF-8 19 | 4.1.4 20 | 21 | 22 | 23 | 24 | junit 25 | junit 26 | 4.13.1 27 | test 28 | true 29 | 30 | 31 | io.vertx 32 | vertx-unit 33 | ${vertx.version} 34 | test 35 | true 36 | 37 | 38 | io.vertx 39 | vertx-core 40 | ${vertx.version} 41 | true 42 | 43 | 44 | io.vertx 45 | vertx-jdbc-client 46 | ${vertx.version} 47 | true 48 | 49 | 50 | io.vertx 51 | vertx-pg-client 52 | ${vertx.version} 53 | true 54 | 55 | 56 | io.vertx 57 | vertx-mysql-client 58 | ${vertx.version} 59 | true 60 | 61 | 62 | io.vertx 63 | vertx-db2-client 64 | ${vertx.version} 65 | true 66 | 67 | 68 | mysql 69 | mysql-connector-java 70 | 8.0.16 71 | test 72 | true 73 | 74 | 75 | org.xerial 76 | sqlite-jdbc 77 | 3.8.11.2 78 | test 79 | true 80 | 81 | 82 | org.mirrentools 83 | screw-driver 84 | 1.2.4 85 | test 86 | true 87 | 88 | 89 | 90 | 91 | 92 | 93 | org.apache.maven.plugins 94 | maven-compiler-plugin 95 | 2.3.2 96 | 97 | 1.8 98 | 1.8 99 | UTF-8 100 | 101 | 102 | 103 | 104 | 105 | 106 | ossrh 107 | https://oss.sonatype.org/content/repositories/snapshots 108 | 109 | 110 | ossrh 111 | https://oss.sonatype.org/service/local/staging/deploy/maven2 112 | 113 | 114 | 115 | 116 | 117 | release 118 | 119 | 120 | 121 | org.sonatype.plugins 122 | nexus-staging-maven-plugin 123 | 1.6.3 124 | true 125 | 126 | ossrh 127 | https://oss.sonatype.org/ 128 | true 129 | 130 | 131 | 132 | org.apache.maven.plugins 133 | maven-release-plugin 134 | 2.3.2 135 | 136 | true 137 | false 138 | release 139 | deploy 140 | 141 | 142 | 143 | org.apache.maven.plugins 144 | maven-compiler-plugin 145 | 2.3.2 146 | 147 | 1.8 148 | 1.8 149 | UTF-8 150 | 151 | 152 | 153 | org.apache.maven.plugins 154 | maven-gpg-plugin 155 | 1.6 156 | 157 | 158 | sign-artifacts 159 | verify 160 | 161 | sign 162 | 163 | 164 | 165 | 166 | 167 | org.apache.maven.plugins 168 | maven-source-plugin 169 | 3.0.1 170 | 171 | 172 | attach-sources 173 | 174 | jar-no-fork 175 | 176 | 177 | 178 | 179 | 180 | maven-javadoc-plugin 181 | 3.0.1 182 | 183 | 184 | package 185 | 186 | jar 187 | 188 | 189 | 190 | 191 | false 192 | none 193 | public 194 | UTF-8 195 | UTF-8 196 | UTF-8 197 | 198 | http://docs.oracle.com/javase/8/docs/api 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | https://github.com/MirrenTools/vertx-sql-assist 209 | https://github.com/MirrenTools/vertx-sql-assist.git 210 | 211 | 212 | 213 | Mirren Tools 214 | https://mirrentools.org/ 215 | 216 | 217 | 218 | 219 | MIT License 220 | https://raw.githubusercontent.com/xtuhcy/gecco/master/LICENSE 221 | 222 | 223 | 224 | 225 | 226 | 227 | Mirren 228 | szmirren@qq.com 229 | https://mirrentools.org/ 230 | 231 | 232 | 233 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/CommonSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.lang.reflect.ParameterizedType; 4 | import java.util.List; 5 | 6 | import io.vertx.core.AsyncResult; 7 | import io.vertx.core.Handler; 8 | import io.vertx.core.json.JsonObject; 9 | import io.vertx.sqlclient.PropertyKind; 10 | import io.vertx.sqlclient.Row; 11 | import io.vertx.sqlclient.RowSet; 12 | import io.vertx.sqlclient.Tuple; 13 | 14 | /** 15 | * 通用的数据库操作客户端的默认实现, 16 | * 17 | * @author Mirren 18 | * 19 | * @param 20 | * 实体类的类型 21 | * @param 22 | * SQL执行器的客户端类型,比如JDBCClient 23 | */ 24 | public abstract class CommonSQL implements CommonSQLClinet { 25 | /** SQL 执行器 */ 26 | private SQLExecute execute; 27 | /** SQL 命令 */ 28 | private SQLCommand command; 29 | 30 | /** 31 | * 使用以注册或默认的{@link SQLStatement} 32 | * 33 | * @param entityClz 34 | * 实体类,类必须包含{@link Table} {@link TableId} {@link TableColumn}注解 35 | * @param execute 36 | * 执行器 37 | */ 38 | public CommonSQL(SQLExecute execute) { 39 | Class entityClz = (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]; 40 | SQLStatement statement = SQLStatement.create(entityClz); 41 | this.execute = execute; 42 | this.command = new SQLCommandImpl(statement, execute); 43 | } 44 | 45 | /** 46 | * 使用自定义的{@link SQLStatement} 47 | * 48 | * @param execute 49 | * SQL执行器 50 | * @param statement 51 | * SQL执行语句 52 | */ 53 | public CommonSQL(SQLExecute execute, SQLStatement statement) { 54 | this.command = new SQLCommandImpl(statement, execute); 55 | } 56 | 57 | /** 58 | * 获取客户端 59 | * 60 | * @return 61 | * 62 | */ 63 | @Override 64 | public C getDbClient() { 65 | return execute.getClient(); 66 | } 67 | 68 | @Override 69 | public void execute(SqlAndParams qp, Handler>> handler) { 70 | execute.execute(qp, handler); 71 | } 72 | 73 | @Override 74 | public void queryAsObj(SqlAndParams qp, Handler> handler) { 75 | execute.queryAsObj(qp, handler); 76 | } 77 | 78 | @Override 79 | public void queryAsList(SqlAndParams qp, Handler>> handler) { 80 | execute.queryAsList(qp, handler); 81 | } 82 | 83 | @Override 84 | public void update(SqlAndParams qp, Handler> handler) { 85 | execute.update(qp, handler); 86 | } 87 | 88 | @Override 89 | public void updateResult(SqlAndParams qp, PropertyKind property, Handler> handler) { 90 | execute.updateResult(qp, property, handler); 91 | } 92 | 93 | @Override 94 | public void batch(SqlAndParams qp, Handler> handler) { 95 | execute.batch(qp, handler); 96 | } 97 | 98 | @Override 99 | public void getCount(SqlAssist assist, Handler> handler) { 100 | command.getCount(assist, handler); 101 | } 102 | 103 | @Override 104 | public void selectAll(SqlAssist assist, Handler>> handler) { 105 | command.selectAll(assist, handler); 106 | } 107 | 108 | @Override 109 | public void limitAll(SqlAssist assist, Handler> handler) { 110 | command.limitAll(assist, handler); 111 | } 112 | 113 | @Override 114 | public void selectById(S primaryValue, String resultColumns, String tableAlias, String joinOrReference, 115 | Handler> handler) { 116 | command.selectById(primaryValue, resultColumns, tableAlias, joinOrReference, handler); 117 | } 118 | 119 | @Override 120 | public void selectSingleByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 121 | Handler> handler) { 122 | command.selectSingleByObj(obj, resultColumns, tableAlias, joinOrReference, handler); 123 | } 124 | 125 | @Override 126 | public void selectByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 127 | Handler>> handler) { 128 | command.selectByObj(obj, resultColumns, tableAlias, joinOrReference, handler); 129 | } 130 | 131 | @Override 132 | public void insertAll(T obj, Handler> handler) { 133 | command.insertAll(obj, handler); 134 | } 135 | 136 | @Override 137 | public void insertNonEmpty(T obj, Handler> handler) { 138 | command.insertNonEmpty(obj, handler); 139 | } 140 | 141 | @Override 142 | public void insertNonEmptyGeneratedKeys(T obj, PropertyKind property, Handler> handler) { 143 | command.insertNonEmptyGeneratedKeys(obj, property, handler); 144 | } 145 | 146 | @Override 147 | public void insertBatch(List list, Handler> handler) { 148 | command.insertBatch(list, handler); 149 | } 150 | 151 | @Override 152 | public void insertBatch(List columns, List params, Handler> handler) { 153 | command.insertBatch(columns, params, handler); 154 | } 155 | 156 | @Override 157 | public void replace(T obj, Handler> handler) { 158 | command.replace(obj, handler); 159 | } 160 | 161 | @Override 162 | public void updateAllById(T obj, Handler> handler) { 163 | command.updateAllById(obj, handler); 164 | } 165 | 166 | @Override 167 | public void updateAllByAssist(T obj, SqlAssist assist, Handler> handler) { 168 | command.updateAllByAssist(obj, assist, handler); 169 | } 170 | 171 | @Override 172 | public void updateNonEmptyById(T obj, Handler> handler) { 173 | command.updateNonEmptyById(obj, handler); 174 | } 175 | 176 | @Override 177 | public void updateNonEmptyByAssist(T obj, SqlAssist assist, Handler> handler) { 178 | command.updateNonEmptyByAssist(obj, assist, handler); 179 | } 180 | 181 | @Override 182 | public void updateSetNullById(S primaryValue, List columns, Handler> handler) { 183 | command.updateSetNullById(primaryValue, columns, handler); 184 | } 185 | 186 | @Override 187 | public void updateSetNullByAssist(SqlAssist assist, List columns, Handler> handler) { 188 | command.updateSetNullByAssist(assist, columns, handler); 189 | } 190 | 191 | @Override 192 | public void deleteById(S primaryValue, Handler> handler) { 193 | command.deleteById(primaryValue, handler); 194 | } 195 | 196 | @Override 197 | public void deleteByAssist(SqlAssist assist, Handler> handler) { 198 | command.deleteByAssist(assist, handler); 199 | } 200 | } 201 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/CommonSQLClinet.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.AsyncResult; 6 | import io.vertx.core.Future; 7 | import io.vertx.core.Handler; 8 | import io.vertx.core.Promise; 9 | import io.vertx.core.json.JsonObject; 10 | import io.vertx.sqlclient.PropertyKind; 11 | import io.vertx.sqlclient.Row; 12 | import io.vertx.sqlclient.RowSet; 13 | import io.vertx.sqlclient.Tuple; 14 | 15 | /** 16 | * 通用的数据库操作客户端 17 | * 18 | * @author Mirren 19 | * 20 | * @param 21 | * SQL执行器的客户端类型,比如JDBCClient 22 | */ 23 | public interface CommonSQLClinet { 24 | /** 25 | * 获取客户端 26 | * 27 | * @return 28 | */ 29 | C getDbClient(); 30 | 31 | /** 32 | * 执行SQL 33 | * 34 | * @param qp 35 | * SQL语句与参数 36 | * @param handler 37 | * 返回结果 38 | */ 39 | default Future> execute(SqlAndParams qp) { 40 | Promise> promise = Promise.promise(); 41 | execute(qp, promise); 42 | return promise.future(); 43 | } 44 | 45 | /** 46 | * 执行SQL 47 | * 48 | * @param qp 49 | * SQL语句与参数 50 | * @param handler 51 | * 返回结果 52 | */ 53 | void execute(SqlAndParams qp, Handler>> handler); 54 | 55 | /** 56 | * 执行查询结果为单个对象 57 | * 58 | * @param qp 59 | * SQL语句与参数 60 | * @param handler 61 | * 返回结果 62 | */ 63 | default Future queryAsObj(SqlAndParams qp) { 64 | Promise promise = Promise.promise(); 65 | queryAsObj(qp, promise); 66 | return promise.future(); 67 | } 68 | 69 | /** 70 | * 执行查询结果为单个对象 71 | * 72 | * @param qp 73 | * SQL语句与参数 74 | * @param handler 75 | * 返回结果 76 | */ 77 | void queryAsObj(SqlAndParams qp, Handler> handler); 78 | 79 | /** 80 | * 执行查询多个对象 81 | * 82 | * @param qp 83 | * SQL语句与参数 84 | * @return 返回结果 85 | */ 86 | default Future> queryAsList(SqlAndParams qp) { 87 | Promise> promise = Promise.promise(); 88 | queryAsList(qp, promise); 89 | return promise.future(); 90 | } 91 | 92 | /** 93 | * 执行查询多个对象 94 | * 95 | * @param qp 96 | * SQL语句与参数 97 | * @param handler 98 | * 返回结果 99 | */ 100 | void queryAsList(SqlAndParams qp, Handler>> handler); 101 | 102 | /** 103 | * 执行更新等操作得到受影响的行数 104 | * 105 | * @param qp 106 | * SQL语句与参数 107 | * 108 | * @return 受影响的行数 109 | */ 110 | default Future update(SqlAndParams qp) { 111 | Promise promise = Promise.promise(); 112 | update(qp, promise); 113 | return promise.future(); 114 | } 115 | 116 | /** 117 | * 执行更新等操作得到受影响的行数 118 | * 119 | * @param qp 120 | * SQL语句与参数 121 | * 122 | * @param handler 123 | */ 124 | void update(SqlAndParams qp, Handler> handler); 125 | 126 | /** 127 | * 执行更新并获得操作结果 128 | * 129 | * @param qp 130 | * SQL语句与参数 131 | * @param property 132 | * 返回结果的PropertyKind名称,比如JDBCPool.GENERATED_KEYS或MySQLClient.LAST_INSERTED_ID 133 | * @param handler 134 | */ 135 | default Future updateResult(SqlAndParams qp, PropertyKind property) { 136 | Promise promise = Promise.promise(); 137 | updateResult(qp, property, promise); 138 | return promise.future(); 139 | } 140 | 141 | /** 142 | * 执行更新并获得操作结果 143 | * 144 | * @param qp 145 | * SQL语句与参数 146 | * @param property 147 | * 返回结果的PropertyKind名称,比如JDBCPool.GENERATED_KEYS或MySQLClient.LAST_INSERTED_ID 148 | * @param handler 149 | */ 150 | void updateResult(SqlAndParams qp, PropertyKind property, Handler> handler); 151 | 152 | /** 153 | * 批量操作 154 | * 155 | * @param qp 156 | * SQL语句与批量参数 157 | * 158 | * @return 返回结果 159 | */ 160 | default Future batch(SqlAndParams qp) { 161 | Promise promise = Promise.promise(); 162 | batch(qp, promise); 163 | return promise.future(); 164 | } 165 | 166 | /** 167 | * 批量操作 168 | * 169 | * @param qp 170 | * SQL语句与批量参数 171 | * 172 | * @param handler 173 | * 返回结果 174 | */ 175 | void batch(SqlAndParams qp, Handler> handler); 176 | 177 | /** 178 | * 获得数据总行数 179 | * 180 | */ 181 | default Future getCount() { 182 | Promise promise = Promise.promise(); 183 | getCount(null, promise); 184 | return promise.future(); 185 | } 186 | 187 | /** 188 | * 获得数据总行数 189 | * 190 | * @param handler 191 | * 返回数据总行数 192 | */ 193 | default void getCount(Handler> handler) { 194 | getCount(null, handler); 195 | } 196 | 197 | /** 198 | * 获取数据总行数 199 | * 200 | * @param assist 201 | * 查询工具,如果没有可以为null 202 | * @return 203 | */ 204 | default Future getCount(SqlAssist assist) { 205 | Promise promise = Promise.promise(); 206 | getCount(assist, promise); 207 | return promise.future(); 208 | } 209 | 210 | /** 211 | * 获取数据总行数 212 | * 213 | * @param assist 214 | * 查询工具,如果没有可以为null 215 | * @param handler 216 | * 返回数据总行数 217 | */ 218 | void getCount(SqlAssist assist, Handler> handler); 219 | 220 | /** 221 | * 查询所有数据 222 | * 223 | * @return 224 | */ 225 | default Future> selectAll() { 226 | Promise> promise = Promise.promise(); 227 | selectAll(null, promise); 228 | return promise.future(); 229 | } 230 | 231 | /** 232 | * 查询所有数据 233 | * 234 | * @param handler 235 | * 结果集 236 | */ 237 | default void selectAll(Handler>> handler) { 238 | selectAll(null, handler); 239 | } 240 | 241 | /** 242 | * 通过查询工具查询所有数据 243 | * 244 | * @param assist 245 | * 查询工具帮助类 246 | * @return 247 | */ 248 | default Future> selectAll(SqlAssist assist) { 249 | Promise> promise = Promise.promise(); 250 | selectAll(assist, promise); 251 | return promise.future(); 252 | } 253 | 254 | /** 255 | * 通过查询工具查询所有数据 256 | * 257 | * @param assist 258 | * 查询工具帮助类 259 | * @param handler 260 | * 结果集 261 | */ 262 | void selectAll(SqlAssist assist, Handler>> handler); 263 | 264 | /** 265 | * 页查询,默认page=1,rowSize=15(取第一页,每页取15行数据) 266 | * 267 | * @param assist 268 | * 查询工具(注意:startRow在该方法中无效,最后会有page转换为startRow) 269 | * @return 返回结果为(JsonObject)格式为: {@link SqlLimitResult#toJson()} 270 | */ 271 | default Future limitAll(final SqlAssist assist) { 272 | Promise promise = Promise.promise(); 273 | limitAll(assist, promise); 274 | return promise.future(); 275 | } 276 | 277 | /** 278 | * 分页查询,默认page=1,rowSize=15(取第一页,每页取15行数据) 279 | * 280 | * @param assist 281 | * 查询工具(注意:startRow在该方法中无效,最后会有page转换为startRow) 282 | * @param handler 283 | * 返回结果为(JsonObject)格式为: {@link SqlLimitResult#toJson()} 284 | */ 285 | void limitAll(final SqlAssist assist, Handler> handler); 286 | 287 | /** 288 | * 通过ID查询出数据 289 | * 290 | * @param primaryValue 291 | * 主键值 292 | * @return 返回结果:如果查询得到返回JsonObject如果查询不到返回null 293 | */ 294 | default Future selectById(S primaryValue) { 295 | Promise promise = Promise.promise(); 296 | selectById(primaryValue, null, null, null, promise); 297 | return promise.future(); 298 | } 299 | 300 | /** 301 | * 通过ID查询出数据 302 | * 303 | * @param primaryValue 304 | * 主键值 305 | * @param handler 306 | * 返回结果:如果查询得到返回JsonObject如果查询不到返回null 307 | */ 308 | default void selectById(S primaryValue, Handler> handler) { 309 | selectById(primaryValue, null, null, null, handler); 310 | } 311 | 312 | /** 313 | * 通过ID查询出数据 314 | * 315 | * @param primaryValue 316 | * 主键值 317 | * @param resultColumns 318 | * 自定义返回列 319 | * @return 返回结果:如果查询得到返回JsonObject如果查询不到返回null 320 | */ 321 | default Future selectById(S primaryValue, String resultColumns) { 322 | Promise promise = Promise.promise(); 323 | selectById(primaryValue, resultColumns, null, null, promise); 324 | return promise.future(); 325 | } 326 | 327 | /** 328 | * 通过ID查询出数据 329 | * 330 | * @param primaryValue 331 | * 主键值 332 | * @param resultColumns 333 | * 自定义返回列 334 | * @param handler 335 | * 返回结果:如果查询得到返回JsonObject如果查询不到返回null 336 | */ 337 | default void selectById(S primaryValue, String resultColumns, Handler> handler) { 338 | selectById(primaryValue, resultColumns, null, null, handler); 339 | } 340 | 341 | /** 342 | * 通过ID查询出数据,并自定义返回列 343 | * 344 | * @param primaryValue 345 | * 主键值 346 | * @param resultColumns 347 | * 自定义返回列 348 | * @param tableAlias 349 | * 当前表的别名 350 | * @param joinOrReference 351 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 352 | * @return 返回结果:如果查询得到返回JsonObject如果查询不到返回null 353 | */ 354 | default Future selectById(S primaryValue, String resultColumns, String tableAlias, String joinOrReference) { 355 | Promise promise = Promise.promise(); 356 | selectById(primaryValue, resultColumns, tableAlias, joinOrReference, promise); 357 | return promise.future(); 358 | } 359 | /** 360 | * 通过ID查询出数据,并自定义返回列 361 | * 362 | * @param primaryValue 363 | * 主键值 364 | * @param resultColumns 365 | * 自定义返回列 366 | * @param tableAlias 367 | * 当前表的别名 368 | * @param joinOrReference 369 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 370 | * @param handler 371 | * 返回结果:如果查询得到返回JsonObject如果查询不到返回null 372 | */ 373 | void selectById(S primaryValue, String resultColumns, String tableAlias, String joinOrReference, 374 | Handler> handler); 375 | 376 | /** 377 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据; 378 | * 379 | * @param obj 380 | * 对象 381 | * 382 | * @return 结果:如果存在返回JsonObject,不存在返回null 383 | */ 384 | default Future selectSingleByObj(T obj) { 385 | Promise promise = Promise.promise(); 386 | selectSingleByObj(obj, null, null, null, promise); 387 | return promise.future(); 388 | } 389 | 390 | /** 391 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据; 392 | * 393 | * @param obj 394 | * 对象 395 | * 396 | * @param handler 397 | * 结果:如果存在返回JsonObject,不存在返回null 398 | */ 399 | default void selectSingleByObj(T obj, Handler> handler) { 400 | selectSingleByObj(obj, null, null, null, handler); 401 | } 402 | 403 | /** 404 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据 405 | * 406 | * @param obj 407 | * 对象 408 | * @param resultColumns 409 | * 自定义返回列 410 | * 411 | * @return 结果:如果存在返回JsonObject,不存在返回null 412 | */ 413 | default Future selectSingleByObj(T obj, String resultColumns) { 414 | Promise promise = Promise.promise(); 415 | selectSingleByObj(obj, resultColumns, null, null, promise); 416 | return promise.future(); 417 | } 418 | 419 | /** 420 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据 421 | * 422 | * @param obj 423 | * 对象 424 | * @param resultColumns 425 | * 自定义返回列 426 | * 427 | * @param handler 428 | * 结果:如果存在返回JsonObject,不存在返回null 429 | */ 430 | default void selectSingleByObj(T obj, String resultColumns, Handler> handler) { 431 | selectSingleByObj(obj, resultColumns, null, null, handler); 432 | } 433 | 434 | /** 435 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据 436 | * 437 | * @param obj 438 | * 对象 439 | * @param resultColumns 440 | * 自定义返回列 441 | * @param tableAlias 442 | * 当前表的别名 443 | * @param joinOrReference 444 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 445 | * @return 结果:如果存在返回JsonObject,不存在返回null 446 | */ 447 | default Future selectSingleByObj(T obj, String resultColumns, String tableAlias, String joinOrReference) { 448 | Promise promise = Promise.promise(); 449 | selectSingleByObj(obj, resultColumns, tableAlias, joinOrReference, promise); 450 | return promise.future(); 451 | } 452 | 453 | /** 454 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据 455 | * 456 | * @param obj 457 | * 对象 458 | * @param resultColumns 459 | * 自定义返回列 460 | * @param tableAlias 461 | * 当前表的别名 462 | * @param joinOrReference 463 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 464 | * @param handler 465 | * 结果:如果存在返回JsonObject,不存在返回null 466 | */ 467 | void selectSingleByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 468 | Handler> handler); 469 | 470 | /** 471 | * 将对象属性不为null的属性作为条件查询出数据 472 | * 473 | * @param obj 474 | * 对象 475 | * 476 | * @return 返回结果集 477 | */ 478 | default Future> selectByObj(T obj) { 479 | Promise> promise = Promise.promise(); 480 | selectByObj(obj, null, null, null, promise); 481 | return promise.future(); 482 | } 483 | 484 | /** 485 | * 将对象属性不为null的属性作为条件查询出数据 486 | * 487 | * @param obj 488 | * 对象 489 | * 490 | * @param handler 491 | * 返回结果集 492 | */ 493 | default void selectByObj(T obj, Handler>> handler) { 494 | selectByObj(obj, null, null, null, handler); 495 | } 496 | 497 | /** 498 | * 将对象属性不为null的属性作为条件查询出数据 499 | * 500 | * @param obj 501 | * 对象 502 | * @param resultColumns 503 | * 自定义返回列 504 | * 505 | * @return 返回结果集 506 | */ 507 | default Future> selectByObj(T obj, String resultColumns) { 508 | Promise> promise = Promise.promise(); 509 | selectByObj(obj, resultColumns, null, null, promise); 510 | return promise.future(); 511 | } 512 | 513 | /** 514 | * 将对象属性不为null的属性作为条件查询出数据 515 | * 516 | * @param obj 517 | * 对象 518 | * @param resultColumns 519 | * 自定义返回列 520 | * 521 | * @param handler 522 | * 返回结果集 523 | */ 524 | default void selectByObj(T obj, String resultColumns, Handler>> handler) { 525 | selectByObj(obj, resultColumns, null, null, handler); 526 | } 527 | 528 | /** 529 | * 将对象属性不为null的属性作为条件查询出数据 530 | * 531 | * @param obj 532 | * 对象 533 | * @param resultColumns 534 | * 自定义返回列 535 | * @param tableAlias 536 | * 当前表的别名 537 | * @param joinOrReference 538 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 539 | * @return 返回结果集 540 | */ 541 | default Future> selectByObj(T obj, String resultColumns, String tableAlias, String joinOrReference) { 542 | Promise> promise = Promise.promise(); 543 | selectByObj(obj, resultColumns, tableAlias, joinOrReference, promise); 544 | return promise.future(); 545 | } 546 | 547 | /** 548 | * 将对象属性不为null的属性作为条件查询出数据 549 | * 550 | * @param obj 551 | * 对象 552 | * @param resultColumns 553 | * 自定义返回列 554 | * @param tableAlias 555 | * 当前表的别名 556 | * @param joinOrReference 557 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 558 | * @param handler 559 | * 返回结果集 560 | */ 561 | void selectByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 562 | Handler>> handler); 563 | 564 | /** 565 | * 插入一个对象包括属性值为null的值 566 | * 567 | * @param obj 568 | * 对象 569 | * @return 返回操作结果受影响的行数 570 | */ 571 | default Future insertAll(T obj) { 572 | Promise promise = Promise.promise(); 573 | insertAll(obj, promise); 574 | return promise.future(); 575 | } 576 | 577 | /** 578 | * 插入一个对象包括属性值为null的值 579 | * 580 | * @param obj 581 | * 对象 582 | * @param handler 583 | * 返回操作结果 584 | */ 585 | void insertAll(T obj, Handler> handler); 586 | 587 | /** 588 | * 插入一个对象,只插入对象中值不为null的属性 589 | * 590 | * @param obj 591 | * 对象 592 | * @return 返回操作结果 593 | */ 594 | default Future insertNonEmpty(T obj) { 595 | Promise promise = Promise.promise(); 596 | insertNonEmpty(obj, promise); 597 | return promise.future(); 598 | } 599 | 600 | /** 601 | * 插入一个对象,只插入对象中值不为null的属性 602 | * 603 | * @param obj 604 | * 对象 605 | * @param handler 606 | * 返回操作结果 607 | */ 608 | void insertNonEmpty(T obj, Handler> handler); 609 | 610 | /** 611 | * 插入一个对象,只插入对象中值不为null的属性,并返回自增的结果 612 | * 613 | * @param obj 614 | * 对象 615 | * @return 返回操作结果 616 | */ 617 | /** 618 | * 619 | * @param 620 | * @param obj 621 | * 对象 622 | * @param property 623 | * 获取属性的方法,比如JDBCPool使用传入JDBCPool.GENERATED_KEYS,MySQLPool使用PropertyKind.create("last-inserted-id",数据类型) 624 | * @return 625 | */ 626 | default Future insertNonEmptyGeneratedKeys(T obj, PropertyKind property) { 627 | Promise promise = Promise.promise(); 628 | insertNonEmptyGeneratedKeys(obj, property, promise); 629 | return promise.future(); 630 | } 631 | 632 | /** 633 | * 插入一个对象,只插入对象中值不为null的属性,并返回自增的结果 634 | * 635 | * @param obj 636 | * 对象 637 | * @param property 638 | * 获取属性的方法,比如JDBCPool使用传入JDBCPool.GENERATED_KEYS,MySQLPool使用PropertyKind.create("last-inserted-id",数据类型) 639 | * @param handler 640 | * 返回操作结果 641 | */ 642 | void insertNonEmptyGeneratedKeys(T obj, PropertyKind property, Handler> handler); 643 | 644 | /** 645 | * 批量添加全部所有字段 646 | * 647 | * @param list 648 | * 对象 649 | * @return 成功返回受影响的行数,如果对象为null或空则返回0 650 | */ 651 | default Future insertBatch(List list) { 652 | Promise promise = Promise.promise(); 653 | insertBatch(list, promise); 654 | return promise.future(); 655 | } 656 | 657 | /** 658 | * 批量添加全部所有字段 659 | * 660 | * @param list 661 | * 对象 662 | * @param handler 663 | * 成功返回受影响的行数,如果对象为null或空则返回0 664 | */ 665 | void insertBatch(List list, Handler> handler); 666 | /** 667 | * 批量添加自定字段 668 | * 669 | * @param column 670 | * 字段的名称示例:["id","name",...] 671 | * @param params 672 | * 字段对应的参数示例:[["id","name"],["id","name"]...] 673 | * @return 成功返回受影响的行数,如果字段或字段参数为null或空则返回0 674 | */ 675 | default Future insertBatch(List columns, List params) { 676 | Promise promise = Promise.promise(); 677 | insertBatch(columns, params, promise); 678 | return promise.future(); 679 | } 680 | 681 | /** 682 | * 批量添加自定字段 683 | * 684 | * @param column 685 | * 字段的名称示例:["id","name",...] 686 | * @param params 687 | * 字段对应的参数示例:[["id","name"],["id","name"]...] 688 | * @param handler 689 | * 成功返回受影响的行数,如果字段或字段参数为null或空则返回0 690 | */ 691 | void insertBatch(List columns, List params, Handler> handler); 692 | 693 | /** 694 | * 插入一个对象,如果该对象不存在就新建如果该对象已经存在就更新 695 | * 696 | * @param obj 697 | * 对象 698 | * 699 | * @return 结果集受影响的行数 700 | */ 701 | default Future replace(T obj) { 702 | Promise promise = Promise.promise(); 703 | replace(obj, promise); 704 | return promise.future(); 705 | } 706 | 707 | /** 708 | * 插入一个对象,如果该对象不存在就新建如果该对象已经存在就更新 709 | * 710 | * @param obj 711 | * 对象 712 | * 713 | * @param handler 714 | * 结果集受影响的行数 715 | */ 716 | void replace(T obj, Handler> handler); 717 | 718 | /** 719 | * 更新一个对象中所有的属性包括null值,条件为对象中的主键值 720 | * 721 | * @param obj 722 | * 对象 723 | * 724 | * @return 返回操作结果 725 | */ 726 | default Future updateAllById(T obj) { 727 | Promise promise = Promise.promise(); 728 | updateAllById(obj, promise); 729 | return promise.future(); 730 | } 731 | 732 | /** 733 | * 更新一个对象中所有的属性包括null值,条件为对象中的主键值 734 | * 735 | * @param obj 736 | * 对象 737 | * 738 | * @param handler 739 | * 返回操作结果 740 | */ 741 | void updateAllById(T obj, Handler> handler); 742 | 743 | /** 744 | * 更新一个对象中所有的属性包括null值,条件为SqlAssist条件集
745 | * 746 | * @param obj 747 | * 对象 748 | * @param SqlAssist 749 | * sql帮助工具 750 | * 751 | * @return 返回操作结果 752 | */ 753 | default Future updateAllByAssist(T obj, SqlAssist assist) { 754 | Promise promise = Promise.promise(); 755 | updateAllByAssist(obj, assist, promise); 756 | return promise.future(); 757 | } 758 | 759 | /** 760 | * 更新一个对象中所有的属性包括null值,条件为SqlAssist条件集
761 | * 762 | * @param obj 763 | * 对象 764 | * @param SqlAssist 765 | * sql帮助工具 766 | * 767 | * @param handler 768 | * 返回操作结果 769 | */ 770 | void updateAllByAssist(T obj, SqlAssist assist, Handler> handler); 771 | 772 | /** 773 | * 更新一个对象中属性不为null值,条件为对象中的主键值 774 | * 775 | * @param obj 776 | * 对象 777 | * @return 返回操作结果 778 | */ 779 | default Future updateNonEmptyById(T obj) { 780 | Promise promise = Promise.promise(); 781 | updateNonEmptyById(obj, promise); 782 | return promise.future(); 783 | } 784 | /** 785 | * 更新一个对象中属性不为null值,条件为对象中的主键值 786 | * 787 | * @param obj 788 | * 对象 789 | * @param handler 790 | * 返回操作结果 791 | */ 792 | void updateNonEmptyById(T obj, Handler> handler); 793 | 794 | /** 795 | * 更新一个对象中属性不为null值,条件为SqlAssist条件集 796 | * 797 | * @param obj 798 | * 对象 799 | * @param assist 800 | * 查询工具 801 | * @return 返回操作结果 802 | */ 803 | default Future updateNonEmptyByAssist(T obj, SqlAssist assist) { 804 | Promise promise = Promise.promise(); 805 | updateNonEmptyByAssist(obj, assist, promise); 806 | return promise.future(); 807 | } 808 | 809 | /** 810 | * 更新一个对象中属性不为null值,条件为SqlAssist条件集 811 | * 812 | * @param obj 813 | * 对象 814 | * @param assist 815 | * 查询工具 816 | * @param handler 817 | * 返回操作结果 818 | */ 819 | void updateNonEmptyByAssist(T obj, SqlAssist assist, Handler> handler); 820 | 821 | /** 822 | * 通过主键值设置指定的列为空 823 | * 824 | * @param 825 | * @param primaryValue 826 | * 主键 827 | * @param columns 828 | * 要设置为null的列 829 | * 830 | * @return 返回操作结果 831 | */ 832 | default Future updateSetNullById(S primaryValue, List columns) { 833 | Promise promise = Promise.promise(); 834 | updateSetNullById(primaryValue, columns, promise); 835 | return promise.future(); 836 | } 837 | 838 | /** 839 | * 通过主键值设置指定的列为空 840 | * 841 | * @param 842 | * @param primaryValue 843 | * 主键 844 | * @param columns 845 | * 要设置为null的列 846 | * 847 | * @param handler 848 | * 返回操作结果 849 | */ 850 | void updateSetNullById(S primaryValue, List columns, Handler> handler); 851 | 852 | /** 853 | * 通过Assist作为条件设置指定的列为空 854 | * 855 | * @param assist 856 | * sql帮助工具 857 | * @param columns 858 | * 要设置为null的列 859 | * 860 | * @param handler 861 | * 返回操作结果 862 | */ 863 | default Future updateSetNullByAssist(SqlAssist assist, List columns) { 864 | Promise promise = Promise.promise(); 865 | updateSetNullByAssist(assist, columns, promise); 866 | return promise.future(); 867 | } 868 | 869 | /** 870 | * 通过Assist作为条件设置指定的列为空 871 | * 872 | * @param assist 873 | * sql帮助工具 874 | * @param columns 875 | * 要设置为null的列 876 | * 877 | * @return handler 返回操作结果 878 | */ 879 | void updateSetNullByAssist(SqlAssist assist, List columns, Handler> handler); 880 | 881 | /** 882 | * 通过主键值删除对应的数据行 883 | * 884 | * @param obj 885 | * 主键值 886 | * @return 返回操作结果 887 | */ 888 | default Future deleteById(S primaryValue) { 889 | Promise promise = Promise.promise(); 890 | deleteById(primaryValue, promise); 891 | return promise.future(); 892 | } 893 | 894 | /** 895 | * 通过主键值删除对应的数据行 896 | * 897 | * @param obj 898 | * 主键值 899 | * @param handler 900 | * 返回操作结果 901 | */ 902 | void deleteById(S primaryValue, Handler> handler); 903 | 904 | /** 905 | * 通过SqlAssist条件集删除对应的数据行 906 | * 907 | * @param assist 908 | * 条件集 909 | * 910 | * @return 返回操作结果 911 | */ 912 | default Future deleteByAssist(SqlAssist assist) { 913 | Promise promise = Promise.promise(); 914 | deleteByAssist(assist, promise); 915 | return promise.future(); 916 | } 917 | 918 | /** 919 | * 通过SqlAssist条件集删除对应的数据行 920 | * 921 | * @param assist 922 | * 条件集 923 | * 924 | * @param handler 925 | * 返回操作结果 926 | */ 927 | void deleteByAssist(SqlAssist assist, Handler> handler); 928 | 929 | } 930 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLCommand.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.AsyncResult; 6 | import io.vertx.core.Future; 7 | import io.vertx.core.Handler; 8 | import io.vertx.core.json.JsonObject; 9 | import io.vertx.sqlclient.PropertyKind; 10 | import io.vertx.sqlclient.Tuple; 11 | 12 | /** 13 | * SQL可执行命令 14 | * 15 | * @author Mirren 16 | * 17 | */ 18 | public interface SQLCommand { 19 | /** 20 | * 获取数据总行数 21 | * 22 | * @param assist 23 | * 查询工具,如果没有可以为null 24 | * @param handler 25 | * 返回数据总行数 26 | */ 27 | void getCount(SqlAssist assist, Handler> handler); 28 | 29 | /** 30 | * 通过查询工具查询所有数据 31 | * 32 | * @param assist 33 | * 查询工具帮助类 34 | * @param handler 35 | * 结果集 36 | */ 37 | void selectAll(SqlAssist assist, Handler>> handler); 38 | 39 | /** 40 | * 分页查询,默认page=1,rowSize=15(取第一页,每页取15行数据) 41 | * 42 | * @param assist 43 | * 查询工具(注意:startRow在该方法中无效,最后会有page转换为startRow) 44 | * @param handler 45 | * 返回结果为(JsonObject)格式为: {@link SqlLimitResult#toJson()} 46 | */ 47 | default void limitAll(final SqlAssist assist, Handler> handler) { 48 | if (assist == null) { 49 | handler.handle(Future.failedFuture("The SqlAssist cannot be null , you can pass in new SqlAssist()")); 50 | return; 51 | } 52 | if (assist.getPage() == null || assist.getPage() < 1) { 53 | assist.setPage(1); 54 | } 55 | if (assist.getRowSize() == null || assist.getRowSize() < 1) { 56 | assist.setRowSize(15); 57 | } 58 | if (assist.getPage() == 1) { 59 | assist.setStartRow(0); 60 | } else { 61 | assist.setStartRow((assist.getPage() - 1) * assist.getRowSize()); 62 | } 63 | getCount(assist, cres -> { 64 | if (cres.succeeded()) { 65 | Long count = cres.result(); 66 | SqlLimitResult result = new SqlLimitResult<>(count, assist.getPage(), assist.getRowSize()); 67 | if (count == 0 || assist.getPage() > result.getPages()) { 68 | handler.handle(Future.succeededFuture(result.toJson())); 69 | } else { 70 | selectAll(assist, dres -> { 71 | if (dres.succeeded()) { 72 | result.setData(dres.result()); 73 | handler.handle(Future.succeededFuture(result.toJson())); 74 | } else { 75 | handler.handle(Future.failedFuture(dres.cause())); 76 | } 77 | }); 78 | } 79 | } else { 80 | handler.handle(Future.failedFuture(cres.cause())); 81 | } 82 | }); 83 | }; 84 | 85 | /** 86 | * 通过ID查询出数据,并自定义返回列 87 | * 88 | * @param primaryValue 89 | * 主键值 90 | * @param resultColumns 91 | * 自定义返回列 92 | * @param tableAlias 93 | * 当前表的别名 94 | * @param joinOrReference 95 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 96 | * @param handler 97 | * 返回结果:如果查询得到返回JsonObject如果查询不到返回null 98 | */ 99 | void selectById(S primaryValue, String resultColumns, String tableAlias, String joinOrReference, 100 | Handler> handler); 101 | 102 | /** 103 | * 将对象属性不为null的属性作为条件查询出数据,只取查询出来的第一条数据 104 | * 105 | * @param obj 106 | * 对象 107 | * @param resultColumns 108 | * 自定义返回列 109 | * @param tableAlias 110 | * 当前表的别名 111 | * @param joinOrReference 112 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 113 | * @param handler 114 | * 结果:如果存在返回JsonObject,不存在返回null 115 | */ 116 | void selectSingleByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 117 | Handler> handler); 118 | 119 | /** 120 | * 将对象属性不为null的属性作为条件查询出数据 121 | * 122 | * @param obj 123 | * 对象 124 | * @param resultColumns 125 | * 自定义返回列 126 | * @param tableAlias 127 | * 当前表的别名 128 | * @param joinOrReference 129 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 130 | * @param handler 131 | * 返回结果集 132 | */ 133 | void selectByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 134 | Handler>> handler); 135 | 136 | /** 137 | * 插入一个对象包括属性值为null的值 138 | * 139 | * @param obj 140 | * 对象 141 | * @param handler 142 | * 返回操作结果 143 | */ 144 | void insertAll(T obj, Handler> handler); 145 | 146 | /** 147 | * 插入一个对象,只插入对象中值不为null的属性 148 | * 149 | * @param obj 150 | * 对象 151 | * @param handler 152 | * 返回操作结果 153 | */ 154 | void insertNonEmpty(T obj, Handler> handler); 155 | 156 | /** 157 | * 插入一个对象,只插入对象中值不为null的属性,并返回自增的结果 158 | * @param 159 | * @param obj 插入的对象 160 | * @param property 返回结果的PropertyKind名称,比如JDBCPool.GENERATED_KEYS或MySQLClient.LAST_INSERTED_ID 161 | * @param handler 162 | */ 163 | void insertNonEmptyGeneratedKeys(T obj, PropertyKind property, Handler> handler); 164 | 165 | /** 166 | * 批量添加全部所有字段 167 | * 168 | * @param list 169 | * 对象 170 | * @param handler 171 | * 成功返回受影响的行数,如果对象为null或空则返回0 172 | */ 173 | void insertBatch(List list, Handler> handler); 174 | /** 175 | * 批量添加自定字段 176 | * 177 | * @param column 178 | * 字段的名称示例:["id","name",...] 179 | * @param params 180 | * 字段对应的参数示例:[["id","name"],["id","name"]...] 181 | * @param handler 182 | * 成功返回受影响的行数,如果字段或字段参数为null或空则返回0 183 | */ 184 | void insertBatch(List columns, List params, Handler> handler); 185 | 186 | /** 187 | * 插入一个对象,如果该对象不存在就新建如果该对象已经存在就更新 188 | * 189 | * @param obj 190 | * 对象 191 | * 192 | * @param handler 193 | * 结果集受影响的行数 194 | */ 195 | void replace(T obj, Handler> handler); 196 | 197 | /** 198 | * 更新一个对象中所有的属性包括null值,条件为对象中的主键值 199 | * 200 | * @param obj 201 | * 对象 202 | * 203 | * @param handler 204 | * 返回操作结果 205 | */ 206 | void updateAllById(T obj, Handler> handler); 207 | 208 | /** 209 | * 更新一个对象中所有的属性包括null值,条件为SqlAssist条件集
210 | * 211 | * @param obj 212 | * 对象 213 | * @param SqlAssist 214 | * sql帮助工具 215 | * 216 | * @param handler 217 | * 返回操作结果 218 | */ 219 | void updateAllByAssist(T obj, SqlAssist assist, Handler> handler); 220 | /** 221 | * 更新一个对象中属性不为null值,条件为对象中的主键值 222 | * 223 | * @param obj 224 | * 对象 225 | * @param handler 226 | * 返回操作结果 227 | */ 228 | void updateNonEmptyById(T obj, Handler> handler); 229 | 230 | /** 231 | * 更新一个对象中属性不为null值,条件为SqlAssist条件集 232 | * 233 | * @param obj 234 | * 对象 235 | * @param assist 236 | * 查询工具 237 | * @param handler 238 | * 返回操作结果 239 | */ 240 | void updateNonEmptyByAssist(T obj, SqlAssist assist, Handler> handler); 241 | 242 | /** 243 | * 通过主键值设置指定的列为空 244 | * 245 | * @param 246 | * @param primaryValue 247 | * 主键 248 | * @param columns 249 | * 要设置为null的列 250 | * 251 | * @param handler 252 | * 返回操作结果 253 | */ 254 | void updateSetNullById(S primaryValue, List columns, Handler> handler); 255 | 256 | /** 257 | * 通过Assist作为条件设置指定的列为空 258 | * 259 | * @param assist 260 | * sql帮助工具 261 | * @param columns 262 | * 要设置为null的列 263 | * 264 | * @param handler 265 | * 返回操作结果 266 | * @param nullable 267 | * 没有实际作用,用于做方法重载而已,可以传入null 268 | */ 269 | void updateSetNullByAssist(SqlAssist assist, List columns, Handler> handler); 270 | 271 | /** 272 | * 通过主键值删除对应的数据行 273 | * 274 | * @param obj 275 | * 主键值 276 | * @param handler 277 | * 返回操作结果 278 | */ 279 | void deleteById(S primaryValue, Handler> handler); 280 | /** 281 | * 通过SqlAssist条件集删除对应的数据行 282 | * 283 | * @param assist 284 | * 条件集 285 | * 286 | * @param handler 287 | * 返回操作结果 288 | */ 289 | void deleteByAssist(SqlAssist assist, Handler> handler); 290 | 291 | } 292 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLCommandImpl.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.AsyncResult; 6 | import io.vertx.core.Future; 7 | import io.vertx.core.Handler; 8 | import io.vertx.core.json.JsonObject; 9 | import io.vertx.sqlclient.PropertyKind; 10 | import io.vertx.sqlclient.Row; 11 | import io.vertx.sqlclient.RowSet; 12 | import io.vertx.sqlclient.Tuple; 13 | /** 14 | * 数据库命令执行器的默认实现 15 | * 16 | * @author Mirren 17 | * 18 | */ 19 | public class SQLCommandImpl implements SQLCommand { 20 | /** 语句 */ 21 | private SQLStatement statement; 22 | /** 执行器 */ 23 | private SQLExecute execute; 24 | /** 25 | * 初始化 26 | * 27 | * @param statement 28 | * @param execute 29 | */ 30 | public SQLCommandImpl(SQLStatement statement, SQLExecute execute) { 31 | super(); 32 | this.statement = statement; 33 | this.execute = execute; 34 | } 35 | 36 | @Override 37 | public void getCount(SqlAssist assist, Handler> handler) { 38 | SqlAndParams qp = statement.getCountSQL(assist); 39 | execute.execute(qp, res -> { 40 | if (res.succeeded()) { 41 | RowSet set = res.result(); 42 | if (set == null || !set.iterator().hasNext()) { 43 | handler.handle(Future.succeededFuture(0L)); 44 | } else { 45 | Long result = set.iterator().next().getLong(0); 46 | handler.handle(Future.succeededFuture(result)); 47 | } 48 | } else { 49 | handler.handle(Future.failedFuture(res.cause())); 50 | } 51 | }); 52 | } 53 | 54 | @Override 55 | public void selectAll(SqlAssist assist, Handler>> handler) { 56 | SqlAndParams qp = statement.selectAllSQL(assist); 57 | if (qp.succeeded()) { 58 | execute.queryAsList(qp, handler); 59 | } else { 60 | handler.handle(Future.failedFuture(qp.getSql())); 61 | } 62 | } 63 | 64 | @Override 65 | public void selectById(S primaryValue, String resultColumns, String tableAlias, String joinOrReference, 66 | Handler> handler) { 67 | SqlAndParams qp = statement.selectByIdSQL(primaryValue, resultColumns, tableAlias, joinOrReference); 68 | if (qp.succeeded()) { 69 | execute.queryAsObj(qp, handler); 70 | } else { 71 | handler.handle(Future.failedFuture(qp.getSql())); 72 | } 73 | } 74 | 75 | @Override 76 | public void selectSingleByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 77 | Handler> handler) { 78 | SqlAndParams qp = statement.selectByObjSQL(obj, resultColumns, tableAlias, joinOrReference, true); 79 | if (qp.succeeded()) { 80 | execute.queryAsObj(qp, handler); 81 | } else { 82 | handler.handle(Future.failedFuture(qp.getSql())); 83 | } 84 | } 85 | 86 | @Override 87 | public void selectByObj(T obj, String resultColumns, String tableAlias, String joinOrReference, 88 | Handler>> handler) { 89 | SqlAndParams qp = statement.selectByObjSQL(obj, resultColumns, tableAlias, joinOrReference, false); 90 | if (qp.succeeded()) { 91 | execute.queryAsList(qp, handler); 92 | } else { 93 | handler.handle(Future.failedFuture(qp.getSql())); 94 | } 95 | } 96 | 97 | @Override 98 | public void insertAll(T obj, Handler> handler) { 99 | SqlAndParams qp = statement.insertAllSQL(obj); 100 | if (qp.succeeded()) { 101 | execute.update(qp, handler); 102 | } else { 103 | handler.handle(Future.failedFuture(qp.getSql())); 104 | } 105 | } 106 | 107 | @Override 108 | public void insertNonEmpty(T obj, Handler> handler) { 109 | SqlAndParams qp = statement.insertNonEmptySQL(obj); 110 | if (qp.succeeded()) { 111 | execute.update(qp, handler); 112 | } else { 113 | handler.handle(Future.failedFuture(qp.getSql())); 114 | } 115 | } 116 | 117 | @Override 118 | public void insertNonEmptyGeneratedKeys(T obj, PropertyKind property, Handler> handler) { 119 | SqlAndParams qp = statement.insertNonEmptySQL(obj); 120 | if (qp.succeeded()) { 121 | execute.updateResult(qp, property, handler); 122 | } else { 123 | handler.handle(Future.failedFuture(qp.getSql())); 124 | } 125 | } 126 | 127 | @Override 128 | public void insertBatch(List list, Handler> handler) { 129 | SqlAndParams qp = statement.insertBatchSQL(list); 130 | if (qp.succeeded()) { 131 | execute.batch(qp, res -> { 132 | if (res.succeeded()) { 133 | handler.handle(Future.succeededFuture(res.result())); 134 | } else { 135 | handler.handle(Future.failedFuture(res.cause())); 136 | } 137 | }); 138 | } else { 139 | handler.handle(Future.failedFuture(qp.getSql())); 140 | } 141 | } 142 | 143 | @Override 144 | public void insertBatch(List columns, List params, Handler> handler) { 145 | SqlAndParams qp = statement.insertBatchSQL(columns, params); 146 | if (qp.succeeded()) { 147 | execute.batch(qp, res -> { 148 | if (res.succeeded()) { 149 | handler.handle(Future.succeededFuture(res.result())); 150 | } else { 151 | handler.handle(Future.failedFuture(res.cause())); 152 | } 153 | }); 154 | } else { 155 | handler.handle(Future.failedFuture(qp.getSql())); 156 | } 157 | } 158 | 159 | @Override 160 | public void replace(T obj, Handler> handler) { 161 | SqlAndParams qp = statement.replaceSQL(obj); 162 | if (qp.succeeded()) { 163 | execute.update(qp, handler); 164 | } else { 165 | handler.handle(Future.failedFuture(qp.getSql())); 166 | } 167 | } 168 | 169 | @Override 170 | public void updateAllById(T obj, Handler> handler) { 171 | SqlAndParams qp = statement.updateAllByIdSQL(obj); 172 | if (qp.succeeded()) { 173 | execute.update(qp, handler); 174 | } else { 175 | handler.handle(Future.failedFuture(qp.getSql())); 176 | } 177 | } 178 | 179 | @Override 180 | public void updateAllByAssist(T obj, SqlAssist assist, Handler> handler) { 181 | SqlAndParams qp = statement.updateAllByAssistSQL(obj, assist); 182 | if (qp.succeeded()) { 183 | execute.update(qp, handler); 184 | } else { 185 | handler.handle(Future.failedFuture(qp.getSql())); 186 | } 187 | } 188 | 189 | @Override 190 | public void updateNonEmptyById(T obj, Handler> handler) { 191 | SqlAndParams qp = statement.updateNonEmptyByIdSQL(obj); 192 | if (qp.succeeded()) { 193 | execute.update(qp, handler); 194 | } else { 195 | handler.handle(Future.failedFuture(qp.getSql())); 196 | } 197 | } 198 | 199 | @Override 200 | public void updateNonEmptyByAssist(T obj, SqlAssist assist, Handler> handler) { 201 | SqlAndParams qp = statement.updateNonEmptyByAssistSQL(obj, assist); 202 | if (qp.succeeded()) { 203 | execute.update(qp, handler); 204 | } else { 205 | handler.handle(Future.failedFuture(qp.getSql())); 206 | } 207 | } 208 | 209 | @Override 210 | public void updateSetNullById(S primaryValue, List columns, Handler> handler) { 211 | SqlAndParams qp = statement.updateSetNullByIdSQL(primaryValue, columns); 212 | if (qp.succeeded()) { 213 | execute.update(qp, handler); 214 | } else { 215 | handler.handle(Future.failedFuture(qp.getSql())); 216 | } 217 | } 218 | 219 | @Override 220 | public void updateSetNullByAssist(SqlAssist assist, List columns, Handler> handler) { 221 | SqlAndParams qp = statement.updateSetNullByAssistSQL(assist, columns); 222 | if (qp.succeeded()) { 223 | execute.update(qp, handler); 224 | } else { 225 | handler.handle(Future.failedFuture(qp.getSql())); 226 | } 227 | } 228 | 229 | @Override 230 | public void deleteById(S primaryValue, Handler> handler) { 231 | SqlAndParams qp = statement.deleteByIdSQL(primaryValue); 232 | if (qp.succeeded()) { 233 | execute.update(qp, handler); 234 | } else { 235 | handler.handle(Future.failedFuture(qp.getSql())); 236 | } 237 | } 238 | 239 | @Override 240 | public void deleteByAssist(SqlAssist assist, Handler> handler) { 241 | SqlAndParams qp = statement.deleteByAssistSQL(assist); 242 | if (qp.succeeded()) { 243 | execute.update(qp, handler); 244 | } else { 245 | handler.handle(Future.failedFuture(qp.getSql())); 246 | } 247 | } 248 | 249 | } 250 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecute.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.AsyncResult; 6 | import io.vertx.core.Handler; 7 | import io.vertx.core.json.JsonObject; 8 | import io.vertx.db2client.DB2Pool; 9 | import io.vertx.jdbcclient.JDBCPool; 10 | import io.vertx.mysqlclient.MySQLPool; 11 | import io.vertx.pgclient.PgPool; 12 | import io.vertx.sqlclient.PropertyKind; 13 | import io.vertx.sqlclient.Row; 14 | import io.vertx.sqlclient.RowSet; 15 | 16 | /** 17 | * SQL执行器 18 | * 19 | * @author Mirren 20 | * 21 | */ 22 | public interface SQLExecute { 23 | /** 24 | * 创建JDBC客户端实例 25 | * 26 | * @param client 27 | * @return 28 | */ 29 | static SQLExecute createJDBC(JDBCPool pool) { 30 | return new SQLExecuteImplJDBC(pool); 31 | } 32 | 33 | /** 34 | * 创建MySQL客户端实例 35 | * 36 | * @param client 37 | * @return 38 | */ 39 | static SQLExecute createMySQL(MySQLPool pool) { 40 | return new SQLExecuteImplMySQL(pool); 41 | } 42 | 43 | /** 44 | * 创建MySQL客户端实例 45 | * 46 | * @param client 47 | * @return 48 | */ 49 | static SQLExecute createPg(PgPool pool) { 50 | return new SQLExecuteImplPg(pool); 51 | } 52 | /** 53 | * 创建DB2客户端实例 54 | * 55 | * @param client 56 | * @return 57 | */ 58 | static SQLExecute createPg(DB2Pool pool) { 59 | return new SQLExecuteImplDB2(pool); 60 | } 61 | 62 | /** 63 | * 获取客户端 64 | * 65 | * @return 66 | */ 67 | T getClient(); 68 | 69 | /** 70 | * 执行查询 71 | * 72 | * @param qp 73 | * SQL语句与参数 74 | * @param handler 75 | * 返回结果 76 | */ 77 | void execute(SqlAndParams qp, Handler>> handler); 78 | 79 | /** 80 | * 执行查询 81 | * 82 | * @param qp 83 | * SQL语句与参数 84 | * @param handler 85 | * 返回结果 查询不到结果的时候返回null 86 | */ 87 | void queryAsObj(SqlAndParams qp, Handler> handler); 88 | 89 | /** 90 | * 执行查询 91 | * 92 | * @param qp 93 | * SQL语句与参数 94 | * @param handler 95 | * 返回结果 查询不到结果的时候返回不为null的空List 96 | */ 97 | void queryAsList(SqlAndParams qp, Handler>> handler); 98 | 99 | /** 100 | * 执行更新等操作得到受影响的行数 101 | * 102 | * @param qp 103 | * SQL语句与参数 104 | * 105 | * @param handler 106 | */ 107 | void update(SqlAndParams qp, Handler> handler); 108 | 109 | /** 110 | * 执行更新并操作结果,比如返回GENERATED_KEYS等:
111 | * 获取GENERATED_KEYS方法:property传入JDBCPool.GENERATED_KEYS得到结果后判断row!=null就执行row.get对应类型数据 112 | * 113 | * @param qp 114 | * SQL语句与参数 115 | * 116 | * @param handler 117 | */ 118 | void updateResult(SqlAndParams qp, PropertyKind property, Handler> handler); 119 | 120 | /** 121 | * 批量操作 122 | * 123 | * @param qp 124 | * SQL语句与批量参数 125 | * 126 | * @param handler 127 | * 返回结果 128 | */ 129 | void batch(SqlAndParams qp, Handler> handler); 130 | } 131 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecuteBase.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import io.vertx.core.AsyncResult; 7 | import io.vertx.core.Future; 8 | import io.vertx.core.Handler; 9 | import io.vertx.core.json.JsonObject; 10 | import io.vertx.sqlclient.Pool; 11 | import io.vertx.sqlclient.PropertyKind; 12 | import io.vertx.sqlclient.Row; 13 | import io.vertx.sqlclient.RowSet; 14 | 15 | /** 16 | * SQL操作的默认实现 17 | * 18 | * @author Mirren 19 | * 20 | */ 21 | public abstract class SQLExecuteBase { 22 | /** JDBC客户端 */ 23 | private Pool pool; 24 | 25 | public SQLExecuteBase(Pool pool) { 26 | super(); 27 | this.pool = pool; 28 | } 29 | 30 | public void execute(SqlAndParams qp, Handler>> handler) { 31 | if (qp.succeeded()) { 32 | if (qp.getParams() == null) { 33 | pool.query(qp.getSql()).execute(handler); 34 | } else { 35 | pool.preparedQuery(qp.getSql()).execute(qp.getParams(), handler); 36 | } 37 | } else { 38 | handler.handle(Future.failedFuture(qp.getSql())); 39 | } 40 | } 41 | 42 | public void queryAsObj(SqlAndParams qp, Handler> handler) { 43 | execute(qp, res -> { 44 | if (res.succeeded()) { 45 | RowSet rowSet = res.result(); 46 | if (rowSet == null || !rowSet.iterator().hasNext()) { 47 | handler.handle(Future.succeededFuture()); 48 | } else { 49 | Row row = rowSet.iterator().next(); 50 | handler.handle(Future.succeededFuture(row.toJson())); 51 | } 52 | } else { 53 | handler.handle(Future.failedFuture(res.cause())); 54 | } 55 | }); 56 | } 57 | 58 | public void queryAsList(SqlAndParams qp, Handler>> handler) { 59 | execute(qp, res -> { 60 | if (res.succeeded()) { 61 | RowSet rowSet = res.result(); 62 | if (rowSet == null || rowSet.size() <= 0) { 63 | handler.handle(Future.succeededFuture(new ArrayList<>())); 64 | } else { 65 | List list = new ArrayList<>(); 66 | for (Row row : rowSet) { 67 | list.add(row.toJson()); 68 | } 69 | handler.handle(Future.succeededFuture(list)); 70 | } 71 | } else { 72 | handler.handle(Future.failedFuture(res.cause())); 73 | } 74 | }); 75 | } 76 | 77 | public void update(SqlAndParams qp, Handler> handler) { 78 | execute(qp, res -> { 79 | if (res.succeeded()) { 80 | if (res.result() == null) { 81 | handler.handle(Future.succeededFuture(0)); 82 | } else { 83 | handler.handle(Future.succeededFuture(res.result().rowCount())); 84 | } 85 | } else { 86 | handler.handle(Future.failedFuture(res.cause())); 87 | } 88 | }); 89 | } 90 | 91 | public void updateResult(SqlAndParams qp, PropertyKind property, Handler> handler) { 92 | execute(qp, res -> { 93 | if (res.succeeded()) { 94 | if (property == null || res.result() == null) { 95 | handler.handle(Future.succeededFuture()); 96 | } else { 97 | handler.handle(Future.succeededFuture(res.result().property(property))); 98 | } 99 | } else { 100 | handler.handle(Future.failedFuture(res.cause())); 101 | } 102 | }); 103 | } 104 | 105 | public void batch(SqlAndParams qp, Handler> handler) { 106 | if (qp.succeeded()) { 107 | pool.preparedQuery(qp.getSql()).executeBatch(qp.getBatchParams(), res -> { 108 | if (res.succeeded()) { 109 | RowSet rowSet = res.result(); 110 | if (rowSet == null) { 111 | handler.handle(Future.succeededFuture(0)); 112 | } else { 113 | int count = rowSet.rowCount(); 114 | RowSet next = rowSet.next(); 115 | while (next != null) { 116 | count += next.rowCount(); 117 | next = next.next(); 118 | } 119 | handler.handle(Future.succeededFuture(count)); 120 | } 121 | } else { 122 | handler.handle(Future.failedFuture(res.cause())); 123 | } 124 | }); 125 | } else { 126 | handler.handle(Future.failedFuture(qp.getSql())); 127 | } 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecuteImplDB2.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import io.vertx.db2client.DB2Pool; 4 | 5 | /** 6 | * SQL操作DB2实现 7 | * 8 | * @author Mirren 9 | * 10 | */ 11 | public class SQLExecuteImplDB2 extends SQLExecuteBase implements SQLExecute { 12 | private DB2Pool pool; 13 | public SQLExecuteImplDB2(DB2Pool pool) { 14 | super(pool); 15 | this.pool = pool; 16 | } 17 | @Override 18 | public DB2Pool getClient() { 19 | return this.pool; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecuteImplJDBC.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import io.vertx.jdbcclient.JDBCPool; 4 | 5 | /** 6 | * SQL操作JDBC实现 7 | * 8 | * @author Mirren 9 | * 10 | */ 11 | public class SQLExecuteImplJDBC extends SQLExecuteBase implements SQLExecute { 12 | private JDBCPool pool; 13 | public SQLExecuteImplJDBC(JDBCPool pool) { 14 | super(pool); 15 | this.pool = pool; 16 | } 17 | @Override 18 | public JDBCPool getClient() { 19 | return pool; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecuteImplMySQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import io.vertx.mysqlclient.MySQLPool; 4 | 5 | /** 6 | * SQL操作MySQL版实现 7 | * 8 | * @author Mirren 9 | * 10 | */ 11 | public class SQLExecuteImplMySQL extends SQLExecuteBase implements SQLExecute { 12 | private MySQLPool pool; 13 | public SQLExecuteImplMySQL(MySQLPool pool) { 14 | super(pool); 15 | this.pool = pool; 16 | } 17 | @Override 18 | public MySQLPool getClient() { 19 | return this.pool; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLExecuteImplPg.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import io.vertx.pgclient.PgPool; 4 | 5 | /** 6 | * SQL操作PostgreSQL版实现 7 | * 8 | * @author Mirren 9 | * 10 | */ 11 | public class SQLExecuteImplPg extends SQLExecuteBase implements SQLExecute { 12 | private PgPool pool; 13 | public SQLExecuteImplPg(PgPool pool) { 14 | super(pool); 15 | this.pool = pool; 16 | } 17 | @Override 18 | public PgPool getClient() { 19 | return this.pool; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SQLStatement.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.lang.reflect.Constructor; 4 | import java.util.List; 5 | 6 | import io.vertx.ext.sql.assist.sql.MySQLStatementSQL; 7 | import io.vertx.sqlclient.Tuple; 8 | 9 | /** 10 | * SQL执行语句 11 | * 12 | * @author Mirren 13 | * 14 | */ 15 | public interface SQLStatement { 16 | /** SQLStatement的使用哪个类的key */ 17 | final static String PROVIDER_CLASS_KEY = "VQA_SQL_STATEMENT_PROVIDER_CLASS_NAME"; 18 | 19 | /** 20 | * 设置SQL语句使用哪个类实现 21 | * 22 | * @param statementImplClass 23 | */ 24 | static void register(Class statementImplClass) { 25 | System.setProperty(PROVIDER_CLASS_KEY, statementImplClass.getName()); 26 | } 27 | /** 28 | * 设置SQL语句使用哪个类实现 29 | * 30 | * @param className 31 | */ 32 | static void register(String className) { 33 | System.setProperty(PROVIDER_CLASS_KEY, className); 34 | } 35 | /** 36 | * 创建实例,默认使用MySQL规范实现,如果使用其他数据库可以使用{@link #register(Class) }注册或者使用{@link #create(Class, Class)}方法 37 | * 38 | * @param entityClass 39 | * 实体类,类必须包含{@link Table} {@link TableId} {@link TableColumn}注解 40 | * @return 41 | */ 42 | static SQLStatement create(Class entityClass) { 43 | String className = System.getProperty(PROVIDER_CLASS_KEY); 44 | if (className == null) { 45 | return new MySQLStatementSQL(entityClass); 46 | } 47 | try { 48 | Class forClass = Class.forName(className); 49 | Constructor constructor = forClass.getConstructor(Class.class); 50 | return (SQLStatement) constructor.newInstance(entityClass); 51 | } catch (Exception e) { 52 | throw new RuntimeException(e); 53 | } 54 | } 55 | /** 56 | * 创建实例 57 | * 58 | * @param entityClass 59 | * 实体类,类必须包含{@link Table} {@link TableId} {@link TableColumn}注解 60 | * @param statementClass 61 | * 实现了{@link SQLStatement}的类 62 | * @return 63 | */ 64 | static SQLStatement create(Class entityClass, Class statementClass) { 65 | try { 66 | Constructor constructor = statementClass.getConstructor(Class.class); 67 | return (SQLStatement) constructor.newInstance(entityClass); 68 | } catch (Exception e) { 69 | throw new RuntimeException(e); 70 | } 71 | } 72 | 73 | /** 74 | * 获得数据总行数SQL语句
75 | * 76 | * @param assist 77 | * @return 返回:sql or sql与params 78 | */ 79 | SqlAndParams getCountSQL(SqlAssist assist); 80 | 81 | /** 82 | * 获得查询全部数据SQL语句与参数
83 | * 84 | * @param assist 85 | * 查询工具 86 | * @return 返回:sql or sql与params 87 | */ 88 | SqlAndParams selectAllSQL(SqlAssist assist); 89 | 90 | /** 91 | * 通过主键查询一个对象
92 | * 返回:sql or sql与params 93 | * 94 | * @param 95 | * @param primaryValue 96 | * 主键的值 97 | * @param resultColumns 98 | * 指定返回列 格式 [table.]列名 [as 类的属性名字],... 99 | * @param tableAlias 100 | * 当前表的别名 101 | * @param joinOrReference 102 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 103 | * @return 104 | */ 105 | SqlAndParams selectByIdSQL(S primaryValue, String resultColumns, String tableAlias, String joinOrReference); 106 | /** 107 | * 将对象属性不为null的属性作为条件查询出数据 108 | * 109 | * @param obj 110 | * 对象 111 | * @param resultColumns 112 | * 自定义返回列 113 | * @param tableAlias 114 | * 当前表的别名 115 | * @param joinOrReference 116 | * 多表查询或表连接的语句,示例 inner join table2 as t2 on t.id=t2.id 117 | * @param single 118 | * 是否支取一条数据true支取一条,false取全部 119 | * @return 返回sql 或 sql与params 120 | * 121 | */ 122 | SqlAndParams selectByObjSQL(T obj, String resultColumns, String tableAlias, String joinOrReference, boolean single); 123 | /** 124 | * 插入一个对象包括属性值为null的值
125 | * 126 | * @param obj 127 | * @return 返回:sql 或者 sql与params 128 | */ 129 | SqlAndParams insertAllSQL(T obj); 130 | 131 | /** 132 | * 插入一个对象,只插入对象中值不为null的属性
133 | * 134 | * @param obj 135 | * 对象 136 | * @return 返回:sql 或 sql与params 137 | */ 138 | SqlAndParams insertNonEmptySQL(T obj); 139 | /** 140 | * 批量添加全部所有字段 141 | * 142 | * @param list 143 | * 对象 144 | */ 145 | SqlAndParams insertBatchSQL(List list); 146 | /** 147 | * 批量添加自定字段 148 | * 149 | * @param column 150 | * 字段的名称示例:["id","name",...] 151 | * @param params 152 | * 字段对应的参数示例:[["id","name"],["id","name"]...] 153 | */ 154 | SqlAndParams insertBatchSQL(List columns, List params); 155 | 156 | /** 157 | * 插入一个对象,如果该对象不存在就新建如果该对象已经存在就更新 158 | * 159 | * @param obj 160 | * 对象 161 | * @return 返回:sql 或 sql与params 162 | */ 163 | SqlAndParams replaceSQL(T obj); 164 | /** 165 | * 更新一个对象中所有的属性包括null值,条件为对象中的主键值 166 | * 167 | * @param obj 168 | * @return 返回:sql or sql与params, 如果对象中的id为null将会返回SQL:"there is no primary key 169 | * in your SQL statement" 170 | */ 171 | SqlAndParams updateAllByIdSQL(T obj); 172 | /** 173 | * 更新一个对象中所有的属性包括null值,条件为SqlAssist条件集
174 | * 175 | * @param obj 176 | * @param assist 177 | * @return 返回:sql or 178 | * sql与params如果SqlAssist对象或者对象的Condition为null将会返回SQL:"SqlAssist or 179 | * SqlAssist.condition is null" 180 | */ 181 | SqlAndParams updateAllByAssistSQL(T obj, SqlAssist assist); 182 | /** 183 | * 更新一个对象中属性不为null值,条件为对象中的主键值 184 | * 185 | * @param obj 186 | * 对象 187 | * @return 返回:sql or sql与params , 如果id为null或者没有要更新的数据将返回SQL:"there is no 188 | * primary key in your SQL statement" 189 | */ 190 | SqlAndParams updateNonEmptyByIdSQL(T obj); 191 | 192 | /** 193 | * 将对象中属性值不为null的进行更新,条件为SqlAssist条件集 194 | * 195 | * @param obj 196 | * 对象 197 | * @param assist 198 | * 查询工具 199 | * @return 返回:sql or sql与params , 如果assist为null将会返回sql:"SqlAssist or 200 | * SqlAssist.condition is null" 201 | */ 202 | SqlAndParams updateNonEmptyByAssistSQL(T obj, SqlAssist assist); 203 | /** 204 | * 通过id将指定列设置为null 205 | * 206 | * @param 207 | * @param primaryValue 208 | * id 209 | * @param columns 210 | * 要设置为空的列 211 | * @return 212 | */ 213 | SqlAndParams updateSetNullByIdSQL(S primaryValue, List columns); 214 | /** 215 | * 216 | * 将指定的列设置为空,条件为SqlAssist条件集 217 | * 218 | * @param assist 219 | * 查询工具 220 | * @param columns 221 | * 要设置为空的列 222 | * @return 返回:sql or sql与params , 如果assist为null将会返回sql:"SqlAssist or 223 | * SqlAssist.condition is null" 224 | * @return 225 | */ 226 | SqlAndParams updateSetNullByAssistSQL(SqlAssist assist, List columns); 227 | /** 228 | * 通过主键值删除对应的数据行 229 | * 230 | * @param primaryValue 231 | * id值 232 | * @return 返回:sql or sql与params , 如果id为null或者没有要更新的数据将返回SQL:"there is no 233 | * primary key in your SQL statement" 234 | */ 235 | SqlAndParams deleteByIdSQL(S primaryValue); 236 | /** 237 | * 通过SqlAssist条件集删除对应的数据行 238 | * 239 | * @param assist 240 | * 查询工具 241 | * @return 返回:sql or sql与params , 如果assist为null将会返回sql: "SqlAssist or 242 | * SqlAssist.condition is null" 243 | */ 244 | SqlAndParams deleteByAssistSQL(SqlAssist assist); 245 | 246 | } 247 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SqlAndParams.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.sqlclient.Tuple; 6 | 7 | /** 8 | * 用于生成数据库语句时返回SQL语句与参数 9 | * 10 | * @author Mirren 11 | * 12 | */ 13 | public class SqlAndParams { 14 | /** SQL语句 */ 15 | private String sql; 16 | /** 参数 */ 17 | private Tuple params; 18 | /** 批量参数 */ 19 | private List batchParams; 20 | /** 生成语句是否成功 */ 21 | private boolean succeeded = true; 22 | /** 23 | * 创建一个新的SqlAndParams 24 | */ 25 | public SqlAndParams() { 26 | super(); 27 | } 28 | /** 29 | * 创建一个新的SqlAndParams 30 | * 31 | * @param sql 32 | * SQL语句 33 | */ 34 | public SqlAndParams(String sql) { 35 | super(); 36 | this.sql = sql; 37 | } 38 | 39 | /** 40 | * 创建一个新的SqlAndParams 41 | * 42 | * @param succeeded 43 | * 是否成功,true=成功,false=失败 44 | * @param sql 45 | * SQL语句或者失败语句 46 | */ 47 | public SqlAndParams(boolean succeeded, String sql) { 48 | super(); 49 | this.succeeded = succeeded; 50 | this.sql = sql; 51 | } 52 | 53 | /** 54 | * 创建一个新的SqlAndParams 55 | * 56 | * @param sql 57 | * SQL语句 58 | * @param params 59 | * 参数 60 | */ 61 | public SqlAndParams(String sql, Tuple params) { 62 | super(); 63 | this.sql = sql; 64 | this.params = params; 65 | } 66 | /** 67 | * 创建一个新的SqlAndParams 68 | * 69 | * @param sql 70 | * SQL语句 71 | * @param batchParams 72 | * 参数集合 73 | */ 74 | public SqlAndParams(String sql, List batchParams) { 75 | super(); 76 | this.sql = sql; 77 | this.batchParams = batchParams; 78 | } 79 | 80 | /** 81 | * 获得SQL语句,如果失败时则为错误语句 82 | * 83 | * @return 84 | */ 85 | public String getSql() { 86 | return sql; 87 | } 88 | /** 89 | * 设置SQL语句,如果失败时则为错误语句 90 | * 91 | * @param sql 92 | */ 93 | public SqlAndParams setSql(String sql) { 94 | this.sql = sql; 95 | return this; 96 | } 97 | /** 98 | * 获得参数 99 | * 100 | * @return 101 | */ 102 | public Tuple getParams() { 103 | return params; 104 | } 105 | /** 106 | * 设置参数 107 | */ 108 | public SqlAndParams setParams(Tuple params) { 109 | this.params = params; 110 | return this; 111 | } 112 | 113 | /** 114 | * 获取参数集合 115 | * 116 | * @return 117 | */ 118 | public List getBatchParams() { 119 | return batchParams; 120 | } 121 | /** 122 | * 设置参数集合 123 | * 124 | * @param batchParams 125 | */ 126 | public SqlAndParams setBatchParams(List batchParams) { 127 | this.batchParams = batchParams; 128 | return this; 129 | } 130 | /** 131 | * 获取是否成功 132 | * 133 | * @return 134 | */ 135 | public boolean succeeded() { 136 | return succeeded; 137 | } 138 | /** 139 | * 设置是否成功 140 | * 141 | * @param succeeded 142 | */ 143 | public SqlAndParams setSucceeded(boolean succeeded) { 144 | this.succeeded = succeeded; 145 | return this; 146 | } 147 | 148 | @Override 149 | public String toString() { 150 | StringBuilder result = new StringBuilder(); 151 | result.append("SqlAndParams [succeeded=" + succeeded + ","); 152 | result.append("sql=" + sql + ","); 153 | result.append("params=" + (params == null ? "null" : params.deepToString()) + ","); 154 | result.append("batchParams="); 155 | if (batchParams == null) { 156 | result.append("null"); 157 | } else { 158 | result.append("("); 159 | for (Tuple tuple : batchParams) { 160 | result.append(tuple == null ? "null" : tuple.deepToString()); 161 | } 162 | result.append(")"); 163 | } 164 | result.append("]"); 165 | return result.toString(); 166 | } 167 | 168 | } 169 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SqlAssist.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import io.vertx.core.json.JsonArray; 7 | import io.vertx.core.json.JsonObject; 8 | 9 | /** 10 | * SQL查询帮助类 11 | * 12 | * @author Mirren 13 | * 14 | */ 15 | public class SqlAssist { 16 | /** 去重 */ 17 | private String distinct; 18 | /** 分组 */ 19 | private String groupBy; 20 | /** 分组条件 */ 21 | private String having; 22 | /** 分组条件值 */ 23 | private JsonArray havingValue; 24 | /** 排序 */ 25 | private String order; 26 | /** 数据分页第几页 */ 27 | private Integer page; 28 | /** 数据分页开始行 */ 29 | private Integer startRow; 30 | /** 每次取多少行数据 */ 31 | private Integer rowSize; 32 | /** 设置自定义返回列 */ 33 | private String resultColumn; 34 | /** 连接语句或多表查询语句 */ 35 | private String joinOrReference; 36 | /** 条件集 */ 37 | private List> condition = null; 38 | /** 自定义属性 */ 39 | private Object custom; 40 | 41 | public SqlAssist() { 42 | super(); 43 | } 44 | 45 | /** 46 | * 该构造方法用于使用SqlAssist的静态条件方法,动态添加条件 47 | * 48 | * @param require 49 | * 示例:查询等于使用 SqlWhereCondition.andEq("A.ID",10)... 50 | * {@link SqlWhereCondition#andEq(String, Object)} 51 | */ 52 | public SqlAssist(SqlWhereCondition... require) { 53 | this.setConditions(require); 54 | } 55 | 56 | /** 57 | * 将当前对象装换为json字符串 58 | * 59 | * @return 60 | */ 61 | public String toJsonStr() { 62 | return toJson().toString(); 63 | } 64 | 65 | /** 66 | * 将当前对象装换为JsonObject 67 | * 68 | * @return 69 | */ 70 | public JsonObject toJson() { 71 | JsonObject json = new JsonObject(); 72 | if (distinct != null) { 73 | json.put("distinct", distinct); 74 | } 75 | if (groupBy != null) { 76 | json.put("groupBy", groupBy); 77 | } 78 | if (having != null) { 79 | json.put("having", having); 80 | } 81 | if (havingValue != null) { 82 | json.put("havingValue", havingValue); 83 | } 84 | if (order != null) { 85 | json.put("order", order); 86 | } 87 | if (page != null) { 88 | json.put("page", page); 89 | } 90 | if (startRow != null) { 91 | json.put("startRow", startRow); 92 | } 93 | if (rowSize != null) { 94 | json.put("rowSize", rowSize); 95 | } 96 | if (resultColumn != null) { 97 | json.put("resultColumn", resultColumn); 98 | } 99 | if (joinOrReference != null) { 100 | json.put("joinOrReference", joinOrReference); 101 | } 102 | if (custom != null) { 103 | json.put("custom", custom); 104 | } 105 | if (condition != null) { 106 | JsonArray array = new JsonArray(); 107 | condition.forEach(va -> { 108 | array.add(va.toJson()); 109 | }); 110 | json.put("condition", array); 111 | } 112 | return json; 113 | } 114 | 115 | /** 116 | * 将JsonObject对象装换为SqlAssist 117 | * 118 | * @param obj 119 | * @return 120 | */ 121 | public static SqlAssist fromJson(JsonObject obj) { 122 | if (obj == null || obj.isEmpty()) { 123 | return null; 124 | } 125 | SqlAssist assist = new SqlAssist(); 126 | assist.setPage(obj.getInteger("page")); 127 | assist.setStartRow(obj.getInteger("startRow")); 128 | assist.setRowSize(obj.getInteger("rowSize")); 129 | assist.setDistinct(obj.getString("distinct")); 130 | assist.setGroupBy(obj.getString("groupBy")); 131 | assist.setHaving(obj.getString("having"), obj.getJsonArray("havingValue")); 132 | assist.setOrders(obj.getString("order")); 133 | assist.setResultColumn(obj.getString("resultColumn")); 134 | assist.setJoinOrReference(obj.getString("joinOrReference")); 135 | assist.setCustom(obj.getValue("custom")); 136 | if (obj.getValue("condition") instanceof JsonArray) { 137 | List> list = new ArrayList<>(); 138 | obj.getJsonArray("condition").forEach(va -> { 139 | list.add(SqlWhereCondition.fromJson((JsonObject) va)); 140 | }); 141 | assist.setCondition(list); 142 | } 143 | return assist; 144 | } 145 | 146 | /** 147 | * 添加单个查询条件,参数为{@link SqlWhereCondition} ,推荐使用SqlWhereCondition的静态条件方法添加条件; 148 | * 149 | * @param require 150 | * 示例:查询等于使用 SqlWhereCondition.andEq("A.ID",10)... 151 | * {@link SqlWhereCondition#andEq(String, Object)} 152 | */ 153 | public SqlAssist setConditions(SqlWhereCondition require) { 154 | if (this.condition == null) { 155 | this.condition = new ArrayList>(); 156 | if (require.getRequire() != null) { 157 | String req = require.getRequire().trim(); 158 | if (req.toLowerCase().startsWith("and ") || req.toLowerCase().startsWith("or ")) { 159 | require.setRequire(req.substring(req.indexOf(" ") + 1)+" "); 160 | } 161 | } 162 | } 163 | this.condition.add(require); 164 | return this; 165 | } 166 | 167 | /** 168 | * 添加多个查询条件,参数为{@ SqlWhereCondition},推荐使用SqlWhereCondition的静态条件方法添加条件; 169 | * 170 | * @param require 171 | * 示例:查询等于使用 SqlWhereCondition.andEq("A.ID",10)... 172 | * {@link SqlWhereCondition#andEq(String, Object)} 173 | */ 174 | public SqlAssist setConditions(SqlWhereCondition... require) { 175 | if (this.condition == null) { 176 | this.condition = new ArrayList>(); 177 | } 178 | for (int i = 0; i < require.length; i++) { 179 | if (i == 0 && this.condition.size() == 0) { 180 | if (require[i].getRequire() != null) { 181 | String req = require[i].getRequire().trim(); 182 | if (req.toLowerCase().startsWith("and ") || req.toLowerCase().startsWith("or ")) { 183 | require[i].setRequire(req.substring(req.indexOf(" ") + 1)+" "); 184 | } 185 | } 186 | } 187 | this.condition.add(require[i]); 188 | } 189 | return this; 190 | } 191 | 192 | /** 193 | * 添加查询条件,该方法一般用于初始化,因为会将现有的条件集清空,既this.condition=conditions 194 | * 195 | * @param conditions 196 | * @return 197 | */ 198 | private SqlAssist setCondition(List> conditions) { 199 | this.condition = conditions; 200 | return this; 201 | } 202 | 203 | /** 204 | * 添加并且条件,列名与表达式
205 | * 示例: column = id IS NULL
206 | * SQL: [and] id IS NULL 207 | * 208 | * @param column 209 | * 列名:如果表中存在相同列名使用表名.列名 210 | * @return 211 | */ 212 | public SqlAssist and(String column) { 213 | this.setConditions(SqlWhereCondition.and(column)); 214 | return this; 215 | } 216 | 217 | /** 218 | * 添加或者条件,列名与表达式
219 | * 示例: column = id IS NULL
220 | * SQL: [or] id IS NULL 221 | * 222 | * @param column 223 | * 列名:如果表中存在相同列名使用表名.列名 224 | * @return 225 | */ 226 | public SqlAssist or(String column) { 227 | this.setConditions(SqlWhereCondition.or(column)); 228 | return this; 229 | } 230 | 231 | /** 232 | * 添加并且条件,列名与表达式
233 | * 示例: column = id
234 | * SQL: [and] id IS NULL 235 | * 236 | * @param column 237 | * 列名:如果表中存在相同列名使用表名.列名 238 | * @return 239 | */ 240 | public SqlAssist andIsNull(String column) { 241 | this.setConditions(SqlWhereCondition.andIsNull(column)); 242 | return this; 243 | } 244 | 245 | /** 246 | * 添加或者条件,列名与表达式
247 | * 示例: column = id
248 | * SQL: [or] id IS NULL 249 | * 250 | * @param column 251 | * 列名:如果表中存在相同列名使用表名.列名 252 | * @return 253 | */ 254 | public SqlAssist orIsNull(String column) { 255 | this.setConditions(SqlWhereCondition.orIsNull(column)); 256 | return this; 257 | } 258 | 259 | /** 260 | * 添加并且条件,列名与表达式
261 | * 示例: column = id
262 | * SQL: [and] id IS NOT NULL 263 | * 264 | * @param column 265 | * 列名:如果表中存在相同列名使用表名.列名 266 | * @return 267 | */ 268 | public SqlAssist andIsNotNull(String column) { 269 | this.setConditions(SqlWhereCondition.andIsNotNull(column)); 270 | return this; 271 | } 272 | 273 | /** 274 | * 添加或者条件,列名与表达式
275 | * 示例: column = id
276 | * SQL: [or] id IS NOT NULL 277 | * 278 | * @param column 279 | * 列名:如果表中存在相同列名使用表名.列名 280 | * @return 281 | */ 282 | public SqlAssist orIsNotNull(String column) { 283 | this.setConditions(SqlWhereCondition.orIsNotNull(column)); 284 | return this; 285 | } 286 | 287 | /** 288 | * 添加并且等于条件
289 | * 示例: column = id ,value =1
290 | * SQL: [and] id = 1 291 | * 292 | * @param column 293 | * 列名:如果表中存在相同列名使用表名.列名 294 | * @param value 295 | * 条件值 296 | * @return 297 | */ 298 | public SqlAssist andEq(String column, T value) { 299 | this.setConditions(SqlWhereCondition.andEq(column, value)); 300 | return this; 301 | } 302 | 303 | /** 304 | * 添加或者等于条件
305 | * 示例: column = id ,value =1
306 | * SQL: [or] id = 1 307 | * 308 | * @param column 309 | * 列名:如果表中存在相同列名使用表名.列名 310 | * @param value 311 | * 条件值 312 | * @return 313 | */ 314 | public SqlAssist orEq(String column, T value) { 315 | this.setConditions(SqlWhereCondition.orEq(column, value)); 316 | return this; 317 | } 318 | 319 | /** 320 | * 添加并且不等于条件
321 | * 示例: column = id ,value =1
322 | * SQL: [and] id <> 1 323 | * 324 | * @param column 325 | * 列名:如果表中存在相同列名使用表名.列名 326 | * @param value 327 | * 条件值 328 | * @return 329 | */ 330 | public SqlAssist andNeq(String column, T value) { 331 | this.setConditions(SqlWhereCondition.andNeq(column, value)); 332 | return this; 333 | } 334 | 335 | /** 336 | * 添加或者不等于条件
337 | * 示例: column = id ,value =1
338 | * SQL: [or] id <> 1 339 | * 340 | * @param column 341 | * 列名:如果表中存在相同列名使用表名.列名 342 | * @param value 343 | * 条件值 344 | * @return 345 | */ 346 | public SqlAssist orNeq(String column, T value) { 347 | this.setConditions(SqlWhereCondition.orNeq(column, value)); 348 | return this; 349 | } 350 | 351 | /** 352 | * 添加并且小于条件
353 | * 示例: column = id ,value =1
354 | * SQL: [and] id < 1 355 | * 356 | * @param column 357 | * 列名:如果表中存在相同列名使用表名.列名 358 | * @param value 359 | * 条件值 360 | * @return 361 | */ 362 | public SqlAssist andLt(String column, T value) { 363 | this.setConditions(SqlWhereCondition.andLt(column, value)); 364 | return this; 365 | } 366 | 367 | /** 368 | * 添加或者小于条件
369 | * 示例: column = id ,value =1
370 | * SQL: [or] id < 1 371 | * 372 | * @param column 373 | * 列名:如果表中存在相同列名使用表名.列名 374 | * @param value 375 | * 条件值 376 | * @return 377 | */ 378 | public SqlAssist orLt(String column, T value) { 379 | this.setConditions(SqlWhereCondition.orLt(column, value)); 380 | return this; 381 | } 382 | 383 | /** 384 | * 添加并且小于等于条件
385 | * 示例: column = id ,value =1
386 | * SQL: [and] id <= 1 387 | * 388 | * @param column 389 | * 列名:如果表中存在相同列名使用表名.列名 390 | * @param value 391 | * 条件值 392 | * @return 393 | */ 394 | public SqlAssist andLte(String column, T value) { 395 | this.setConditions(SqlWhereCondition.andLte(column, value)); 396 | return this; 397 | } 398 | 399 | /** 400 | * 添加或者小于等于条件
401 | * 示例: column = id ,value =1
402 | * SQL: [or] id <= 1 403 | * 404 | * @param column 405 | * 列名:如果表中存在相同列名使用表名.列名 406 | * @param value 407 | * 条件值 408 | * @return 409 | */ 410 | public SqlAssist orLte(String column, T value) { 411 | this.setConditions(SqlWhereCondition.orLte(column, value)); 412 | return this; 413 | } 414 | 415 | /** 416 | * 添加并且大于条件
417 | * 示例: column = id ,value =1
418 | * SQL: [and] id > 1 419 | * 420 | * @param column 421 | * 列名:如果表中存在相同列名使用表名.列名 422 | * @param value 423 | * 条件值 424 | * @return 425 | */ 426 | public SqlAssist andGt(String column, T value) { 427 | this.setConditions(SqlWhereCondition.andGt(column, value)); 428 | return this; 429 | } 430 | 431 | /** 432 | * 添加或者大于条件
433 | * 示例: column = id ,value =1
434 | * SQL: [or] id > 1 435 | * 436 | * @param column 437 | * 列名:如果表中存在相同列名使用表名.列名 438 | * @param value 439 | * 条件值 440 | * @return 441 | */ 442 | public SqlAssist orGt(String column, T value) { 443 | this.setConditions(SqlWhereCondition.orGt(column, value)); 444 | return this; 445 | } 446 | 447 | /** 448 | * 添加并且大于等于条件
449 | * 示例: column = id ,value =1
450 | * SQL: [and] id >= 1 451 | * 452 | * @param column 453 | * 列名:如果表中存在相同列名使用表名.列名 454 | * @param value 455 | * 条件值 456 | * @return 457 | */ 458 | public SqlAssist andGte(String column, T value) { 459 | this.setConditions(SqlWhereCondition.andGte(column, value)); 460 | return this; 461 | } 462 | 463 | /** 464 | * 添加或者大于等于条件
465 | * 示例: column = id ,value =1
466 | * SQL: [or] id >= 1 467 | * 468 | * @param column 469 | * 列名:如果表中存在相同列名使用表名.列名 470 | * @param value 471 | * 条件值 472 | * @return 473 | */ 474 | public SqlAssist orGte(String column, T value) { 475 | this.setConditions(SqlWhereCondition.orGte(column, value)); 476 | return this; 477 | } 478 | 479 | /** 480 | * 添加并且like条件
481 | * 示例: column = id ,value =%1%
482 | * SQL: [and] id like %1% 483 | * 484 | * @param column 485 | * 列名:如果表中存在相同列名使用表名.列名 486 | * @param value 487 | * 条件值 488 | * @return 489 | */ 490 | public SqlAssist andLike(String column, T value) { 491 | this.setConditions(SqlWhereCondition.andLike(column, value)); 492 | return this; 493 | } 494 | 495 | /** 496 | * 添加或者like条件
497 | * 示例: column = id ,value =%1%
498 | * SQL: [or] id like %1% 499 | * 500 | * @param column 501 | * 列名:如果表中存在相同列名使用表名.列名 502 | * @param value 503 | * 条件值 504 | * @return 505 | */ 506 | public SqlAssist orLike(String column, T value) { 507 | this.setConditions(SqlWhereCondition.orLike(column, value)); 508 | return this; 509 | } 510 | 511 | /** 512 | * 添加并且like条件
513 | * 示例: column = id ,value =%1%
514 | * SQL: [and] id not like %1% 515 | * 516 | * @param column 517 | * 列名:如果表中存在相同列名使用表名.列名 518 | * @param value 519 | * 条件值 520 | * @return 521 | */ 522 | public SqlAssist andNotLike(String column, T value) { 523 | this.setConditions(SqlWhereCondition.andNotLike(column, value)); 524 | return this; 525 | } 526 | 527 | /** 528 | * 添加或者like条件
529 | * 示例: column = id ,value =%1%
530 | * SQL: [or] id not like %1% 531 | * 532 | * @param column 533 | * 列名:如果表中存在相同列名使用表名.列名 534 | * @param value 535 | * 条件值 536 | * @return 537 | */ 538 | public SqlAssist orNotLike(String column, T value) { 539 | this.setConditions(SqlWhereCondition.orNotLike(column, value)); 540 | return this; 541 | } 542 | 543 | /** 544 | * 添加自定义查询条件 :
545 | * 示例: prefix= and id in(select tid from table where w=?) , value=1
546 | * SQL: and id in(select tid from table where w=1) 547 | * 548 | * @param prefix 549 | * SQL语句 550 | * @param value 551 | * 条件值 552 | * @return 553 | */ 554 | public SqlAssist customCondition(String prefix, T value) { 555 | this.setConditions(SqlWhereCondition.customCondition(prefix, value)); 556 | return this; 557 | } 558 | 559 | /** 560 | * 自定义查询条件 :
561 | * 示例 :prefix=and id in(?,?,?),value=1,2,3
562 | * SQL: and id in(1,2,3) 563 | * 564 | * @param prefix 565 | * SQL语句 566 | * @param value 567 | * 条件值 568 | * @return 569 | */ 570 | public SqlAssist customCondition(String prefix, Object... value) { 571 | this.setConditions(SqlWhereCondition.customCondition(prefix, value)); 572 | return this; 573 | } 574 | 575 | /** 576 | * 获得一个排序对象,将(列名)参数1 按 参数2排序(true=ASC/false=DESC)
577 | * ;如果表中存在相同列名使用表名.列名,如果不存在相同列名可以直接列名
578 | * 579 | * @param column 580 | * 列名 581 | * @param mode 582 | * 排序类型,true=asc,false=desc 583 | * @return 584 | */ 585 | public static String order(String column, boolean mode) { 586 | if (mode) { 587 | return column + " asc "; 588 | } else { 589 | return column + " desc "; 590 | } 591 | } 592 | 593 | /** 594 | * 设置排序,通过SqlAssist.order(列名,排序方式)
595 | * 示例:assist.setOrder(SqlAssist.order("id",true))//将id正序排序 596 | * 597 | * @param order 598 | * {@link #order(String column, boolean mode)} 599 | * @return 600 | */ 601 | public SqlAssist setOrders(String... order) { 602 | if (order == null || order.length == 0) { 603 | this.order = null; 604 | return this; 605 | } 606 | if (this.order == null) { 607 | this.order = " order by "; 608 | } 609 | StringBuffer buffer = new StringBuffer(); 610 | for (String od : order) { 611 | buffer.append(od); 612 | } 613 | this.order += buffer; 614 | return this; 615 | } 616 | 617 | /** 618 | * 设置一个编辑好的order,该方法一般用于初始化,因为会将现有的order清除,既order=参数order 619 | * 620 | * @param order 621 | * @return 622 | */ 623 | private SqlAssist setOrders(String order) { 624 | this.order = order; 625 | return this; 626 | } 627 | 628 | /** 629 | * 获得排序 630 | * 631 | * @return 632 | */ 633 | public String getOrder() { 634 | return order; 635 | } 636 | 637 | /** 638 | * 获取分组 639 | * 640 | * @return 641 | */ 642 | public String getGroupBy() { 643 | return groupBy; 644 | } 645 | 646 | /** 647 | * 设置分组 示例传入: id,type
648 | * SQL: GROUP BY id,type 649 | * 650 | * @param groupBy 651 | * 要分组的列名比如id,type 652 | * @return 653 | */ 654 | public SqlAssist setGroupBy(String groupBy) { 655 | this.groupBy = groupBy; 656 | return this; 657 | } 658 | 659 | /** 660 | * 获取分组条件 661 | * 662 | * @return 663 | */ 664 | public String getHaving() { 665 | return having; 666 | } 667 | 668 | /** 669 | * 设置分组条件
670 | * 示例: having= id > ? and type=? values=[1,2]
671 | * SQL: having id>1 and type=2 672 | * 673 | * @param having 674 | * 表达式,值以?号占位,示例: id > ? and type=? 675 | * @param values 676 | * 传入值 new JsonArray().add(1).add(2) 677 | * @return 678 | */ 679 | public SqlAssist setHaving(String having, JsonArray values) { 680 | this.having = having; 681 | this.havingValue = values; 682 | return this; 683 | } 684 | 685 | /** 686 | * 获取Having的值 687 | * 688 | * @return 689 | */ 690 | public JsonArray getHavingValue() { 691 | return havingValue; 692 | } 693 | 694 | /** 695 | * 获得是否去重 696 | * 697 | * @return 698 | */ 699 | public String getDistinct() { 700 | return distinct; 701 | } 702 | 703 | /** 704 | * 设置是否去重,true去重,false无效 705 | * 706 | * @param distinct 707 | */ 708 | public SqlAssist setDistincts(boolean distinct) { 709 | if (distinct) { 710 | this.distinct = "distinct"; 711 | return this; 712 | } 713 | return this; 714 | } 715 | 716 | /** 717 | * 设置一个现有的去除方案,该方法一般用于初始化,因为会将现有的distinct清除,既distinct=传入的distinct 718 | * 719 | * @param distinct 720 | * @return 721 | */ 722 | private SqlAssist setDistinct(String distinct) { 723 | this.distinct = distinct; 724 | return this; 725 | } 726 | 727 | /** 728 | * 获得开始分页行 729 | * 730 | * @return 731 | */ 732 | public Integer getStartRow() { 733 | return startRow; 734 | } 735 | 736 | /** 737 | * 获取第几页 738 | * 739 | * @return 740 | */ 741 | public Integer getPage() { 742 | return page; 743 | } 744 | 745 | /** 746 | * 设置第几页,该值仅在limitAll方法中有效,最终会被转换为startRow 747 | * 748 | * @param page 749 | * @return 750 | */ 751 | public SqlAssist setPage(Integer page) { 752 | this.page = page; 753 | return this; 754 | } 755 | 756 | /** 757 | * 设置从第几行开始取数据 758 | * 759 | * @param startRow 760 | */ 761 | public SqlAssist setStartRow(Integer startRow) { 762 | this.startRow = startRow; 763 | return this; 764 | } 765 | 766 | /** 767 | * 获得每次取多少行数据 768 | * 769 | * @return 770 | */ 771 | public Integer getRowSize() { 772 | return rowSize; 773 | } 774 | 775 | /** 776 | * 设置每次取多少行数据 777 | * 778 | * @param rowSize 779 | */ 780 | public SqlAssist setRowSize(Integer rowSize) { 781 | this.rowSize = rowSize; 782 | return this; 783 | } 784 | 785 | /** 786 | * 获得返回指定列 787 | * 788 | * @return 789 | */ 790 | public String getResultColumn() { 791 | return resultColumn; 792 | } 793 | 794 | /** 795 | * 设置自定义返回列,多个列以,逗号隔开 796 | * 797 | * @return 798 | */ 799 | public SqlAssist setResultColumn(String resultColumn) { 800 | this.resultColumn = resultColumn; 801 | return this; 802 | } 803 | 804 | /** 805 | * 获取连接查询或多表查询语句 806 | * 807 | * @return 808 | */ 809 | public String getJoinOrReference() { 810 | return joinOrReference; 811 | } 812 | 813 | /** 814 | * 设置连接查询或多表查询语句
815 | * 多表示例: ,table2,table3
816 | * 连接示例: inner join table2 on table1.id=table2.id 817 | * 818 | * @param joinOrReference 819 | * 连接语句 820 | * @return 821 | */ 822 | public SqlAssist setJoinOrReference(String joinOrReference) { 823 | this.joinOrReference = joinOrReference; 824 | return this; 825 | } 826 | 827 | /** 828 | * 获得条件集 829 | * 830 | * @return 831 | */ 832 | public List> getCondition() { 833 | return condition; 834 | } 835 | 836 | /** 837 | * 获得自定义属性 838 | * 839 | * @return 840 | */ 841 | public Object getCustom() { 842 | return custom; 843 | } 844 | 845 | /** 846 | * 设置自定义属性 847 | * 848 | * @param custom 849 | */ 850 | public void setCustom(Object custom) { 851 | this.custom = custom; 852 | } 853 | 854 | @Override 855 | public String toString() { 856 | return "SqlAssist [distinct=" + distinct + ", order=" + order + ", startRow=" + startRow + ", rowSize=" + rowSize + ", resultColumn=" 857 | + resultColumn + ", condition=" + condition + ", custom=" + custom + "]"; 858 | } 859 | } 860 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SqlLimitResult.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.HashMap; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.Objects; 7 | 8 | import io.vertx.core.json.JsonArray; 9 | import io.vertx.core.json.JsonObject; 10 | 11 | /** 12 | * 数据库分页返回结果 13 | * 14 | * @author Mirren 15 | * 16 | */ 17 | public class SqlLimitResult { 18 | /** 分页返回结果键名称的map */ 19 | private static final Map JSON_NAME_KEY_MAPS = new HashMap<>(); 20 | /** 数据总行数的默认key与value */ 21 | public static final String TOTALS = "totals"; 22 | /** 数据总页数的默认key与value */ 23 | public static final String PAGES = "pages"; 24 | /** 当前是第几页的默认key与value */ 25 | public static final String PAGE = "page"; 26 | /** 每页显示多少行数据的默认key与value */ 27 | public static final String SIZE = "size"; 28 | /** 数据的默认key与value */ 29 | public static final String DATA = "data"; 30 | static { 31 | JSON_NAME_KEY_MAPS.put(TOTALS, TOTALS); 32 | JSON_NAME_KEY_MAPS.put(PAGES, PAGES); 33 | JSON_NAME_KEY_MAPS.put(PAGE, PAGE); 34 | JSON_NAME_KEY_MAPS.put(SIZE, SIZE); 35 | JSON_NAME_KEY_MAPS.put(DATA, DATA); 36 | } 37 | 38 | /** 39 | * 设置返回结果数据键的名称 40 | * 41 | * @param oldName 42 | * totals=数据总行数
43 | * pages=数据总页数
44 | * page=当前是第几页
45 | * size=每页显示多少行数据
46 | * data=数据 47 | * @param newName 48 | * 新的名称 49 | */ 50 | public static void registerResultKey(String oldName, String newName) { 51 | if (JSON_NAME_KEY_MAPS.get(oldName) == null) { 52 | throw new IllegalArgumentException("Failed to return result name, invalid old name, only totals、pages、page、size、data are supported"); 53 | } 54 | Objects.requireNonNull(newName, "Failed to set return result name, new name can not be null"); 55 | JSON_NAME_KEY_MAPS.put(oldName, newName); 56 | } 57 | 58 | /** 数据总行数 */ 59 | private long totals; 60 | /** 数据总页数 */ 61 | private int pages; 62 | /** 当前是第几页 */ 63 | private int page; 64 | /** 每页显示多少行数据 */ 65 | private int size; 66 | /** 数据 */ 67 | private List data; 68 | 69 | /** 70 | * 初始化 71 | * 72 | * @param totals 73 | * 总行数 74 | * @param page 75 | * 当前页 76 | * @param size 77 | * 每页显示多少行数据 78 | */ 79 | public SqlLimitResult(long totals, int page, int size) { 80 | super(); 81 | this.totals = totals; 82 | this.page = page; 83 | this.size = size; 84 | } 85 | 86 | /** 87 | * 将当前对象装换为JsonObject:
88 | * totals(long):数据总行数
89 | * pages(int):数据总页数
90 | * page(int):当前是第几页
91 | * size(int):每页显示多少行数据
92 | * data(List):数据 93 | * 94 | * @return 95 | */ 96 | public JsonObject toJson() { 97 | JsonObject result = new JsonObject(); 98 | result.put(JSON_NAME_KEY_MAPS.getOrDefault(TOTALS, TOTALS), getTotals()); 99 | result.put(JSON_NAME_KEY_MAPS.getOrDefault(PAGES, PAGES), getPages()); 100 | result.put(JSON_NAME_KEY_MAPS.getOrDefault(PAGE, PAGE), getPage()); 101 | result.put(JSON_NAME_KEY_MAPS.getOrDefault(SIZE, SIZE), getSize()); 102 | String dataKey = JSON_NAME_KEY_MAPS.getOrDefault(DATA, DATA); 103 | if (getData() == null) { 104 | result.put(dataKey, new JsonArray()); 105 | } else { 106 | result.put(dataKey, getData()); 107 | } 108 | return result; 109 | } 110 | 111 | /** 112 | * 获取数据总行数 113 | * 114 | * @return 115 | */ 116 | public long getTotals() { 117 | return totals; 118 | } 119 | 120 | /** 121 | * 设置数据总行数 122 | * 123 | * @param totals 124 | * @return 125 | */ 126 | public SqlLimitResult setTotals(long totals) { 127 | this.totals = totals; 128 | return this; 129 | } 130 | 131 | /** 132 | * 获取数据总页数 133 | * 134 | * @return 135 | */ 136 | public int getPages() { 137 | if (totals == 0) { 138 | return 0; 139 | } 140 | if (totals % size == 0) { 141 | pages = (int) (totals / size); 142 | } else { 143 | pages = (int) (totals / size) + 1; 144 | } 145 | return pages; 146 | } 147 | 148 | /** 149 | * 获取当前是第几页 150 | * 151 | * @return 152 | */ 153 | public int getPage() { 154 | return page; 155 | } 156 | 157 | /** 158 | * 获取每页显示多少行数据 159 | * 160 | * @return 161 | */ 162 | public int getSize() { 163 | return size; 164 | } 165 | 166 | /** 167 | * 获取数据 168 | * 169 | * @return 170 | */ 171 | public List getData() { 172 | return data; 173 | } 174 | 175 | /** 176 | * 设置数据 177 | * 178 | * @param data 179 | * @return 180 | */ 181 | public SqlLimitResult setData(List data) { 182 | this.data = data; 183 | return this; 184 | } 185 | 186 | @Override 187 | public String toString() { 188 | return "SqlLimitResult [totals=" + totals + ", pages=" + pages + ", page=" + page + ", size=" + size + ", data=" + data + "]"; 189 | } 190 | 191 | } 192 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SqlPropertyValue.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | /** 4 | * 用于存储数据库列名,与列名对应的值 5 | * 6 | * @author Mirren 7 | * 8 | */ 9 | public class SqlPropertyValue { 10 | /** 列名 */ 11 | private String name; 12 | /** 参数值 */ 13 | private T value; 14 | 15 | public String getName() { 16 | return name; 17 | } 18 | 19 | public void setName(String name) { 20 | this.name = name; 21 | } 22 | 23 | public T getValue() { 24 | return value; 25 | } 26 | 27 | public void setValue(T value) { 28 | this.value = value; 29 | } 30 | 31 | public SqlPropertyValue(String name, T value) { 32 | super(); 33 | this.name = name; 34 | this.value = value; 35 | } 36 | 37 | @Override 38 | public String toString() { 39 | return "SqlPropertyValue [name=" + name + ", value=" + value + "]"; 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/SqlWhereCondition.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | 7 | import io.vertx.core.json.JsonArray; 8 | import io.vertx.core.json.JsonObject; 9 | 10 | /** 11 | * SqlAssist的条件类,require属性为列的条件,value和values为条件值 12 | * 13 | * @author Mirren 14 | * @param 15 | */ 16 | public class SqlWhereCondition { 17 | /** 条件 */ 18 | private String require; 19 | /** 条件值,单个 */ 20 | private T value; 21 | /** 条件值,多个 */ 22 | private Object[] values; 23 | 24 | /** 25 | * 将当前对象装换为JsonObject 26 | * 27 | * @return 28 | */ 29 | public JsonObject toJson() { 30 | JsonObject json = new JsonObject(); 31 | if (require != null) { 32 | json.put("require", require); 33 | } 34 | if (value != null) { 35 | json.put("value", value); 36 | } 37 | if (values != null) { 38 | JsonArray array = new JsonArray(); 39 | for (int i = 0; i < values.length; i++) { 40 | array.add(values[i]); 41 | } 42 | json.put("values", array); 43 | } 44 | return json; 45 | } 46 | 47 | /** 48 | * 将一个JsonObject对象装换为SqlWhereCondition 49 | * 50 | * @param obj 51 | * @return 52 | */ 53 | public static SqlWhereCondition fromJson(JsonObject obj) { 54 | SqlWhereCondition condition = new SqlWhereCondition<>(); 55 | if (obj.getValue("require") instanceof String) { 56 | condition.setRequire(obj.getString("require")); 57 | } 58 | if (obj.getValue("value") != null) { 59 | condition.setValue(obj.getValue("value")); 60 | } 61 | if (obj.getValue("values") instanceof JsonArray) { 62 | List list = new ArrayList<>(); 63 | obj.getJsonArray("values").forEach(va -> { 64 | list.add(va); 65 | }); 66 | condition.setValues(list.toArray()); 67 | } 68 | return condition; 69 | } 70 | 71 | public SqlWhereCondition() { 72 | super(); 73 | } 74 | 75 | public SqlWhereCondition(String require, T value) { 76 | super(); 77 | this.require = require; 78 | this.value = value; 79 | } 80 | 81 | public SqlWhereCondition(String require, Object... values) { 82 | super(); 83 | this.require = require; 84 | this.values = values; 85 | } 86 | 87 | /** 88 | * SQL: [and] column = value
89 | * 注释: 并且列名=条件值 90 | * 91 | * @param column 92 | * 列名,如果存在相同列名则使用表名.列名 93 | * @param value 94 | * 条件值 95 | * @return 96 | */ 97 | public static SqlWhereCondition andEq(String column, T value) { 98 | return new SqlWhereCondition("and " + column + " = ? ", value); 99 | } 100 | 101 | /** 102 | * SQL: [or] column = value
103 | * 注释: 或者列名=条件值 104 | * 105 | * @param column 106 | * 列名,如果存在相同列名则使用表名.列名 107 | * @param value 108 | * 条件值 109 | * @return 110 | */ 111 | public static SqlWhereCondition orEq(String column, T value) { 112 | return new SqlWhereCondition("or " + column + " = ? ", value); 113 | } 114 | 115 | /** 116 | * SQL: [and] column <> value
117 | * 解释: 并且列名不等于条件值 118 | * 119 | * @param column 120 | * 列名,如果存在相同列名则使用表名.列名 121 | * @param value 122 | * 条件值 123 | * @return 124 | */ 125 | public static SqlWhereCondition andNeq(String column, T value) { 126 | return new SqlWhereCondition("and " + column + " <> ? ", value); 127 | } 128 | 129 | /** 130 | * SQL: [or] column <> value
131 | * 解释: 或者列名不等于条件值 132 | * 133 | * @param column 134 | * 列名,如果存在相同列名则使用表名.列名 135 | * @param value 136 | * 条件值 137 | * @return 138 | */ 139 | public static SqlWhereCondition orNeq(String column, T value) { 140 | return new SqlWhereCondition("or " + column + " <> ? ", value); 141 | } 142 | 143 | /** 144 | * SQL: [and] column < value
145 | * 解释: 并且列名小于条件值 146 | * 147 | * @param column 148 | * 列名,如果存在相同列名则使用表名.列名 149 | * @param value 150 | * 条件值 151 | * @return 152 | */ 153 | public static SqlWhereCondition andLt(String column, T value) { 154 | return new SqlWhereCondition("and " + column + " < ? ", value); 155 | } 156 | 157 | /** 158 | * SQL: [or] column < value
159 | * 解释: 或者列名小于条件值 160 | * 161 | * @param column 162 | * 列名,如果存在相同列名则使用表名.列名 163 | * @param value 164 | * 条件值 165 | * @return 166 | */ 167 | public static SqlWhereCondition orLt(String column, T value) { 168 | return new SqlWhereCondition("or " + column + " < ? ", value); 169 | } 170 | 171 | /** 172 | * SQL: [and] column <= value
173 | * 解释: 并且列名小于等于条件值 174 | * 175 | * @param column 176 | * 列名,如果存在相同列名则使用表名.列名 177 | * @param value 178 | * 条件值 179 | * @return 180 | */ 181 | public static SqlWhereCondition andLte(String column, T value) { 182 | return new SqlWhereCondition("and " + column + " <= ? ", value); 183 | } 184 | 185 | /** 186 | * SQL: [or] column <= value
187 | * 解释: 或者列名小于等于条件值 188 | * 189 | * @param column 190 | * 列名,如果存在相同列名则使用表名.列名 191 | * @param value 192 | * 条件值 193 | * @return 194 | */ 195 | public static SqlWhereCondition orLte(String column, T value) { 196 | return new SqlWhereCondition("or " + column + " <= ? ", value); 197 | } 198 | 199 | /** 200 | * SQL: [and] column > value
201 | * 解释: 并且列名大于条件值 202 | * 203 | * @param column 204 | * 列名,如果存在相同列名则使用表名.列名 205 | * @param value 206 | * 条件值 207 | * @return 208 | */ 209 | public static SqlWhereCondition andGt(String column, T value) { 210 | return new SqlWhereCondition("and " + column + " > ? ", value); 211 | } 212 | 213 | /** 214 | * SQL: [or] column > value
215 | * 解释: 或者列名大于条件值 216 | * 217 | * @param column 218 | * 列名,如果存在相同列名则使用表名.列名 219 | * @param value 220 | * 条件值 221 | * @return 222 | */ 223 | public static SqlWhereCondition orGt(String column, T value) { 224 | return new SqlWhereCondition("or " + column + " > ? ", value); 225 | } 226 | 227 | /** 228 | * SQL: [and] column >= value
229 | * 解释: 并且列名大于等于条件值 230 | * 231 | * @param column 232 | * 列名,如果存在相同列名则使用表名.列名 233 | * @param value 234 | * 条件值 235 | * @return 236 | */ 237 | public static SqlWhereCondition andGte(String column, T value) { 238 | return new SqlWhereCondition("and " + column + " >= ? ", value); 239 | } 240 | 241 | /** 242 | * SQL: [or] column >= value
243 | * 解释: 或者列名大于等于条件值 244 | * 245 | * @param column 246 | * 列名,如果存在相同列名则使用表名.列名 247 | * @param value 248 | * 条件值 249 | * @return 250 | */ 251 | public static SqlWhereCondition orGte(String column, T value) { 252 | return new SqlWhereCondition("or " + column + " >= ? ", value); 253 | } 254 | 255 | /** 256 | * SQL: [and] column like value
257 | * 解释: 并且列名like条件值 258 | * 259 | * @param column 260 | * 列名,如果存在相同列名则使用表名.列名 261 | * @param value 262 | * 条件值,通配符需要自己添加 263 | * @return 264 | */ 265 | public static SqlWhereCondition andLike(String column, T value) { 266 | return new SqlWhereCondition("and " + column + " like ? ", value); 267 | } 268 | 269 | /** 270 | * SQL: [or] column like value
271 | * 解释: 或者列名like条件值 272 | * 273 | * @param column 274 | * 列名,如果存在相同列名则使用表名.列名 275 | * @param value 276 | * 条件值,通配符需要自己添加 277 | * @return 278 | */ 279 | public static SqlWhereCondition orLike(String column, T req) { 280 | return new SqlWhereCondition("or " + column + " like ? ", req); 281 | } 282 | 283 | /** 284 | * SQL: [and] column not like value
285 | * 解释: 并且列名not like条件值 286 | * 287 | * @param column 288 | * 列名,如果存在相同列名则使用表名.列名 289 | * @param value 290 | * 条件值,通配符需要自己添加 291 | * @return 292 | */ 293 | public static SqlWhereCondition andNotLike(String column, T value) { 294 | return new SqlWhereCondition("and " + column + " not like ? ", value); 295 | } 296 | 297 | /** 298 | * SQL: [or] column not like value
299 | * 解释: 或者列名 not like条件值 300 | * 301 | * @param column 302 | * 列名,如果存在相同列名则使用表名.列名 303 | * @param value 304 | * 条件值,通配符需要自己添加 305 | * @return 306 | */ 307 | public static SqlWhereCondition orNotLike(String column, T req) { 308 | return new SqlWhereCondition("or " + column + " not like ? ", req); 309 | } 310 | 311 | /** 312 | * SQL: [and] column is null
313 | * 解释: 或者列名is null 314 | * 315 | * @param column 316 | * 列名,如果存在相同列名则使用表名.列名 317 | * @return 318 | */ 319 | public static SqlWhereCondition andIsNull(String column) { 320 | return new SqlWhereCondition("and " + column + " is null "); 321 | } 322 | 323 | /** 324 | * SQL: [or] column is null
325 | * 解释: 或者列名is null 326 | * 327 | * @param column 328 | * 列名,如果存在相同列名则使用表名.列名 329 | * @return 330 | */ 331 | public static SqlWhereCondition orIsNull(String column) { 332 | return new SqlWhereCondition("or " + column + " is null "); 333 | } 334 | 335 | /** 336 | * SQL: [and] column is not null
337 | * 解释: 或者列名is not null 338 | * 339 | * @param column 340 | * 列名,如果存在相同列名则使用表名.列名 341 | * @return 342 | */ 343 | public static SqlWhereCondition andIsNotNull(String column) { 344 | return new SqlWhereCondition("and " + column + " is not null "); 345 | } 346 | 347 | /** 348 | * SQL: [or] column is not null
349 | * 解释: 或者列名is not null 350 | * 351 | * @param column 352 | * 列名,如果存在相同列名则使用表名.列名 353 | * @return 354 | */ 355 | public static SqlWhereCondition orIsNotNull(String column) { 356 | return new SqlWhereCondition("or " + column + " is not null "); 357 | } 358 | 359 | /** 360 | * SQL: [and] column [Syntax]
361 | * 解释: 并且列名表达式,比如colum is null 362 | * 363 | * @param column 364 | * 列名[与表达式],如果存在相同列名则使用表名.列名 365 | * @return 366 | */ 367 | public static SqlWhereCondition and(String column) { 368 | return new SqlWhereCondition("and " + column + " "); 369 | } 370 | 371 | /** 372 | * SQL: [or] column [Syntax]
373 | * 解释: 或者列名表达式,比如colum is null 374 | * 375 | * @param column 376 | * 列名[与表达式],如果存在相同列名则使用表名.列名 377 | * @return 378 | */ 379 | public static SqlWhereCondition or(String column) { 380 | return new SqlWhereCondition("or " + column + " "); 381 | } 382 | 383 | /** 384 | * 自定义查询条件:
385 | * 示例 :
386 | * prefix=and id in(select tid from table where w=?)
387 | * value=1
388 | * 389 | * @param prefix 390 | * SQL语句与条件值占位符 391 | * @param value 392 | * 条件值 393 | * @return 394 | */ 395 | public static SqlWhereCondition customCondition(String prefix, T value) { 396 | return new SqlWhereCondition(prefix + " ", value); 397 | } 398 | 399 | /** 400 | * 自定义查询条件 :
401 | * 示例 :
402 | * prefix=and id in(?,?,?)
403 | * value=1,2,3
404 | * 405 | * @param prefix 406 | * SQL语句与条件值占位符 407 | * @param value 408 | * 条件值 409 | * @return 410 | */ 411 | public static SqlWhereCondition customCondition(String prefix, Object... value) { 412 | return new SqlWhereCondition(prefix + " ", value); 413 | } 414 | 415 | public String getRequire() { 416 | return require; 417 | } 418 | 419 | public void setRequire(String require) { 420 | this.require = require; 421 | } 422 | 423 | public T getValue() { 424 | return value; 425 | } 426 | 427 | public void setValue(T value) { 428 | this.value = value; 429 | } 430 | 431 | public Object[] getValues() { 432 | return values; 433 | } 434 | 435 | public void setValues(Object[] values) { 436 | this.values = values; 437 | } 438 | 439 | @Override 440 | public String toString() { 441 | return "SqlWhereCondition [require=" + require + ", value=" + value + ", values=" + Arrays.toString(values) + "]"; 442 | } 443 | 444 | } 445 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/Table.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 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 | 8 | /** 9 | * 实体类关联表的注解 10 | * @author Mirren 11 | * 12 | */ 13 | @Target(ElementType.TYPE) 14 | @Retention(RetentionPolicy.RUNTIME) 15 | public @interface Table { 16 | String value(); 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/TableColumn.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 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 | 8 | /** 9 | * 类属性关联列的注解 10 | * @author Mirren 11 | * 12 | */ 13 | @Target(ElementType.FIELD) 14 | @Retention(RetentionPolicy.RUNTIME) 15 | public @interface TableColumn { 16 | String value(); 17 | String alias() default ""; 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/TableId.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 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 | 8 | /** 9 | * id列关联表的注解 10 | * 11 | * @author Mirren 12 | * 13 | */ 14 | @Target(ElementType.FIELD) 15 | @Retention(RetentionPolicy.RUNTIME) 16 | public @interface TableId { 17 | String value(); 18 | String alias() default ""; 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/AbstractStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import java.lang.reflect.Field; 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | import io.vertx.core.impl.logging.Logger; 8 | import io.vertx.core.impl.logging.LoggerFactory; 9 | import io.vertx.ext.sql.assist.SQLStatement; 10 | import io.vertx.ext.sql.assist.SqlAndParams; 11 | import io.vertx.ext.sql.assist.SqlAssist; 12 | import io.vertx.ext.sql.assist.SqlPropertyValue; 13 | import io.vertx.ext.sql.assist.SqlWhereCondition; 14 | import io.vertx.ext.sql.assist.Table; 15 | import io.vertx.ext.sql.assist.TableColumn; 16 | import io.vertx.ext.sql.assist.TableId; 17 | import io.vertx.sqlclient.Tuple; 18 | 19 | /** 20 | * 抽象数据库操作语句,默认以MySQL标准来编写,如果其他数据库可以基础并重写不兼容的方法
21 | * 通常不支持limit分页的数据库需要重写{@link #selectAllSQL(SqlAssist)}与{@link #selectByObjSQL(Object, String, String, boolean)}这两个方法 22 | * 23 | * @author Mirren 24 | * @param 25 | */ 26 | public abstract class AbstractStatementSQL implements SQLStatement { 27 | /** 日志工具 */ 28 | private final Logger LOG = LoggerFactory.getLogger(AbstractStatementSQL.class); 29 | /** 表的名称 */ 30 | private String sqlTableName; 31 | /** 主键的名称 */ 32 | private String sqlPrimaryId; 33 | /** 返回列 */ 34 | private String sqlResultColumns; 35 | 36 | public AbstractStatementSQL(Class entity) { 37 | super(); 38 | if (tableName() == null) { 39 | Table table = entity.getAnnotation(Table.class); 40 | if (table == null || table.value().isEmpty()) { 41 | throw new NullPointerException(entity.getName() + " no Table annotation ,you need to set @Table on the class"); 42 | } 43 | this.sqlTableName = table.value(); 44 | } 45 | if (primaryId() == null || resultColumns() == null) { 46 | boolean hasId = false; 47 | boolean hasCol = false; 48 | Field[] fields = entity.getDeclaredFields(); 49 | StringBuilder column = new StringBuilder(); 50 | for (Field field : fields) { 51 | field.setAccessible(true); 52 | TableId tableId = field.getAnnotation(TableId.class); 53 | TableColumn tableCol = field.getAnnotation(TableColumn.class); 54 | if (tableId == null && tableCol == null) { 55 | continue; 56 | } 57 | if (tableId != null) { 58 | if (tableId.value() == null || tableId.value().isEmpty()) { 59 | continue; 60 | } 61 | if (this.sqlPrimaryId != null) { 62 | this.sqlPrimaryId += tableId.value(); 63 | } else { 64 | this.sqlPrimaryId = tableId.value(); 65 | } 66 | hasId = true; 67 | column.append("," + tableId.value()); 68 | if (tableId.alias() != null && !tableId.alias().isEmpty()) { 69 | column.append(" AS \"" + tableId.alias() + "\""); 70 | } 71 | } else { 72 | if (tableCol == null) { 73 | continue; 74 | } 75 | column.append("," + tableCol.value()); 76 | if (tableCol.alias() != null && !tableCol.alias().isEmpty()) { 77 | column.append(" AS \"" + tableCol.alias() + "\""); 78 | } 79 | hasCol = true; 80 | } 81 | } 82 | if (!hasId) { 83 | throw new NullPointerException(entity.getName() + " no TableId annotation ,you need to set @TableId on the field"); 84 | } 85 | if (!hasCol && !hasId) { 86 | throw new NullPointerException(entity.getName() + " no TableColumn annotation ,you need to set @TableColumn on the field"); 87 | } 88 | this.sqlResultColumns = column.substring(1); 89 | } 90 | 91 | } 92 | 93 | /** 94 | * 获取表名称 95 | * 96 | * @return 97 | */ 98 | public String tableName() { 99 | return sqlTableName; 100 | } 101 | 102 | /** 103 | * 获取主键名称 104 | * 105 | * @return 106 | */ 107 | public String primaryId() { 108 | return sqlPrimaryId; 109 | } 110 | 111 | /** 112 | * 获取表返回列 113 | * 114 | * @return 115 | */ 116 | public String resultColumns() { 117 | return sqlResultColumns; 118 | } 119 | 120 | /** 121 | * 表的所有列名与列名对应的值 122 | * 123 | * @return 124 | * @throws Exception 125 | */ 126 | public List> getPropertyValue(T obj) throws Exception { 127 | Field[] fields = obj.getClass().getDeclaredFields(); 128 | List> result = new ArrayList<>();; 129 | for (Field field : fields) { 130 | field.setAccessible(true); 131 | TableId tableId = field.getAnnotation(TableId.class); 132 | TableColumn tableCol = field.getAnnotation(TableColumn.class); 133 | if (tableId == null && tableCol == null) { 134 | continue; 135 | } 136 | if (tableId != null) { 137 | result.add(0, new SqlPropertyValue<>(tableId.value(), field.get(obj))); 138 | } else { 139 | result.add(new SqlPropertyValue<>(tableCol.value(), field.get(obj))); 140 | } 141 | } 142 | return result; 143 | } 144 | 145 | @Override 146 | public SqlAndParams getCountSQL(SqlAssist assist) { 147 | StringBuilder sql = new StringBuilder(String.format("select count(*) from %s ", tableName())); 148 | Tuple params = null; 149 | if (assist != null) { 150 | if (assist.getJoinOrReference() != null) { 151 | sql.append(assist.getJoinOrReference()); 152 | } 153 | if (assist.getCondition() != null && assist.getCondition().size() > 0) { 154 | params = Tuple.tuple(); 155 | List> where = assist.getCondition(); 156 | sql.append(" where " + where.get(0).getRequire()); 157 | if (where.get(0).getValue() != null) { 158 | params.addValue(where.get(0).getValue()); 159 | } 160 | if (where.get(0).getValues() != null) { 161 | for (Object value : where.get(0).getValues()) { 162 | params.addValue(value); 163 | } 164 | } 165 | for (int i = 1; i < where.size(); i++) { 166 | sql.append(where.get(i).getRequire()); 167 | if (where.get(i).getValue() != null) { 168 | params.addValue(where.get(i).getValue()); 169 | } 170 | if (where.get(i).getValues() != null) { 171 | for (Object value : where.get(i).getValues()) { 172 | params.addValue(value); 173 | } 174 | } 175 | } 176 | } 177 | if (assist.getGroupBy() != null) { 178 | sql.append(" group by " + assist.getGroupBy() + " "); 179 | } 180 | } 181 | SqlAndParams result = new SqlAndParams(sql.toString(), params); 182 | if (LOG.isDebugEnabled()) { 183 | LOG.debug("getCountSQL : " + result.toString()); 184 | } 185 | return result; 186 | } 187 | 188 | @Override 189 | public SqlAndParams selectAllSQL(SqlAssist assist) { 190 | // 如果Assist为空返回默认默认查询语句,反则根据Assist生成语句sql语句 191 | if (assist == null) { 192 | SqlAndParams result = new SqlAndParams(String.format("select %s from %s ", resultColumns(), tableName())); 193 | if (LOG.isDebugEnabled()) { 194 | LOG.debug("SelectAllSQL : " + result.toString()); 195 | } 196 | return result; 197 | } else { 198 | String distinct = assist.getDistinct() == null ? "" : assist.getDistinct();// 去重语句 199 | String column = assist.getResultColumn() == null ? resultColumns() : assist.getResultColumn();// 表的列名 200 | // 初始化SQL语句 201 | StringBuilder sql = new StringBuilder(String.format("select %s %s from %s", distinct, column, tableName())); 202 | Tuple params = Tuple.tuple();// 参数 203 | if (assist.getJoinOrReference() != null) { 204 | sql.append(assist.getJoinOrReference()); 205 | } 206 | if (assist.getCondition() != null && assist.getCondition().size() > 0) { 207 | List> where = assist.getCondition(); 208 | sql.append(" where " + where.get(0).getRequire()); 209 | if (where.get(0).getValue() != null) { 210 | params.addValue(where.get(0).getValue()); 211 | } 212 | if (where.get(0).getValues() != null) { 213 | for (Object value : where.get(0).getValues()) { 214 | params.addValue(value); 215 | } 216 | } 217 | for (int i = 1; i < where.size(); i++) { 218 | sql.append(where.get(i).getRequire()); 219 | if (where.get(i).getValue() != null) { 220 | params.addValue(where.get(i).getValue()); 221 | } 222 | if (where.get(i).getValues() != null) { 223 | for (Object value : where.get(i).getValues()) { 224 | params.addValue(value); 225 | } 226 | } 227 | } 228 | } 229 | if (assist.getGroupBy() != null) { 230 | sql.append(" group by " + assist.getGroupBy() + " "); 231 | } 232 | if (assist.getHaving() != null) { 233 | sql.append(" having " + assist.getHaving() + " "); 234 | if (assist.getHavingValue() != null) { 235 | for (Object value : assist.getHavingValue()) { 236 | params.addValue(value); 237 | } 238 | } 239 | } 240 | if (assist.getOrder() != null) { 241 | sql.append(assist.getOrder()); 242 | } 243 | if (assist.getRowSize() != null || assist.getStartRow() != null) { 244 | if (assist.getStartRow() != null) { 245 | sql.append(" LIMIT ?"); 246 | params.addValue(assist.getRowSize()); 247 | } 248 | if (assist.getStartRow() != null) { 249 | sql.append(" OFFSET ?"); 250 | params.addValue(assist.getStartRow()); 251 | } 252 | } 253 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 254 | if (LOG.isDebugEnabled()) { 255 | LOG.debug("SelectAllSQL : " + result.toString()); 256 | } 257 | return result; 258 | } 259 | } 260 | 261 | @Override 262 | public SqlAndParams selectByIdSQL(S primaryValue, String resultColumns, String tableAlias, String joinOrReference) { 263 | String sql = String.format("select %s from %s %s where %s = ? ", 264 | (resultColumns == null ? resultColumns() : resultColumns), 265 | (tableName() + (tableAlias == null ? "" : (" AS " + tableAlias))), 266 | (joinOrReference == null ? "" : joinOrReference), 267 | (tableAlias == null ? "" : (tableAlias + ".")) + primaryId()); 268 | SqlAndParams result = new SqlAndParams(sql, Tuple.of(primaryValue)); 269 | if (LOG.isDebugEnabled()) { 270 | LOG.debug("selectByIdSQL : " + result.toString()); 271 | } 272 | return result; 273 | } 274 | 275 | @Override 276 | public SqlAndParams selectByObjSQL(T obj, String resultColumns, String tableAlias, String joinOrReference, boolean single) { 277 | StringBuilder sql = new StringBuilder(String.format("select %s from %s %s ", 278 | (resultColumns == null ? resultColumns() : resultColumns), 279 | (tableName() + (tableAlias == null ? "" : (" AS " + tableAlias))), 280 | (joinOrReference == null ? "" : joinOrReference))); 281 | Tuple params = Tuple.tuple(); 282 | boolean isFrist = true; 283 | List> propertyValue; 284 | try { 285 | propertyValue = getPropertyValue(obj); 286 | } catch (Exception e) { 287 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 288 | } 289 | for (int i = propertyValue.size() - 1; i >= 0; i--) { 290 | SqlPropertyValue pv = propertyValue.get(i); 291 | if (pv.getValue() != null) { 292 | if (isFrist) { 293 | sql.append(String.format("where %s = ? ", (tableAlias == null ? "" : (tableAlias + ".")) + pv.getName())); 294 | isFrist = false; 295 | } else { 296 | sql.append(String.format("and %s = ? ", (tableAlias == null ? "" : (tableAlias + ".")) + pv.getName())); 297 | } 298 | params.addValue(pv.getValue()); 299 | } 300 | } 301 | if (single) { 302 | sql.append(" LIMIT 1"); 303 | } 304 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 305 | if (LOG.isDebugEnabled()) { 306 | LOG.debug("selectByObjSQL : " + result.toString()); 307 | } 308 | return result; 309 | } 310 | 311 | @Override 312 | public SqlAndParams insertAllSQL(T obj) { 313 | Tuple params = Tuple.tuple(); 314 | StringBuilder tempColumn = null; 315 | StringBuilder tempValues = null; 316 | List> propertyValue; 317 | try { 318 | propertyValue = getPropertyValue(obj); 319 | } catch (Exception e) { 320 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 321 | } 322 | for (SqlPropertyValue pv : propertyValue) { 323 | if (tempColumn == null) { 324 | tempColumn = new StringBuilder(pv.getName()); 325 | tempValues = new StringBuilder("?"); 326 | } else { 327 | tempColumn.append("," + pv.getName()); 328 | tempValues.append(",?"); 329 | } 330 | params.addValue(pv.getValue()); 331 | } 332 | String sql = String.format("insert into %s (%s) values (%s) ", tableName(), tempColumn, tempValues); 333 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 334 | if (LOG.isDebugEnabled()) { 335 | LOG.debug("insertAllSQL : " + result.toString()); 336 | } 337 | return result; 338 | } 339 | 340 | @Override 341 | public SqlAndParams insertNonEmptySQL(T obj) { 342 | Tuple params = Tuple.tuple(); 343 | StringBuilder tempColumn = null; 344 | StringBuilder tempValues = null; 345 | List> propertyValue; 346 | try { 347 | propertyValue = getPropertyValue(obj); 348 | } catch (Exception e) { 349 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 350 | } 351 | for (SqlPropertyValue pv : propertyValue) { 352 | if (pv.getValue() != null) { 353 | if (tempColumn == null) { 354 | tempColumn = new StringBuilder(pv.getName()); 355 | tempValues = new StringBuilder("?"); 356 | } else { 357 | tempColumn.append("," + pv.getName()); 358 | tempValues.append(",?"); 359 | } 360 | params.addValue(pv.getValue()); 361 | } 362 | } 363 | if (tempColumn == null || tempValues == null) { 364 | return new SqlAndParams(false, "The column or value is null"); 365 | } 366 | String sql = String.format("insert into %s (%s) values (%s) ", tableName(), tempColumn, tempValues); 367 | SqlAndParams result = new SqlAndParams(sql, (params.size() <= 0 ? null : params)); 368 | if (LOG.isDebugEnabled()) { 369 | LOG.debug("insertNonEmptySQL : " + result.toString()); 370 | } 371 | return result; 372 | } 373 | 374 | @Override 375 | public SqlAndParams insertBatchSQL(List list) { 376 | if (list == null || list.isEmpty()) { 377 | return new SqlAndParams(false, "The param can not be null or empty"); 378 | } 379 | StringBuilder tempColumn = null; 380 | StringBuilder tempValues = null; 381 | Tuple param0 = Tuple.tuple(); 382 | List> propertyValue; 383 | try { 384 | propertyValue = getPropertyValue(list.get(0)); 385 | } catch (Exception e) { 386 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 387 | } 388 | for (SqlPropertyValue pv : propertyValue) { 389 | if (tempColumn == null) { 390 | tempColumn = new StringBuilder(pv.getName()); 391 | tempValues = new StringBuilder("?"); 392 | } else { 393 | tempColumn.append("," + pv.getName()); 394 | tempValues.append(",?"); 395 | } 396 | param0.addValue(pv.getValue()); 397 | } 398 | List params = new ArrayList<>(); 399 | params.add(param0); 400 | for (int i = 1; i < list.size(); i++) { 401 | Tuple paramx = Tuple.tuple(); 402 | List> propertyValue1; 403 | try { 404 | propertyValue1 = getPropertyValue(list.get(i)); 405 | } catch (Exception e) { 406 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 407 | } 408 | for (SqlPropertyValue pv : propertyValue1) { 409 | paramx.addValue(pv.getValue()); 410 | } 411 | params.add(paramx); 412 | } 413 | String sql = String.format("insert into %s (%s) values (%s) ", tableName(), tempColumn, tempValues); 414 | SqlAndParams qp = new SqlAndParams(sql, params); 415 | if (LOG.isDebugEnabled()) { 416 | LOG.debug("insertBatch : " + qp.toString()); 417 | } 418 | return qp; 419 | } 420 | 421 | @Override 422 | public SqlAndParams insertBatchSQL(List columns, List params) { 423 | if ((columns == null || columns.isEmpty()) || (params == null || params.isEmpty())) { 424 | return new SqlAndParams(false, "The columns and params can not be null or empty"); 425 | } 426 | StringBuilder tempColumn = null; 427 | StringBuilder tempValues = null; 428 | for (String column : columns) { 429 | if (tempColumn == null) { 430 | tempColumn = new StringBuilder(column); 431 | tempValues = new StringBuilder("?"); 432 | } else { 433 | tempColumn.append("," + column); 434 | tempValues.append(",?"); 435 | } 436 | } 437 | String sql = String.format("insert into %s (%s) values (%s) ", tableName(), tempColumn, tempValues); 438 | SqlAndParams qp = new SqlAndParams(sql, params); 439 | if (LOG.isDebugEnabled()) { 440 | LOG.debug("insertBatch : " + qp.toString()); 441 | } 442 | return qp; 443 | } 444 | 445 | @Override 446 | public SqlAndParams replaceSQL(T obj) { 447 | Tuple params = Tuple.tuple(); 448 | StringBuilder tempColumn = null; 449 | StringBuilder tempValues = null; 450 | List> propertyValue; 451 | try { 452 | propertyValue = getPropertyValue(obj); 453 | } catch (Exception e) { 454 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 455 | } 456 | for (SqlPropertyValue pv : propertyValue) { 457 | if (pv.getValue() != null) { 458 | if (tempColumn == null) { 459 | tempColumn = new StringBuilder(pv.getName()); 460 | tempValues = new StringBuilder("?"); 461 | } else { 462 | tempColumn.append("," + pv.getName()); 463 | tempValues.append(",?"); 464 | } 465 | params.addValue(pv.getValue()); 466 | } 467 | } 468 | if (tempColumn == null || tempValues == null) { 469 | return new SqlAndParams(false, "The column or value is null"); 470 | } 471 | String sql = String.format("replace into %s (%s) values (%s) ", tableName(), tempColumn, tempValues); 472 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 473 | if (LOG.isDebugEnabled()) { 474 | LOG.debug("replaceSQL : " + result.toString()); 475 | } 476 | return result; 477 | } 478 | 479 | @Override 480 | public SqlAndParams updateAllByIdSQL(T obj) { 481 | if (primaryId() == null) { 482 | return new SqlAndParams(false, "there is no primary key in your SQL statement"); 483 | } 484 | Tuple params = Tuple.tuple(); 485 | StringBuilder tempColumn = null; 486 | Object tempIdValue = null; 487 | List> propertyValue; 488 | try { 489 | propertyValue = getPropertyValue(obj); 490 | } catch (Exception e) { 491 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 492 | } 493 | for (SqlPropertyValue pv : propertyValue) { 494 | if (pv.getName().equals(primaryId())) { 495 | tempIdValue = pv.getValue(); 496 | continue; 497 | } 498 | if (tempColumn == null) { 499 | tempColumn = new StringBuilder(pv.getName() + " = ? "); 500 | } else { 501 | tempColumn.append(", " + pv.getName() + " = ? "); 502 | } 503 | params.addValue(pv.getValue()); 504 | } 505 | if (tempIdValue == null) { 506 | return new SqlAndParams(false, "there is no primary key in your SQL statement"); 507 | } 508 | params.addValue(tempIdValue); 509 | String sql = String.format("update %s set %s where %s = ? ", tableName(), tempColumn, primaryId()); 510 | SqlAndParams result = new SqlAndParams(sql, params); 511 | if (LOG.isDebugEnabled()) { 512 | LOG.debug("updateAllByIdSQL : " + result.toString()); 513 | } 514 | return result; 515 | } 516 | 517 | @Override 518 | public SqlAndParams updateAllByAssistSQL(T obj, SqlAssist assist) { 519 | if (assist == null || assist.getCondition() == null || assist.getCondition().size() < 1) { 520 | return new SqlAndParams(false, "SqlAssist or SqlAssist.condition is null"); 521 | } 522 | Tuple params = Tuple.tuple(); 523 | StringBuilder tempColumn = null; 524 | List> propertyValue; 525 | try { 526 | propertyValue = getPropertyValue(obj); 527 | } catch (Exception e) { 528 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 529 | } 530 | for (SqlPropertyValue pv : propertyValue) { 531 | if (tempColumn == null) { 532 | tempColumn = new StringBuilder(pv.getName() + " = ? "); 533 | } else { 534 | tempColumn.append(", " + pv.getName() + " = ? "); 535 | } 536 | params.addValue(pv.getValue()); 537 | } 538 | List> where = assist.getCondition(); 539 | StringBuilder whereStr = new StringBuilder(" where " + where.get(0).getRequire()); 540 | if (where.get(0).getValue() != null) { 541 | params.addValue(where.get(0).getValue()); 542 | } 543 | if (where.get(0).getValues() != null) { 544 | for (Object value : where.get(0).getValues()) { 545 | params.addValue(value); 546 | } 547 | } 548 | for (int i = 1; i < where.size(); i++) { 549 | whereStr.append(where.get(i).getRequire()); 550 | if (where.get(i).getValue() != null) { 551 | params.addValue(where.get(i).getValue()); 552 | } 553 | if (where.get(i).getValues() != null) { 554 | for (Object value : where.get(i).getValues()) { 555 | params.addValue(value); 556 | } 557 | } 558 | } 559 | String sql = String.format("update %s set %s %s", tableName(), tempColumn, whereStr == null ? "" : whereStr); 560 | SqlAndParams result = new SqlAndParams(sql.toString(), params); 561 | if (LOG.isDebugEnabled()) { 562 | LOG.debug("updateAllByAssistSQL : " + result.toString()); 563 | } 564 | return result; 565 | } 566 | 567 | @Override 568 | public SqlAndParams updateNonEmptyByIdSQL(T obj) { 569 | if (primaryId() == null) { 570 | if (LOG.isDebugEnabled()) { 571 | LOG.debug("there is no primary key in your SQL statement"); 572 | } 573 | return new SqlAndParams(false, "there is no primary key in your SQL statement"); 574 | } 575 | Tuple params = Tuple.tuple(); 576 | StringBuilder tempColumn = null; 577 | Object tempIdValue = null; 578 | List> propertyValue; 579 | try { 580 | propertyValue = getPropertyValue(obj); 581 | } catch (Exception e) { 582 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 583 | } 584 | for (SqlPropertyValue pv : propertyValue) { 585 | if (pv.getName().equals(primaryId())) { 586 | tempIdValue = pv.getValue(); 587 | continue; 588 | } 589 | if (pv.getValue() != null) { 590 | if (tempColumn == null) { 591 | tempColumn = new StringBuilder(pv.getName() + " = ? "); 592 | } else { 593 | tempColumn.append(", " + pv.getName() + " = ? "); 594 | } 595 | params.addValue(pv.getValue()); 596 | } 597 | } 598 | if (tempColumn == null || tempIdValue == null) { 599 | if (LOG.isDebugEnabled()) { 600 | LOG.debug("there is no set update value or no primary key in your SQL statement"); 601 | } 602 | return new SqlAndParams(false, "there is no set update value or no primary key in your SQL statement"); 603 | } 604 | params.addValue(tempIdValue); 605 | String sql = String.format("update %s set %s where %s = ? ", tableName(), tempColumn, primaryId()); 606 | SqlAndParams result = new SqlAndParams(sql, params); 607 | if (LOG.isDebugEnabled()) { 608 | LOG.debug("updateNonEmptyByIdSQL : " + result.toString()); 609 | } 610 | return result; 611 | } 612 | 613 | @Override 614 | public SqlAndParams updateNonEmptyByAssistSQL(T obj, SqlAssist assist) { 615 | if (assist == null || assist.getCondition() == null || assist.getCondition().size() < 1) { 616 | return new SqlAndParams(false, "SqlAssist or SqlAssist.condition is null"); 617 | } 618 | Tuple params = Tuple.tuple(); 619 | StringBuilder tempColumn = null; 620 | List> propertyValue; 621 | try { 622 | propertyValue = getPropertyValue(obj); 623 | } catch (Exception e) { 624 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 625 | } 626 | for (SqlPropertyValue pv : propertyValue) { 627 | if (pv.getValue() != null) { 628 | if (tempColumn == null) { 629 | tempColumn = new StringBuilder(pv.getName() + " = ? "); 630 | } else { 631 | tempColumn.append(", " + pv.getName() + " = ? "); 632 | } 633 | params.addValue(pv.getValue()); 634 | } 635 | } 636 | 637 | if (tempColumn == null) { 638 | return new SqlAndParams(false, "The object has no value"); 639 | } 640 | 641 | List> where = assist.getCondition(); 642 | StringBuilder whereStr = new StringBuilder(" where " + where.get(0).getRequire()); 643 | if (where.get(0).getValue() != null) { 644 | params.addValue(where.get(0).getValue()); 645 | } 646 | if (where.get(0).getValues() != null) { 647 | for (Object value : where.get(0).getValues()) { 648 | params.addValue(value); 649 | } 650 | } 651 | for (int i = 1; i < where.size(); i++) { 652 | whereStr.append(where.get(i).getRequire()); 653 | if (where.get(i).getValue() != null) { 654 | params.addValue(where.get(i).getValue()); 655 | } 656 | if (where.get(i).getValues() != null) { 657 | for (Object value : where.get(i).getValues()) { 658 | params.addValue(value); 659 | } 660 | } 661 | } 662 | String sql = String.format("update %s set %s %s", tableName(), tempColumn, whereStr); 663 | SqlAndParams result = new SqlAndParams(sql.toString(), params); 664 | if (LOG.isDebugEnabled()) { 665 | LOG.debug("updateNonEmptyByAssistSQL : " + result.toString()); 666 | } 667 | return result; 668 | } 669 | 670 | @Override 671 | public SqlAndParams updateSetNullByIdSQL(S primaryValue, List columns) { 672 | if (primaryId() == null) { 673 | return new SqlAndParams(false, "there is no primary key in your SQL statement"); 674 | } 675 | 676 | if (columns == null || columns.size() == 0) { 677 | return new SqlAndParams(false, "Columns cannot be null or empty"); 678 | } 679 | StringBuilder setStr = new StringBuilder(); 680 | setStr.append(" " + columns.get(0) + " = null "); 681 | for (int i = 1; i < columns.size(); i++) { 682 | setStr.append(", " + columns.get(i) + " = null "); 683 | } 684 | String sql = String.format("update %s set %s where %s = ? ", tableName(), setStr.toString(), primaryId()); 685 | SqlAndParams result = new SqlAndParams(sql, Tuple.of(primaryValue)); 686 | if (LOG.isDebugEnabled()) { 687 | LOG.debug("updateSetNullById : " + result.toString()); 688 | } 689 | return result; 690 | } 691 | 692 | @Override 693 | public SqlAndParams updateSetNullByAssistSQL(SqlAssist assist, List columns) { 694 | if (assist == null || assist.getCondition() == null || assist.getCondition().size() < 1) { 695 | return new SqlAndParams(false, "SqlAssist or SqlAssist.condition is null"); 696 | } 697 | if (columns == null || columns.size() == 0) { 698 | return new SqlAndParams(false, "Columns cannot be null or empty"); 699 | } 700 | StringBuilder setStr = new StringBuilder(); 701 | setStr.append(" " + columns.get(0) + " = null "); 702 | for (int i = 1; i < columns.size(); i++) { 703 | setStr.append(", " + columns.get(i) + " = null "); 704 | } 705 | Tuple params = Tuple.tuple(); 706 | List> where = assist.getCondition(); 707 | StringBuilder whereStr = new StringBuilder(" where " + where.get(0).getRequire()); 708 | if (where.get(0).getValue() != null) { 709 | params.addValue(where.get(0).getValue()); 710 | } 711 | if (where.get(0).getValues() != null) { 712 | for (Object value : where.get(0).getValues()) { 713 | params.addValue(value); 714 | } 715 | } 716 | for (int i = 1; i < where.size(); i++) { 717 | whereStr.append(where.get(i).getRequire()); 718 | if (where.get(i).getValue() != null) { 719 | params.addValue(where.get(i).getValue()); 720 | } 721 | if (where.get(i).getValues() != null) { 722 | for (Object value : where.get(i).getValues()) { 723 | params.addValue(value); 724 | } 725 | } 726 | } 727 | String sql = String.format("update %s set %s %s", tableName(), setStr.toString(), whereStr); 728 | SqlAndParams result = new SqlAndParams(sql.toString(), params); 729 | if (LOG.isDebugEnabled()) { 730 | LOG.debug("updateSetNullByAssist : " + result.toString()); 731 | } 732 | return result; 733 | } 734 | 735 | @Override 736 | public SqlAndParams deleteByIdSQL(S primaryValue) { 737 | if (primaryId() == null) { 738 | return new SqlAndParams(false, "there is no primary key in your SQL statement"); 739 | } 740 | String sql = String.format("delete from %s where %s = ? ", tableName(), primaryId()); 741 | SqlAndParams result = new SqlAndParams(sql, Tuple.of(primaryValue)); 742 | if (LOG.isDebugEnabled()) { 743 | LOG.debug("deleteByIdSQL : " + result.toString()); 744 | } 745 | return result; 746 | } 747 | 748 | @Override 749 | public SqlAndParams deleteByAssistSQL(SqlAssist assist) { 750 | if (assist == null || assist.getCondition() == null || assist.getCondition().size() < 1) { 751 | return new SqlAndParams(false, "SqlAssist or SqlAssist.condition is null"); 752 | } 753 | List> where = assist.getCondition(); 754 | Tuple params = Tuple.tuple(); 755 | StringBuilder whereStr = new StringBuilder(" where " + where.get(0).getRequire()); 756 | if (where.get(0).getValue() != null) { 757 | params.addValue(where.get(0).getValue()); 758 | } 759 | if (where.get(0).getValues() != null) { 760 | for (Object value : where.get(0).getValues()) { 761 | params.addValue(value); 762 | } 763 | } ; 764 | for (int i = 1; i < where.size(); i++) { 765 | whereStr.append(where.get(i).getRequire()); 766 | if (where.get(i).getValue() != null) { 767 | params.addValue(where.get(i).getValue()); 768 | } 769 | if (where.get(i).getValues() != null) { 770 | for (Object value : where.get(i).getValues()) { 771 | params.addValue(value); 772 | } 773 | } 774 | } 775 | String sql = String.format("delete from %s %s", tableName(), whereStr); 776 | SqlAndParams result = new SqlAndParams(sql, params); 777 | if (LOG.isDebugEnabled()) { 778 | LOG.debug("deleteByAssistSQL : " + result.toString()); 779 | } 780 | return result; 781 | } 782 | 783 | } 784 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/DB2StatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.impl.logging.Logger; 6 | import io.vertx.core.impl.logging.LoggerFactory; 7 | import io.vertx.ext.sql.assist.SqlAndParams; 8 | import io.vertx.ext.sql.assist.SqlAssist; 9 | import io.vertx.ext.sql.assist.SqlPropertyValue; 10 | import io.vertx.ext.sql.assist.SqlWhereCondition; 11 | import io.vertx.sqlclient.Tuple; 12 | 13 | /** 14 | * DB2通用SQL操作 15 | * 16 | * @author Mirren 17 | * 18 | * @param 19 | */ 20 | public class DB2StatementSQL extends AbstractStatementSQL { 21 | public DB2StatementSQL(Class entity) { 22 | super(entity); 23 | } 24 | 25 | /** 日志工具 */ 26 | private final Logger LOG = LoggerFactory.getLogger(DB2StatementSQL.class); 27 | 28 | @Override 29 | public SqlAndParams selectAllSQL(SqlAssist assist) { 30 | if (assist != null && assist.getRowSize() != null) { 31 | String distinct = assist.getDistinct() == null ? "" : assist.getDistinct();// 去重语句 32 | String column = assist.getResultColumn() == null ? resultColumns() : assist.getResultColumn();// 表的列名 33 | StringBuilder sql = new StringBuilder(); 34 | // SQL语句添加分页 35 | sql.append("select * from ( select temp_table.*, rownumber () over () as tt_row_index from ("); 36 | // SQL语句主查询 37 | sql.append(String.format("select %s %s from %s", distinct, column, tableName())); 38 | Tuple params = Tuple.tuple();// 参数 39 | if (assist.getJoinOrReference() != null) { 40 | sql.append(assist.getJoinOrReference()); 41 | } 42 | if (assist.getCondition() != null && assist.getCondition().size() > 0) { 43 | List> where = assist.getCondition(); 44 | sql.append(" where " + where.get(0).getRequire()); 45 | if (where.get(0).getValue() != null) { 46 | params.addValue(where.get(0).getValue()); 47 | } 48 | if (where.get(0).getValues() != null) { 49 | for (Object value : where.get(0).getValues()) { 50 | params.addValue(value); 51 | } 52 | } 53 | for (int i = 1; i < where.size(); i++) { 54 | sql.append(where.get(i).getRequire()); 55 | if (where.get(i).getValue() != null) { 56 | params.addValue(where.get(i).getValue()); 57 | } 58 | if (where.get(i).getValues() != null) { 59 | for (Object value : where.get(i).getValues()) { 60 | params.addValue(value); 61 | } 62 | } 63 | } 64 | } 65 | if (assist.getGroupBy() != null) { 66 | sql.append(" group by " + assist.getGroupBy() + " "); 67 | } 68 | if (assist.getHaving() != null) { 69 | sql.append(" having " + assist.getHaving() + " "); 70 | if (assist.getHavingValue() != null) { 71 | for (Object value : assist.getHavingValue()) { 72 | params.addValue(value); 73 | } 74 | } 75 | } 76 | if (assist.getOrder() != null) { 77 | sql.append(assist.getOrder()); 78 | } 79 | // SQL分页语句添加别名与结尾 80 | sql.append(") AS temp_table ) AS tt_result_table "); 81 | sql.append(" where tt_result_table.tt_row_index between ? and ? "); 82 | 83 | int startRow = assist.getStartRow() == null ? 0 : assist.getStartRow(); 84 | params.addValue(startRow); 85 | params.addValue(startRow + assist.getRowSize()); 86 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 87 | if (LOG.isDebugEnabled()) { 88 | LOG.debug("SelectAllSQL : " + result.toString()); 89 | } 90 | return result; 91 | } else { 92 | return super.selectAllSQL(assist); 93 | } 94 | } 95 | 96 | @Override 97 | public SqlAndParams selectByObjSQL(T obj, String resultColumns, String tableAlias, String joinOrReference, boolean single) { 98 | StringBuilder sql = new StringBuilder( 99 | String.format("select %s from %s %s ",(resultColumns == null ? resultColumns() : resultColumns), 100 | (tableName() + (tableAlias == null ? "" : (" AS " + tableAlias))), 101 | (joinOrReference == null ? "" : joinOrReference))); 102 | Tuple params = null; 103 | boolean isFrist = true; 104 | List> propertyValue; 105 | try { 106 | propertyValue = getPropertyValue(obj); 107 | } catch (Exception e) { 108 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 109 | } 110 | for (int i = propertyValue.size() - 1; i >= 0; i--) { 111 | SqlPropertyValue pv = propertyValue.get(i); 112 | if (pv.getValue() != null) { 113 | if (isFrist) { 114 | sql.append(String.format("where %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 115 | params = Tuple.of(pv.getValue()); 116 | isFrist = false; 117 | } else { 118 | sql.append(String.format("and %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 119 | params.addValue(pv.getValue()); 120 | } 121 | } 122 | } 123 | if (single) { 124 | sql.append(" FETCH FIRST 1 ROWS ONLY "); 125 | } 126 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 127 | if (LOG.isDebugEnabled()) { 128 | LOG.debug("selectByObjSQL : " + result.toString()); 129 | } 130 | return result; 131 | } 132 | 133 | } 134 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/MySQLStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | /** 4 | * MySQL通用SQL操作 5 | * 6 | * @author Mirren 7 | * 8 | * @param 9 | */ 10 | public class MySQLStatementSQL extends AbstractStatementSQL { 11 | 12 | public MySQLStatementSQL(Class entity) { 13 | super(entity); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/OracleStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.impl.logging.Logger; 6 | import io.vertx.core.impl.logging.LoggerFactory; 7 | import io.vertx.ext.sql.assist.SqlAndParams; 8 | import io.vertx.ext.sql.assist.SqlAssist; 9 | import io.vertx.ext.sql.assist.SqlPropertyValue; 10 | import io.vertx.ext.sql.assist.SqlWhereCondition; 11 | import io.vertx.sqlclient.Tuple; 12 | 13 | /** 14 | * Oracle通用SQL操作 15 | * 16 | * @author Mirren 17 | * 18 | * @param 19 | */ 20 | public class OracleStatementSQL extends AbstractStatementSQL { 21 | public OracleStatementSQL(Class entity) { 22 | super(entity); 23 | } 24 | 25 | /** 日志工具 */ 26 | private final Logger LOG = LoggerFactory.getLogger(OracleStatementSQL.class); 27 | 28 | @Override 29 | public SqlAndParams selectAllSQL(SqlAssist assist) { 30 | if (assist != null && assist.getRowSize() != null) { 31 | String distinct = assist.getDistinct() == null ? "" : assist.getDistinct();// 去重语句 32 | String column = assist.getResultColumn() == null ? resultColumns() : assist.getResultColumn();// 表的列名 33 | StringBuilder sql = new StringBuilder(); 34 | // SQL语句添加分页 35 | sql.append("select * from ( select temp_table.*, ROWNUM AS tt_row_index from ("); 36 | // SQL语句主查询 37 | sql.append(String.format("select %s %s from %s", distinct, column, tableName())); 38 | Tuple params = Tuple.tuple();// 参数 39 | if (assist.getJoinOrReference() != null) { 40 | sql.append(assist.getJoinOrReference()); 41 | } 42 | if (assist.getCondition() != null && assist.getCondition().size() > 0) { 43 | List> where = assist.getCondition(); 44 | sql.append(" where " + where.get(0).getRequire()); 45 | if (where.get(0).getValue() != null) { 46 | params.addValue(where.get(0).getValue()); 47 | } 48 | if (where.get(0).getValues() != null) { 49 | for (Object value : where.get(0).getValues()) { 50 | params.addValue(value); 51 | } 52 | } 53 | for (int i = 1; i < where.size(); i++) { 54 | sql.append(where.get(i).getRequire()); 55 | if (where.get(i).getValue() != null) { 56 | params.addValue(where.get(i).getValue()); 57 | } 58 | if (where.get(i).getValues() != null) { 59 | for (Object value : where.get(i).getValues()) { 60 | params.addValue(value); 61 | } 62 | } 63 | } 64 | } 65 | if (assist.getGroupBy() != null) { 66 | sql.append(" group by " + assist.getGroupBy() + " "); 67 | } 68 | if (assist.getHaving() != null) { 69 | sql.append(" having " + assist.getHaving() + " "); 70 | if (assist.getHavingValue() != null) { 71 | for (Object value : assist.getHavingValue()) { 72 | params.addValue(value); 73 | } 74 | } 75 | } 76 | if (assist.getOrder() != null) { 77 | sql.append(assist.getOrder()); 78 | } 79 | // SQL分页语句添加别名与结尾 80 | sql.append(") temp_table where ROWNUM <= ? ) tt_result_table "); 81 | sql.append(" where tt_result_table.tt_row_index >= ? "); 82 | int startRow = assist.getStartRow() == null ? 0 : assist.getStartRow(); 83 | params.addValue(startRow + assist.getRowSize()); 84 | params.addValue(startRow); 85 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 86 | if (LOG.isDebugEnabled()) { 87 | LOG.debug("SelectAllSQL : " + result.toString()); 88 | } 89 | return result; 90 | } else { 91 | return super.selectAllSQL(assist); 92 | } 93 | } 94 | 95 | @Override 96 | public SqlAndParams selectByObjSQL(T obj, String resultColumns, String tableAlias,String joinOrReference, boolean single) { 97 | StringBuilder sql = new StringBuilder( 98 | String.format("select %s from %s %s ", (resultColumns == null ? resultColumns() : resultColumns), 99 | (tableName() + (tableAlias == null ? "" : (" AS " + tableAlias))), 100 | (joinOrReference == null ? "" : joinOrReference))); 101 | Tuple params = Tuple.tuple(); 102 | boolean isFrist = true; 103 | List> propertyValue; 104 | try { 105 | propertyValue = getPropertyValue(obj); 106 | } catch (Exception e) { 107 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 108 | } 109 | for (int i = propertyValue.size() - 1; i >= 0; i--) { 110 | SqlPropertyValue pv = propertyValue.get(i); 111 | if (pv.getValue() != null) { 112 | if (isFrist) { 113 | sql.append(String.format("where %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 114 | isFrist = false; 115 | } else { 116 | sql.append(String.format("and %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 117 | } 118 | params.addValue(pv.getValue()); 119 | } 120 | } 121 | if (single) { 122 | if (!isFrist) { 123 | sql.append(" and "); 124 | } 125 | sql.append(" rownum <=1 "); 126 | } 127 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 128 | if (LOG.isDebugEnabled()) { 129 | LOG.debug("selectByObjSQL : " + result.toString()); 130 | } 131 | return result; 132 | } 133 | 134 | } 135 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/PostgreSQLStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | /** 4 | * SQLite通用SQL操作 5 | * 6 | * @author Mirren 7 | * 8 | * @param 9 | */ 10 | public class PostgreSQLStatementSQL extends AbstractStatementSQL { 11 | 12 | public PostgreSQLStatementSQL(Class entity) { 13 | super(entity); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/SQLiteStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | /** 4 | * SQLite通用SQL操作 5 | * 6 | * @author Mirren 7 | * 8 | */ 9 | public class SQLiteStatementSQL extends AbstractStatementSQL { 10 | 11 | public SQLiteStatementSQL(Class entity) { 12 | super(entity); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/io/vertx/ext/sql/assist/sql/SqlServerStatementSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import java.util.List; 4 | 5 | import io.vertx.core.impl.logging.Logger; 6 | import io.vertx.core.impl.logging.LoggerFactory; 7 | import io.vertx.ext.sql.assist.SqlAndParams; 8 | import io.vertx.ext.sql.assist.SqlAssist; 9 | import io.vertx.ext.sql.assist.SqlPropertyValue; 10 | import io.vertx.ext.sql.assist.SqlWhereCondition; 11 | import io.vertx.sqlclient.Tuple; 12 | 13 | /** 14 | * SQL Server通用SQL操作 15 | * 16 | * @author Mirren 17 | * 18 | * @param 19 | */ 20 | public class SqlServerStatementSQL extends AbstractStatementSQL { 21 | public SqlServerStatementSQL(Class entity) { 22 | super(entity); 23 | } 24 | 25 | /** 日志工具 */ 26 | private final Logger LOG = LoggerFactory.getLogger(AbstractStatementSQL.class); 27 | /** 28 | * 分页的排序,子类可以重写该方法 29 | * 30 | * @return 31 | */ 32 | 33 | /** 34 | * 分页时指定排序的SQL语句,默认排序主键,子类可以重写该方法排序其他的列
35 | * tips:当assist.getOrder()不为空时则该方法无效 36 | * 37 | * @param cols 38 | * @return 39 | */ 40 | protected String getRowNumberOverSQL(String cols) { 41 | return " order by " + cols + " "; 42 | } 43 | 44 | @Override 45 | public SqlAndParams selectAllSQL(SqlAssist assist) { 46 | if (assist != null && assist.getRowSize() != null) { 47 | String distinct = assist.getDistinct() == null ? "" : assist.getDistinct();// 去重语句 48 | String column = assist.getResultColumn() == null ? resultColumns() : assist.getResultColumn();// 表的列名 49 | StringBuilder sql = new StringBuilder(); 50 | // SQL语句添加分页 51 | sql.append("select * from ( "); 52 | sql.append(String.format("select %s %s,row_number() over(", distinct, column)); 53 | if (assist.getOrder() != null) { 54 | sql.append(assist.getOrder()); 55 | } else { 56 | sql.append(getRowNumberOverSQL(primaryId())); 57 | } 58 | sql.append(String.format(") AS tt_row_index from %s ", tableName())); 59 | Tuple params = Tuple.tuple();// 参数 60 | if (assist.getJoinOrReference() != null) { 61 | sql.append(assist.getJoinOrReference()); 62 | } 63 | if (assist.getCondition() != null && assist.getCondition().size() > 0) { 64 | List> where = assist.getCondition(); 65 | sql.append(" where " + where.get(0).getRequire()); 66 | if (where.get(0).getValue() != null) { 67 | params.addValue(where.get(0).getValue()); 68 | } 69 | if (where.get(0).getValues() != null) { 70 | for (Object value : where.get(0).getValues()) { 71 | params.addValue(value); 72 | } 73 | } 74 | for (int i = 1; i < where.size(); i++) { 75 | sql.append(where.get(i).getRequire()); 76 | if (where.get(i).getValue() != null) { 77 | params.addValue(where.get(i).getValue()); 78 | } 79 | if (where.get(i).getValues() != null) { 80 | for (Object value : where.get(i).getValues()) { 81 | params.addValue(value); 82 | } 83 | } 84 | } 85 | } 86 | if (assist.getGroupBy() != null) { 87 | sql.append(" group by " + assist.getGroupBy() + " "); 88 | } 89 | if (assist.getHaving() != null) { 90 | sql.append(" having " + assist.getHaving() + " "); 91 | if (assist.getHavingValue() != null) { 92 | for (Object value : assist.getHavingValue()) { 93 | params.addValue(value); 94 | } 95 | } 96 | } 97 | // SQL分页语句添加别名与结尾 98 | sql.append(" ) AS tt_result_table "); 99 | sql.append(" where tt_row_index > ? and tt_row_index <= ? "); 100 | int startRow = assist.getStartRow() == null ? 0 : assist.getStartRow(); 101 | params.addValue(startRow); 102 | params.addValue(startRow + assist.getRowSize()); 103 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 104 | if (LOG.isDebugEnabled()) { 105 | LOG.debug("SelectAllSQL : " + result.toString()); 106 | } 107 | return result; 108 | } else { 109 | return super.selectAllSQL(assist); 110 | } 111 | } 112 | 113 | @Override 114 | public SqlAndParams selectByObjSQL(T obj, String resultColumns,String tableAlias, String joinOrReference, boolean single) { 115 | StringBuilder sql = new StringBuilder( 116 | String.format("select %s %s from %s %s ", (single ? "top 1" : ""), (resultColumns == null ? resultColumns() : resultColumns), 117 | (tableName() + (tableAlias == null ? "" : (" AS " + tableAlias))), 118 | (joinOrReference == null ? "" : joinOrReference))); 119 | Tuple params = Tuple.tuple(); 120 | boolean isFrist = true; 121 | List> propertyValue; 122 | try { 123 | propertyValue = getPropertyValue(obj); 124 | } catch (Exception e) { 125 | return new SqlAndParams(false, " Get SqlPropertyValue failed: " + e.getMessage()); 126 | } 127 | for (int i = propertyValue.size() - 1; i >= 0; i--) { 128 | SqlPropertyValue pv = propertyValue.get(i); 129 | if (pv.getValue() != null) { 130 | if (isFrist) { 131 | sql.append(String.format("where %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 132 | isFrist = false; 133 | } else { 134 | sql.append(String.format("and %s = ? ", (tableAlias == null ? "" : (tableAlias+"."))+pv.getName())); 135 | } 136 | params.addValue(pv.getValue()); 137 | } 138 | } 139 | SqlAndParams result = new SqlAndParams(sql.toString(), (params.size() <= 0 ? null : params)); 140 | if (LOG.isDebugEnabled()) { 141 | LOG.debug("selectByObjSQL : " + result.toString()); 142 | } 143 | return result; 144 | } 145 | 146 | } 147 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/JdbcPoolTest.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | import io.vertx.core.Vertx; 7 | import io.vertx.core.json.JsonObject; 8 | import io.vertx.ext.sql.assist.entity.Student; 9 | import io.vertx.ext.sql.assist.sql.StudentSQL; 10 | import io.vertx.jdbcclient.JDBCPool; 11 | 12 | public class JdbcPoolTest extends TestSuite { 13 | public static void main(String[] args) { 14 | Vertx vertx = Vertx.vertx(); 15 | JsonObject config = new JsonObject(); 16 | // config.put("url", 17 | // "jdbc:mysql://10.0.0.79:3306/orion_api_manager?useUnicode=true&useSSL=false&serverTimezone=UTC") 18 | // .put("driver_class", "com.mysql.cj.jdbc.Driver").put("user", 19 | // "root").put("password", "root"); 20 | config.put("url", String.format("jdbc:sqlite:%s/data/sqlite.db", System.getProperty("user.dir"))).put("driver_class", 21 | "org.sqlite.JDBC"); 22 | JDBCPool jdbcPool = JDBCPool.pool(vertx, config); 23 | StudentSQL sql = new StudentSQL(SQLExecute.createJDBC(jdbcPool)); 24 | JdbcPoolTest test = new JdbcPoolTest(sql, config); 25 | test.runTest(res -> System.exit(0)); 26 | } 27 | 28 | public JdbcPoolTest(StudentSQL sql, JsonObject config) { 29 | super(sql, config); 30 | } 31 | 32 | @Override 33 | public Student insertAllData() { 34 | return new Student().setId(1).setCid(1).setNickname("nickname"); 35 | } 36 | @Override 37 | public Student insertNonEmptyData() { 38 | return new Student().setId(2).setCid(1); 39 | } 40 | 41 | @Override 42 | public int insertNonEmptyGeneratedKeysResultPoolType() { 43 | return 0; 44 | } 45 | 46 | @Override 47 | public Student insertNonEmptyGeneratedKeysData() { 48 | return new Student().setCid(1).setNickname("nickname").setPwd("pwd"); 49 | } 50 | 51 | @Override 52 | public List insertBatchData() { 53 | return Arrays.asList(new Student().setCid(1).setPwd("batch"), new Student().setCid(1).setPwd("batch")); 54 | } 55 | 56 | @Override 57 | public Student replaceData() { 58 | return new Student().setId(1).setCid(1).setNickname("replace").setPwd("replace"); 59 | } 60 | 61 | @Override 62 | public Student updateAllByIdData() { 63 | return new Student().setId(1).setCid(1).setNickname("update"); 64 | } 65 | 66 | @Override 67 | public Student updateAllByAssistData() { 68 | return new Student().setId(1).setCid(1).setPwd("updatebyAssist"); 69 | } 70 | 71 | @Override 72 | public Student updateNonEmptyByIdData() { 73 | return new Student().setId(1).setCid(1).setNickname("nickname"); 74 | } 75 | 76 | @Override 77 | public Student updateNonEmptyByAssistData() { 78 | return new Student().setPwd("updateNonEmptyByAssist"); 79 | } 80 | 81 | @Override 82 | public Student selectByObjData() { 83 | return new Student().setCid(1); 84 | } 85 | 86 | } 87 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/MySQLPoolTest.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | import io.vertx.core.Vertx; 7 | import io.vertx.core.json.JsonObject; 8 | import io.vertx.ext.sql.assist.sql.JsonObjectSQL; 9 | import io.vertx.mysqlclient.MySQLConnectOptions; 10 | import io.vertx.mysqlclient.MySQLPool; 11 | import io.vertx.sqlclient.PoolOptions; 12 | 13 | public class MySQLPoolTest extends TestSuite { 14 | public static void main(String[] args) { 15 | Vertx vertx = Vertx.vertx(); 16 | JsonObject config = new JsonObject(); 17 | config.put("url", "jdbc:mysql://10.0.0.79:3306/test_db?useUnicode=true&useSSL=false&serverTimezone=UTC") 18 | .put("driver_class", "com.mysql.cj.jdbc.Driver").put("user", "root").put("password", "root"); 19 | 20 | MySQLConnectOptions connectOptions = new MySQLConnectOptions().setPort(3306).setHost("10.0.0.79").setDatabase("test_db").setUser("root") 21 | .setPassword("root"); 22 | MySQLPool pool = MySQLPool.pool(vertx, connectOptions, new PoolOptions()); 23 | JsonObjectSQL sql = new JsonObjectSQL(SQLExecute.createMySQL(pool)); 24 | MySQLPoolTest test = new MySQLPoolTest(sql, config); 25 | test.runTest(res -> System.exit(0)); 26 | } 27 | 28 | public MySQLPoolTest(JsonObjectSQL sql, JsonObject config) { 29 | super(sql, config); 30 | } 31 | 32 | @Override 33 | public JsonObject insertAllData() { 34 | return new JsonObject().put("id", 1).put("cid", 1).put("nickname", "nickname"); 35 | } 36 | @Override 37 | public JsonObject insertNonEmptyData() { 38 | return new JsonObject().put("id", 2).put("cid", 1); 39 | } 40 | 41 | @Override 42 | public int insertNonEmptyGeneratedKeysResultPoolType() { 43 | return 1; 44 | } 45 | 46 | @Override 47 | public JsonObject insertNonEmptyGeneratedKeysData() { 48 | return new JsonObject().put("cid", 1).put("nickname", "nickname").put("pwd", "pwd"); 49 | } 50 | 51 | @Override 52 | public List insertBatchData() { 53 | return Arrays.asList(new JsonObject().put("cid", 1).put("pwd", "batch"), new JsonObject().put("cid", 1).put("pwd", "batch")); 54 | } 55 | 56 | @Override 57 | public JsonObject replaceData() { 58 | return new JsonObject().put("id", 1).put("cid", 1).put("nickname", "replace").put("pwd", "replace"); 59 | } 60 | 61 | @Override 62 | public JsonObject updateAllByIdData() { 63 | return new JsonObject().put("id", 1).put("cid", 1).put("nickname", "update"); 64 | } 65 | 66 | @Override 67 | public JsonObject updateAllByAssistData() { 68 | return new JsonObject().put("id", 1).put("cid", 1).put("pwd", "updatebyAssist"); 69 | } 70 | 71 | @Override 72 | public JsonObject updateNonEmptyByIdData() { 73 | return new JsonObject().put("id", 1).put("cid", 1).put("nickname", "nickname"); 74 | } 75 | 76 | @Override 77 | public JsonObject updateNonEmptyByAssistData() { 78 | return new JsonObject().put("pwd", "updateNonEmptyByAssist"); 79 | } 80 | 81 | @Override 82 | public JsonObject selectByObjData() { 83 | return new JsonObject().put("cid", 1); 84 | } 85 | 86 | } 87 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/TestSuite.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Objects; 6 | 7 | import org.mirrentools.sd.ScrewDriver; 8 | import org.mirrentools.sd.ScrewDriverDbUtil; 9 | import org.mirrentools.sd.SdType; 10 | import org.mirrentools.sd.models.SdBean; 11 | import org.mirrentools.sd.models.SdColumn; 12 | import org.mirrentools.sd.models.db.update.SdBasicTableContent; 13 | import org.mirrentools.sd.options.ScrewDriverOptions; 14 | import org.mirrentools.sd.options.SdDatabaseOptions; 15 | 16 | import io.vertx.core.AsyncResult; 17 | import io.vertx.core.Future; 18 | import io.vertx.core.Handler; 19 | import io.vertx.core.impl.logging.Logger; 20 | import io.vertx.core.impl.logging.LoggerFactory; 21 | import io.vertx.core.json.JsonObject; 22 | import io.vertx.jdbcclient.JDBCPool; 23 | import io.vertx.mysqlclient.MySQLClient; 24 | import io.vertx.sqlclient.Tuple; 25 | /** 26 | * 测试方法合集 27 | * 28 | * @author Mirren 29 | * 30 | * @param 31 | * @param 32 | */ 33 | public abstract class TestSuite { 34 | /** 日志工具 */ 35 | private final Logger LOG = LoggerFactory.getLogger(TestSuite.class); 36 | 37 | private final static String COLUMN_ID = "id"; 38 | private final static String COLUMN_CID = "cid"; 39 | private final static String COLUMN_NICKNAME = "nickname"; 40 | private final static String COLUMN_PWD = "pwd"; 41 | private final static String KEY_PWD = "possword"; 42 | 43 | private CommonSQL sql; 44 | /** 数据库连接信息 */ 45 | private JsonObject config; 46 | public TestSuite(CommonSQL sql, JsonObject config) { 47 | this.sql = sql; 48 | this.config = config; 49 | } 50 | /** 51 | * 执行测试 52 | * 53 | * @return 54 | */ 55 | public void runTest(Handler> handler) { 56 | try { 57 | resetDB(); 58 | } catch (Throwable e) { 59 | failed(e, handler); 60 | } 61 | insertAll(handler); 62 | }; 63 | 64 | /** 65 | * 重设数据库表 66 | * 67 | * @throws Throwable 68 | */ 69 | public void resetDB() throws Throwable { 70 | SdDatabaseOptions dbOptions = new SdDatabaseOptions(config.getString("driver_class"), config.getString("url")); 71 | if (config.getString("user") != null) { 72 | dbOptions.setUser(config.getString("user")); 73 | } 74 | if (config.getString("password") != null) { 75 | dbOptions.setPassword(config.getString("password")); 76 | } 77 | String classesName = "classes"; 78 | String studentName = "student"; 79 | 80 | ScrewDriver screwDriver = ScrewDriver.instance(new ScrewDriverOptions(dbOptions)); 81 | ScrewDriverDbUtil dbUtil = ScrewDriverDbUtil.instance(dbOptions); 82 | // 重置学生表 83 | SdBasicTableContent studentContent = new SdBasicTableContent() { 84 | }; 85 | studentContent.setTableName(studentName); 86 | dbUtil.deleteTable(studentContent); 87 | 88 | // 重置班级表 89 | SdBasicTableContent classesContent = new SdBasicTableContent() { 90 | }; 91 | classesContent.setTableName(classesName); 92 | dbUtil.deleteTable(classesContent); 93 | SdBean classesbean = new SdBean().setName(classesName); 94 | classesbean.addColumn(new SdColumn().setName("id").setType(SdType.INTEGER).setPrimary(true)) 95 | .addColumn(new SdColumn().setName("classanme").setType(SdType.STRING).setLength(30)); 96 | screwDriver.createTable(classesbean); 97 | 98 | dbUtil.execute(String.format("insert into %s values(1,'class name')", classesName)); 99 | 100 | SdBean bean = new SdBean().setName(studentName); 101 | bean.addColumn(new SdColumn().setName(COLUMN_ID).setType(SdType.INTEGER).setPrimary(true).setAutoIncrement(true)); 102 | bean.addColumn(new SdColumn().setName(COLUMN_CID).setType(SdType.INTEGER).setForeignConstraint("FK_classes_student_id") 103 | .setForeignReferencesTable(classesName).setForeignReferencesColumn("id")); 104 | bean.addColumn(new SdColumn().setName(COLUMN_NICKNAME).setType(SdType.STRING).setLength(255)); 105 | bean.addColumn(new SdColumn().setName(COLUMN_PWD).setType(SdType.STRING).setLength(255)); 106 | screwDriver.createTable(bean); 107 | } 108 | /** 109 | * 测试成功 110 | * 111 | * @param handler 112 | */ 113 | public void succeeded(Handler> handler) { 114 | System.out.println("==================================================="); 115 | System.out.println("=====================succeeded====================="); 116 | System.out.println("==================================================="); 117 | handler.handle(Future.succeededFuture(1)); 118 | } 119 | /** 120 | * 测试失败 121 | * 122 | * @param fun 123 | * 方法的名称 124 | * @param err 125 | * 异常的信息 126 | * @param handler 127 | * 操作 128 | */ 129 | public void failed(Throwable err, Handler> handler) { 130 | err.printStackTrace(); 131 | System.out.println("**********************************************"); 132 | System.out.println("********************failed********************"); 133 | System.out.println(err.getMessage()); 134 | System.out.println("**********************************************"); 135 | handler.handle(Future.failedFuture(err)); 136 | } 137 | /** 138 | * 测试失败 139 | * 140 | * @param handler 141 | */ 142 | public void failed(String err, Handler> handler) { 143 | System.out.println("**********************************************"); 144 | System.out.println("********************failed********************"); 145 | System.out.println(err); 146 | System.out.println("**********************************************"); 147 | handler.handle(Future.failedFuture(err)); 148 | } 149 | 150 | /** 测试新增所有的数据,要求:id=1,cid=1,nickname=nickname,pwd=null */ 151 | public abstract E insertAllData(); 152 | public void insertAll(Handler> handler) { 153 | System.out.println("================================================="); 154 | sql.insertAll(insertAllData()).onSuccess(res -> { 155 | LOG.info("insertAll 执行结果:" + res); 156 | if (Objects.equals(1, res)) { 157 | getByIdAndEquals(1, "nickname", null, test -> { 158 | if (Objects.equals(true, test.result())) { 159 | LOG.info("insertAll 测试通过!"); 160 | insertNonEmpty(handler); 161 | } else { 162 | LOG.info("insertAll 结果不匹配!"); 163 | failed("insertAll 结果不匹配!" + test.cause().getMessage(), handler); 164 | } 165 | }); 166 | } else { 167 | LOG.info("insertAll 结果不匹配!"); 168 | String format = String.format("insertAll 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 169 | failed(format, handler); 170 | } 171 | }).onFailure(err -> failed(err, handler)); 172 | } 173 | 174 | /** 测试新增不为空的数据,要求:id=2,cid=1,nickname=null,pwd=null */ 175 | public abstract E insertNonEmptyData(); 176 | public void insertNonEmpty(Handler> handler) { 177 | System.out.println("================================================="); 178 | sql.insertNonEmpty(insertNonEmptyData()).onSuccess(res -> { 179 | LOG.info("insertNonEmpty 执行结果:" + res); 180 | if (Objects.equals(1, res)) { 181 | getByIdAndEquals(2, null, null, test -> { 182 | if (Objects.equals(true, test.result())) { 183 | LOG.info("insertNonEmpty 测试通过!"); 184 | insertNonEmptyGeneratedKeys(handler); 185 | } else { 186 | LOG.info("insertNonEmpty 结果不匹配!"); 187 | failed("insertNonEmpty 结果不匹配!" + test.cause().getMessage(), handler); 188 | } 189 | }); 190 | } else { 191 | LOG.info("insertNonEmpty 结果不匹配!"); 192 | String format = String.format("insertNonEmpty 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 193 | failed(format, handler); 194 | } 195 | }).onFailure(err -> failed(err, handler)); 196 | } 197 | 198 | /** 测试新增不为空的数据,要求:id=null,cid=1,nickname=nickname,pwd=pwd */ 199 | public abstract E insertNonEmptyGeneratedKeysData(); 200 | /** 0=JDBCPool,1=MySQLPool */ 201 | public abstract int insertNonEmptyGeneratedKeysResultPoolType(); 202 | public void insertNonEmptyGeneratedKeys(Handler> handler) { 203 | System.out.println("================================================="); 204 | int type = insertNonEmptyGeneratedKeysResultPoolType(); 205 | if (type == 0) { 206 | sql.insertNonEmptyGeneratedKeys(insertNonEmptyGeneratedKeysData(), JDBCPool.GENERATED_KEYS).onSuccess(res -> { 207 | LOG.info("insertNonEmptyGeneratedKeys JDBCPool 执行结果:" + res); 208 | int id = (res == null ? 0 : res.getInteger(0)); 209 | if (id >= 1) { 210 | getByIdAndEquals(id, "nickname", "pwd", test -> { 211 | if (Objects.equals(true, test.result())) { 212 | LOG.info("insertNonEmptyGeneratedKeys JDBCPool 测试通过!"); 213 | insertBatch(handler); 214 | } else { 215 | LOG.info("insertNonEmptyGeneratedKeys JDBCPool 结果不匹配!"); 216 | failed("insertNonEmptyGeneratedKeys JDBCPool 结果不匹配!" + test.cause().getMessage(), handler); 217 | } 218 | }); 219 | } else { 220 | LOG.info("insertNonEmptyGeneratedKeys JDBCPool 结果不匹配!"); 221 | String format = String.format("insertNonEmptyGeneratedKeys JDBCPool 结果不匹配!\n期望结果:[>=%d]\n实际结果:[%d]", 1, res); 222 | failed(format, handler); 223 | } 224 | }).onFailure(err -> failed(err, handler)); 225 | } else if (type == 1) { 226 | sql.insertNonEmptyGeneratedKeys(insertNonEmptyGeneratedKeysData(), MySQLClient.LAST_INSERTED_ID).onSuccess(res -> { 227 | LOG.info("insertNonEmptyGeneratedKeys MySQLPool 执行结果:" + res); 228 | int id = (res == null ? 0 : ((Number) res).intValue()); 229 | if (id >= 1) { 230 | getByIdAndEquals(id, "nickname", "pwd", test -> { 231 | if (Objects.equals(true, test.result())) { 232 | LOG.info("insertNonEmptyGeneratedKeys MySQLPool 测试通过!"); 233 | insertBatch(handler); 234 | } else { 235 | LOG.info("insertNonEmptyGeneratedKeys MySQLPool 结果不匹配!"); 236 | failed("insertNonEmptyGeneratedKeys MySQLPool 结果不匹配!" + test.cause().getMessage(), handler); 237 | } 238 | }); 239 | } else { 240 | LOG.info("insertNonEmptyGeneratedKeys MySQLPool 结果不匹配!"); 241 | String format = String.format("insertNonEmptyGeneratedKeys MySQLPool 结果不匹配!\n期望结果:[>=%d]\n实际结果:[%d]", 1, res); 242 | failed(format, handler); 243 | } 244 | }).onFailure(err -> failed(err, handler)); 245 | } else { 246 | LOG.info("insertNonEmptyGeneratedKeys 不认识的Pool类型,无法获取结果,请搜索这句话并添加类型"); 247 | failed("insertNonEmptyGeneratedKeys 不认识的Pool类型,无法获取结果,请搜索这句话并添加类型", handler); 248 | } 249 | 250 | } 251 | 252 | /** 测试批量新增所有,要求2个数据:id=null,cid=1,nickname=null,pwd=batch */ 253 | public abstract List insertBatchData(); 254 | public void insertBatch(Handler> handler) { 255 | System.out.println("================================================="); 256 | sql.insertBatch(insertBatchData()).onSuccess(res -> { 257 | LOG.info("insertBatch 执行结果:" + res); 258 | if (res == 2) { 259 | SqlAssist assist = new SqlAssist(); 260 | assist.and(COLUMN_NICKNAME + " IS NULL").andEq(COLUMN_PWD, "batch"); 261 | getCountAndEquals(assist, 2, test -> { 262 | if (Objects.equals(true, test.result())) { 263 | LOG.info("insertBatch 测试通过!"); 264 | insertBatchCulumns(handler); 265 | } else { 266 | LOG.info("insertBatch 结果不匹配!"); 267 | failed("insertBatch 结果不匹配!" + test.cause().getMessage(), handler); 268 | } 269 | }); 270 | } else { 271 | LOG.info("insertBatch 结果不匹配!"); 272 | String format = String.format("insertBatch 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 2, res); 273 | failed(format, handler); 274 | } 275 | }).onFailure(err -> failed(err, handler)); 276 | } 277 | 278 | public void insertBatchCulumns(Handler> handler) { 279 | System.out.println("================================================="); 280 | sql.insertBatch(Arrays.asList("cid", "pwd"), Arrays.asList(Tuple.of(1, "batch2"), Tuple.of(1, "batch2"))).onSuccess(res -> { 281 | LOG.info("insertBatchCulumns 执行结果:" + res); 282 | if (res == 2) { 283 | SqlAssist assist = new SqlAssist(); 284 | assist.and(COLUMN_NICKNAME + " IS NULL").andEq(COLUMN_PWD, "batch2"); 285 | getCountAndEquals(assist, 2, test -> { 286 | if (Objects.equals(true, test.result())) { 287 | LOG.info("insertBatchCulumns 测试通过!"); 288 | replace(handler); 289 | } else { 290 | LOG.info("insertBatchCulumns 结果不匹配!"); 291 | failed("insertBatchCulumns 结果不匹配!" + test.cause().getMessage(), handler); 292 | } 293 | }); 294 | } else { 295 | LOG.info("insertBatchCulumns 结果不匹配!"); 296 | String format = String.format("insertBatchCulumns 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 2, res); 297 | failed(format, handler); 298 | } 299 | }).onFailure(err -> failed(err, handler)); 300 | } 301 | 302 | /** 测试replace要求:id=1,cid=1,nickname=replace,pwd=replace */ 303 | public abstract E replaceData(); 304 | public void replace(Handler> handler) { 305 | System.out.println("================================================="); 306 | sql.replace(replaceData()).onSuccess(res -> { 307 | LOG.info("replace 执行结果:" + res); 308 | if (res >= 1) { 309 | getByIdAndEquals(1, "replace", "replace", test -> { 310 | if (Objects.equals(true, test.result())) { 311 | LOG.info("replace 测试通过!"); 312 | updateAllById(handler); 313 | } else { 314 | LOG.info("replace 结果不匹配!"); 315 | failed("replace 结果不匹配!" + test.cause().getMessage(), handler); 316 | } 317 | }); 318 | } else { 319 | LOG.info("replace 结果不匹配!"); 320 | String format = String.format("replace 结果不匹配!\n期望结果:[>=%d]\n实际结果:[%d]", 1, res); 321 | failed(format, handler); 322 | } 323 | }).onFailure(err -> failed(err, handler)); 324 | } 325 | 326 | /** 测试根据id修改所有,要求:id=1,cid=1,nickname=update,pwd=null */ 327 | public abstract E updateAllByIdData(); 328 | public void updateAllById(Handler> handler) { 329 | System.out.println("================================================="); 330 | sql.updateAllById(updateAllByIdData()).onSuccess(res -> { 331 | LOG.info("updateAllById 执行结果:" + res); 332 | if (res == 1) { 333 | getByIdAndEquals(1, "update", null, test -> { 334 | if (Objects.equals(true, test.result())) { 335 | LOG.info("updateAllById 测试通过!"); 336 | updateAllByAssist(handler); 337 | } else { 338 | LOG.info("updateAllById 结果不匹配!"); 339 | failed("updateAllById 结果不匹配!" + test.cause().getMessage(), handler); 340 | } 341 | }); 342 | } else { 343 | LOG.info("updateAllById 结果不匹配!"); 344 | String format = String.format("updateAllById 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 345 | failed(format, handler); 346 | } 347 | }).onFailure(err -> failed(err, handler)); 348 | } 349 | 350 | /** 测试根据assist修改所有,要求:id=1,cid=1,nickname=null,pwd=updatebyAssist */ 351 | public abstract E updateAllByAssistData(); 352 | public void updateAllByAssist(Handler> handler) { 353 | System.out.println("================================================="); 354 | sql.updateAllByAssist(updateAllByAssistData(), new SqlAssist().andEq(COLUMN_ID, 1)).onSuccess(res -> { 355 | LOG.info("updateAllByAssist 执行结果:" + res); 356 | if (res == 1) { 357 | getByIdAndEquals(1, null, "updatebyAssist", test -> { 358 | if (Objects.equals(true, test.result())) { 359 | LOG.info("updateAllByAssist 测试通过!"); 360 | updateNonEmptyById(handler); 361 | } else { 362 | LOG.info("updateAllByAssist 结果不匹配!"); 363 | failed("updateAllByAssist 结果不匹配!" + test.cause().getMessage(), handler); 364 | } 365 | }); 366 | } else { 367 | LOG.info("updateAllByAssist 结果不匹配!"); 368 | String format = String.format("updateAllByAssist 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 369 | failed(format, handler); 370 | } 371 | }).onFailure(err -> failed(err, handler)); 372 | } 373 | 374 | /** 测试根据id修改不为空,要求:id=1,cid=1,nickname=nickname,pwd=null */ 375 | public abstract E updateNonEmptyByIdData(); 376 | public void updateNonEmptyById(Handler> handler) { 377 | System.out.println("================================================="); 378 | sql.updateNonEmptyById(updateNonEmptyByIdData()).onSuccess(res -> { 379 | LOG.info("updateNonEmptyById 执行结果:" + res); 380 | if (res == 1) { 381 | getByIdAndEquals(1, "nickname", "updatebyAssist", test -> { 382 | if (Objects.equals(true, test.result())) { 383 | LOG.info("updateNonEmptyById 测试通过!"); 384 | updateNonEmptyByAssist(handler); 385 | } else { 386 | LOG.info("updateNonEmptyById 结果不匹配!"); 387 | failed("updateNonEmptyById 结果不匹配!" + test.cause().getMessage(), handler); 388 | } 389 | }); 390 | } else { 391 | LOG.info("updateNonEmptyById 结果不匹配!"); 392 | String format = String.format("updateNonEmptyById 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 393 | failed(format, handler); 394 | } 395 | }).onFailure(err -> failed(err, handler)); 396 | } 397 | 398 | /** 测试根据assist修改不为空,要求:pwd=updateNonEmptyByAssist */ 399 | public abstract E updateNonEmptyByAssistData(); 400 | public void updateNonEmptyByAssist(Handler> handler) { 401 | System.out.println("================================================="); 402 | sql.updateNonEmptyByAssist(updateNonEmptyByAssistData(), new SqlAssist().andEq(COLUMN_ID, 1)).onSuccess(res -> { 403 | LOG.info("updateNonEmptyByAssist 执行结果:" + res); 404 | if (res == 1) { 405 | getByIdAndEquals(1, "nickname", "updateNonEmptyByAssist", test -> { 406 | if (Objects.equals(true, test.result())) { 407 | LOG.info("updateNonEmptyByAssist 测试通过!"); 408 | updateSetNullById(handler); 409 | } else { 410 | LOG.info("updateNonEmptyByAssist 结果不匹配!"); 411 | failed("updateNonEmptyByAssist 结果不匹配!" + test.cause().getMessage(), handler); 412 | } 413 | }); 414 | } else { 415 | LOG.info("updateNonEmptyByAssist 结果不匹配!"); 416 | String format = String.format("updateNonEmptyByAssist 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 417 | failed(format, handler); 418 | } 419 | }).onFailure(err -> failed(err, handler)); 420 | } 421 | 422 | public void updateSetNullById(Handler> handler) { 423 | System.out.println("================================================="); 424 | sql.updateSetNullById(1, Arrays.asList(COLUMN_NICKNAME)).onSuccess(res -> { 425 | LOG.info("updateSetNullById 执行结果:" + res); 426 | if (res == 1) { 427 | getByIdAndEquals(1, null, "updateNonEmptyByAssist", test -> { 428 | if (Objects.equals(true, test.result())) { 429 | LOG.info("updateSetNullById 测试通过!"); 430 | updateSetNullByAssist(handler); 431 | } else { 432 | LOG.info("updateSetNullById 结果不匹配!"); 433 | failed("updateSetNullById 结果不匹配!" + test.cause().getMessage(), handler); 434 | } 435 | }); 436 | } else { 437 | LOG.info("updateSetNullById 结果不匹配!"); 438 | String format = String.format("updateSetNullById 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 439 | failed(format, handler); 440 | } 441 | }).onFailure(err -> failed(err, handler)); 442 | } 443 | 444 | public void updateSetNullByAssist(Handler> handler) { 445 | System.out.println("================================================="); 446 | sql.updateSetNullByAssist(new SqlAssist().andEq(COLUMN_ID, 1), Arrays.asList(COLUMN_PWD)).onSuccess(res -> { 447 | LOG.info("updateSetNullByAssist 执行结果:" + res); 448 | if (res == 1) { 449 | getByIdAndEquals(1, null, null, test -> { 450 | if (Objects.equals(true, test.result())) { 451 | LOG.info("updateSetNullByAssist 测试通过!"); 452 | selectAll(handler); 453 | } else { 454 | LOG.info("updateSetNullByAssist 结果不匹配!"); 455 | failed("updateSetNullByAssist 结果不匹配!" + test.cause().getMessage(), handler); 456 | } 457 | }); 458 | } else { 459 | LOG.info("updateSetNullByAssist 结果不匹配!"); 460 | String format = String.format("updateSetNullByAssist 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 461 | failed(format, handler); 462 | } 463 | }).onFailure(err -> failed(err, handler)); 464 | } 465 | 466 | public void selectAll(Handler> handler) { 467 | System.out.println("================================================="); 468 | sql.selectAll(new SqlAssist().andEq(COLUMN_PWD, "batch")).onSuccess(res -> { 469 | LOG.info("selectAll 执行结果:" + res); 470 | if (res.size() == 2) { 471 | LOG.info("selectAll 测试通过!"); 472 | limitAll(handler); 473 | } else { 474 | LOG.info("selectAll 结果不匹配!"); 475 | String format = String.format("selectAll 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 2, res); 476 | failed(format, handler); 477 | } 478 | }).onFailure(err -> failed(err, handler)); 479 | } 480 | 481 | public void limitAll(Handler> handler) { 482 | System.out.println("================================================="); 483 | sql.limitAll(new SqlAssist().andEq(COLUMN_PWD, "batch")).onSuccess(res -> { 484 | LOG.info("limitAll 执行结果:" + res); 485 | Object value = res.getValue(SqlLimitResult.DATA); 486 | if (value != null) { 487 | LOG.info("limitAll 测试通过!"); 488 | limitAllNewName(handler); 489 | } else { 490 | LOG.info("limitAll 结果不匹配!"); 491 | failed("limitAll 结果不匹配!\n期望结果:[non null]\n实际结果:[null]", handler); 492 | } 493 | }).onFailure(err -> failed(err, handler)); 494 | } 495 | 496 | public void limitAllNewName(Handler> handler) { 497 | System.out.println("================================================="); 498 | SqlLimitResult.registerResultKey(SqlLimitResult.DATA, "result"); 499 | sql.limitAll(new SqlAssist().andEq(COLUMN_PWD, "batch")).onSuccess(res -> { 500 | LOG.info("limitAllNewName 执行结果:" + res); 501 | Object value = res.getValue("result"); 502 | if (value != null) { 503 | LOG.info("limitAllNewName 测试通过!"); 504 | selectById(handler); 505 | } else { 506 | LOG.info("limitAllNewName 结果不匹配!"); 507 | failed("limitAllNewName 结果不匹配!\n期望结果:[non null]\n实际结果:[null]", handler); 508 | } 509 | }).onFailure(err -> failed(err, handler)); 510 | } 511 | 512 | public void selectById(Handler> handler) { 513 | System.out.println("================================================="); 514 | String cols = "t1.id,t2.classanme"; 515 | String join = "inner join classes t2 on t1.cid=t2.id"; 516 | sql.selectById(1, cols, "t1", join).onSuccess(res -> { 517 | LOG.info("selectById 执行结果:" + res); 518 | if (res.getString("classanme") != null) { 519 | LOG.info("selectById 测试通过!"); 520 | selectSingleByObj(handler); 521 | } else { 522 | LOG.info("selectById 结果不匹配!"); 523 | failed("selectById 结果不匹配!\n期望结果:[non null]\n实际结果:[null]", handler); 524 | } 525 | }).onFailure(err -> failed(err, handler)); 526 | } 527 | /** 通过obj查询的数据,要求:cid=1 */ 528 | public abstract E selectByObjData(); 529 | public void selectSingleByObj(Handler> handler) { 530 | System.out.println("================================================="); 531 | String cols = "t1.id,t2.classanme"; 532 | String join = "inner join classes t2 on t1.cid=t2.id"; 533 | sql.selectSingleByObj(selectByObjData(), cols, "t1", join).onSuccess(res -> { 534 | LOG.info("selectSingleByObj 执行结果:" + res); 535 | if (res.getString("classanme") != null) { 536 | LOG.info("selectSingleByObj 测试通过!"); 537 | selectByObj(handler); 538 | } else { 539 | LOG.info("selectSingleByObj 结果不匹配!"); 540 | failed("selectSingleByObj 结果不匹配!\n期望结果:[non null]\n实际结果:[null]", handler); 541 | } 542 | }).onFailure(err -> failed(err, handler)); 543 | } 544 | 545 | public void selectByObj(Handler> handler) { 546 | System.out.println("================================================="); 547 | String cols = "t1.id,t2.classanme"; 548 | String join = "inner join classes t2 on t1.cid=t2.id"; 549 | sql.selectByObj(selectByObjData(), cols, "t1", join).onSuccess(res -> { 550 | LOG.info("selectByObj 执行结果:" + res); 551 | if (res.size() > 1) { 552 | LOG.info("selectByObj 测试通过!"); 553 | deleteById(handler); 554 | } else { 555 | LOG.info("selectByObj 结果不匹配!"); 556 | String format = String.format("selectByObj 结果不匹配!\n期望结果:[>%d]\n实际结果:[%d]", 1, res.size()); 557 | failed(format, handler); 558 | } 559 | }).onFailure(err -> failed(err, handler)); 560 | } 561 | 562 | public void deleteById(Handler> handler) { 563 | sql.deleteById(1).onSuccess(res -> { 564 | LOG.info("deleteById 执行结果:" + res); 565 | if (res == 1) { 566 | LOG.info("deleteById 测试通过!"); 567 | deleteByAssist(handler); 568 | } else { 569 | LOG.info("deleteById 结果不匹配!"); 570 | String format = String.format("deleteById 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 1, res); 571 | failed(format, handler); 572 | } 573 | }).onFailure(err -> failed(err, handler)); 574 | } 575 | 576 | public void deleteByAssist(Handler> handler) { 577 | sql.deleteByAssist(new SqlAssist().andEq(COLUMN_PWD, "batch")).onSuccess(res -> { 578 | LOG.info("deleteByAssist 执行结果:" + res); 579 | if (res == 2) { 580 | LOG.info("deleteByAssist 测试通过!"); 581 | succeeded(handler); 582 | } else { 583 | LOG.info("deleteByAssist 结果不匹配!"); 584 | String format = String.format("deleteByAssist 结果不匹配!\n期望结果:[%d]\n实际结果:[%d]", 2, res); 585 | failed(format, handler); 586 | } 587 | }).onFailure(err -> failed(err, handler)); 588 | } 589 | 590 | /** 591 | * 获取id并测试的数据是否匹配 592 | * 593 | * @param id 594 | * 查询的id 595 | * @param nickname 596 | * 期望的名称结果 597 | * @param password 598 | * 期望的密码结果 599 | * @param handler 600 | */ 601 | public void getByIdAndEquals(Integer id, String nickname, String password, Handler> handler) { 602 | sql.selectById(id, COLUMN_NICKNAME + "," + COLUMN_PWD + " AS " + KEY_PWD).onSuccess(res -> { 603 | LOG.info("getByIdAndEquals 执行结果:" + res + ",期望结果nickname=" + nickname + ",password=" + password); 604 | if (Objects.equals(nickname, res.getString(COLUMN_NICKNAME)) && Objects.equals(password, res.getString(KEY_PWD))) { 605 | LOG.info("getByIdAndEquals 测试通过!"); 606 | handler.handle(Future.succeededFuture(true)); 607 | } else { 608 | String format = String.format("\n期望结果:[nickname=%s,password=%s]\n实际结果:[nickname=%s,password=%s]", nickname, password, 609 | res.getString(COLUMN_NICKNAME), res.getString(KEY_PWD)); 610 | handler.handle(Future.failedFuture(format)); 611 | } 612 | }).onFailure(err -> handler.handle(Future.failedFuture(err))); 613 | } 614 | /** 615 | * 获取数据行数并测试行数 616 | * 617 | * @param assist 618 | * @param value 619 | * 期望的值 620 | * @param handler 621 | */ 622 | public void getCountAndEquals(SqlAssist assist, long value, Handler> handler) { 623 | sql.getCount(assist).onSuccess(res -> { 624 | LOG.info("getCountAndEquals 执行结果:" + res + ",期望结果=" + value); 625 | if (Objects.equals(value, res)) { 626 | LOG.info("getCountAndEquals 测试通过!"); 627 | handler.handle(Future.succeededFuture(true)); 628 | } else { 629 | String format = String.format("\n期望结果:[%d]\n实际结果:[%d]", value, res); 630 | handler.handle(Future.failedFuture(format)); 631 | } 632 | }).onFailure(err -> handler.handle(Future.failedFuture(err))); 633 | } 634 | 635 | } 636 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/entity/Classes.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.entity; 2 | 3 | import io.vertx.ext.sql.assist.Table; 4 | import io.vertx.ext.sql.assist.TableColumn; 5 | import io.vertx.ext.sql.assist.TableId; 6 | 7 | @Table("classes") 8 | public class Classes { 9 | /** 班级的id */ 10 | @TableId("id") 11 | private Integer id; 12 | /** 班级的名称 */ 13 | @TableColumn("classanme") 14 | private String classanme; 15 | 16 | public Integer getId() { 17 | return id; 18 | } 19 | public void setId(Integer id) { 20 | this.id = id; 21 | } 22 | public String getClassanme() { 23 | return classanme; 24 | } 25 | public void setClassanme(String classanme) { 26 | this.classanme = classanme; 27 | } 28 | @Override 29 | public String toString() { 30 | return "Classes [id=" + id + ", classanme=" + classanme + "]"; 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/entity/Student.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.entity; 2 | 3 | import io.vertx.ext.sql.assist.Table; 4 | import io.vertx.ext.sql.assist.TableColumn; 5 | import io.vertx.ext.sql.assist.TableId; 6 | 7 | @Table("student") 8 | public class Student { 9 | /** 用户的id */ 10 | @TableId("id") 11 | private Integer id; 12 | /** 自增长的数组 */ 13 | @TableColumn("cid") 14 | private Integer cid; 15 | /** 用户的名字 */ 16 | @TableColumn("nickname") 17 | private String nickname; 18 | /** 用户的的密码 */ 19 | @TableColumn(value = "pwd", alias = "possword") 20 | private String pwd; 21 | 22 | public Integer getId() { 23 | return id; 24 | } 25 | 26 | public Student setId(Integer id) { 27 | this.id = id; 28 | return this; 29 | } 30 | 31 | public Integer getCid() { 32 | return cid; 33 | } 34 | 35 | public Student setCid(Integer cid) { 36 | this.cid = cid; 37 | return this; 38 | } 39 | 40 | public String getNickname() { 41 | return nickname; 42 | } 43 | 44 | public Student setNickname(String nickname) { 45 | this.nickname = nickname; 46 | return this; 47 | } 48 | 49 | public String getPwd() { 50 | return pwd; 51 | } 52 | 53 | public Student setPwd(String pwd) { 54 | this.pwd = pwd; 55 | return this; 56 | } 57 | 58 | @Override 59 | public String toString() { 60 | return "Student [id=" + id + ", cid=" + cid + ", nickname=" + nickname + ", pwd=" + pwd + "]"; 61 | } 62 | 63 | } 64 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/sql/ClassesSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import io.vertx.ext.sql.assist.CommonSQL; 4 | import io.vertx.ext.sql.assist.SQLExecute; 5 | import io.vertx.ext.sql.assist.entity.Classes; 6 | import io.vertx.jdbcclient.JDBCPool; 7 | 8 | /** 9 | * 使用JDBCPool的班级SQL操作,这也是使用带注解实体类的SQL示例 10 | * 11 | * @author Mirren 12 | * 13 | */ 14 | public class ClassesSQL extends CommonSQL { 15 | public ClassesSQL(SQLExecute execute) { 16 | super(execute); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/sql/JsonObjectSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import io.vertx.core.json.JsonObject; 7 | import io.vertx.ext.sql.assist.CommonSQL; 8 | import io.vertx.ext.sql.assist.SQLExecute; 9 | import io.vertx.ext.sql.assist.SQLStatement; 10 | import io.vertx.ext.sql.assist.SqlPropertyValue; 11 | import io.vertx.mysqlclient.MySQLPool; 12 | 13 | public class JsonObjectSQL extends CommonSQL { 14 | public JsonObjectSQL(SQLExecute execute) { 15 | super(execute, statement()); 16 | } 17 | 18 | public static SQLStatement statement() { 19 | AbstractStatementSQL statement = new AbstractStatementSQL(JsonObject.class) { 20 | @Override 21 | public String tableName() { 22 | return "student"; 23 | } 24 | 25 | @Override 26 | public String primaryId() { 27 | return "id"; 28 | } 29 | 30 | @Override 31 | public String resultColumns() { 32 | return "id,cid,nickname,pwd AS possword"; 33 | } 34 | 35 | @Override 36 | public List> getPropertyValue(T obj) throws Exception { 37 | JsonObject data = (JsonObject) obj; 38 | List> result = new ArrayList<>(4); 39 | result.add(new SqlPropertyValue<>("pwd", data.getString("pwd"))); 40 | result.add(new SqlPropertyValue<>("nickname", data.getString("nickname"))); 41 | result.add(new SqlPropertyValue<>("cid", data.getInteger("cid"))); 42 | result.add(new SqlPropertyValue<>("id", data.getInteger("id"))); 43 | return result; 44 | } 45 | 46 | }; 47 | return statement; 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/test/java/io/vertx/ext/sql/assist/sql/StudentSQL.java: -------------------------------------------------------------------------------- 1 | package io.vertx.ext.sql.assist.sql; 2 | 3 | import io.vertx.ext.sql.assist.CommonSQL; 4 | import io.vertx.ext.sql.assist.SQLExecute; 5 | import io.vertx.ext.sql.assist.entity.Student; 6 | import io.vertx.jdbcclient.JDBCPool; 7 | /** 8 | * 使用JDBCPool的学生SQL操作,这也是使用带注解实体类的SQL示例 9 | * 10 | * @author Mirren 11 | * 12 | */ 13 | public class StudentSQL extends CommonSQL { 14 | public StudentSQL(SQLExecute execute) { 15 | super(execute); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/resources/vertx-default-jul-logging.properties: -------------------------------------------------------------------------------- 1 | handlers=java.util.logging.ConsoleHandler 2 | #java.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n 3 | #java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter 4 | java.util.logging.ConsoleHandler.level=FINE 5 | 6 | .level=FINE 7 | com.mchange.v2.c3p0.impl.NewProxyPreparedStatement.level=INFO --------------------------------------------------------------------------------