ZhouXY108
/
plusone-commons
forked from plusone/plusone-commons
1
0
Fork 0
Code Pull Requests Activity

删除 SQL 构造器。暂不考虑相关工具。

pull/2/head
ZhouXY108 2024-12-28 22:27:00 +08:00
parent 9ccaa2d1d6
commit 40302d83cf
6 changed files with 4 additions and 979 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ProgressOfTesting.txt
View File

@ -1,7 +1,7 @@
[ ] 未开始测试 - 7 (10.45%)
[-] 测试未完成 - 7 (10.45%)
[Y] 测试完成 - 31 (46.27%)
[x] 无需测试 - 22 (32.84%)
[ ] 未开始测试 - 5 (7.94%)
[-] 测试未完成 - 5 (7.94%)
[Y] 测试完成 - 31 (49.21%)
[x] 无需测试 - 22 (34.92%)
xyz.zhouxy.plusone.commons
├───annotation
@ -69,12 +69,6 @@ xyz.zhouxy.plusone.commons
│ PageResult.java [-]
│ PagingAndSortingQueryParams.java [-]
│ PagingParams.java [-]
│ UnifiedResponse.java [-]
│
├───sql
│ JdbcSql.java [ ]
│ MyBatisSql.java [-]
│ SQL.java [ ]
│
├───time
│ Quarter.java [Y]

740
src/main/java/org/apache/ibatis/jdbc/AbstractSQL.java
View File

@ -1,740 +0,0 @@
/*
* Copyright 2009-2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.jdbc;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* @author Clinton Begin
* @author Jeff Butler
* @author Adam Gent
* @author Kazuki Shimizu
*/
public abstract class AbstractSQL<T> {
private static final String AND = ") \nAND (";
private static final String OR = ") \nOR (";
private final SQLStatement sql = new SQLStatement();
public abstract T getSelf();
public T UPDATE(String table) {
sql().statementType = SQLStatement.StatementType.UPDATE;
sql().tables.add(table);
return getSelf();
}
public T SET(String sets) {
sql().sets.add(sets);
return getSelf();
}
/**
* Sets the.
*
* @param sets
* the sets
*
* @return the t
*
* @since 3.4.2
*/
public T SET(String... sets) {
sql().sets.addAll(Arrays.asList(sets));
return getSelf();
}
public T INSERT_INTO(String tableName) {
sql().statementType = SQLStatement.StatementType.INSERT;
sql().tables.add(tableName);
return getSelf();
}
public T VALUES(String columns, String values) {
INTO_COLUMNS(columns);
INTO_VALUES(values);
return getSelf();
}
/**
* Into columns.
*
* @param columns
* the columns
*
* @return the t
*
* @since 3.4.2
*/
public T INTO_COLUMNS(String... columns) {
sql().columns.addAll(Arrays.asList(columns));
return getSelf();
}
/**
* Into values.
*
* @param values
* the values
*
* @return the t
*
* @since 3.4.2
*/
public T INTO_VALUES(String... values) {
List<String> list = sql().valuesList.get(sql().valuesList.size() - 1);
Collections.addAll(list, values);
return getSelf();
}
public T SELECT(String columns) {
sql().statementType = SQLStatement.StatementType.SELECT;
sql().select.add(columns);
return getSelf();
}
/**
* Select.
*
* @param columns
* the columns
*
* @return the t
*
* @since 3.4.2
*/
public T SELECT(String... columns) {
sql().statementType = SQLStatement.StatementType.SELECT;
sql().select.addAll(Arrays.asList(columns));
return getSelf();
}
public T SELECT_DISTINCT(String columns) {
sql().distinct = true;
SELECT(columns);
return getSelf();
}
/**
* Select distinct.
*
* @param columns
* the columns
*
* @return the t
*
* @since 3.4.2
*/
public T SELECT_DISTINCT(String... columns) {
sql().distinct = true;
SELECT(columns);
return getSelf();
}
public T DELETE_FROM(String table) {
sql().statementType = SQLStatement.StatementType.DELETE;
sql().tables.add(table);
return getSelf();
}
public T FROM(String table) {
sql().tables.add(table);
return getSelf();
}
/**
* From.
*
* @param tables
* the tables
*
* @return the t
*
* @since 3.4.2
*/
public T FROM(String... tables) {
sql().tables.addAll(Arrays.asList(tables));
return getSelf();
}
public T JOIN(String join) {
sql().join.add(join);
return getSelf();
}
/**
* Join.
*
* @param joins
* the joins
*
* @return the t
*
* @since 3.4.2
*/
public T JOIN(String... joins) {
sql().join.addAll(Arrays.asList(joins));
return getSelf();
}
public T INNER_JOIN(String join) {
sql().innerJoin.add(join);
return getSelf();
}
/**
* Inner join.
*
* @param joins
* the joins
*
* @return the t
*
* @since 3.4.2
*/
public T INNER_JOIN(String... joins) {
sql().innerJoin.addAll(Arrays.asList(joins));
return getSelf();
}
public T LEFT_OUTER_JOIN(String join) {
sql().leftOuterJoin.add(join);
return getSelf();
}
/**
* Left outer join.
*
* @param joins
* the joins
*
* @return the t
*
* @since 3.4.2
*/
public T LEFT_OUTER_JOIN(String... joins) {
sql().leftOuterJoin.addAll(Arrays.asList(joins));
return getSelf();
}
public T RIGHT_OUTER_JOIN(String join) {
sql().rightOuterJoin.add(join);
return getSelf();
}
/**
* Right outer join.
*
* @param joins
* the joins
*
* @return the t
*
* @since 3.4.2
*/
public T RIGHT_OUTER_JOIN(String... joins) {
sql().rightOuterJoin.addAll(Arrays.asList(joins));
return getSelf();
}
public T OUTER_JOIN(String join) {
sql().outerJoin.add(join);
return getSelf();
}
/**
* Outer join.
*
* @param joins
* the joins
*
* @return the t
*
* @since 3.4.2
*/
public T OUTER_JOIN(String... joins) {
sql().outerJoin.addAll(Arrays.asList(joins));
return getSelf();
}
public T WHERE(String conditions) {
sql().where.add(conditions);
sql().lastList = sql().where;
return getSelf();
}
/**
* Where.
*
* @param conditions
* the conditions
*
* @return the t
*
* @since 3.4.2
*/
public T WHERE(String... conditions) {
sql().where.addAll(Arrays.asList(conditions));
sql().lastList = sql().where;
return getSelf();
}
public T OR() {
sql().lastList.add(OR);
return getSelf();
}
public T AND() {
sql().lastList.add(AND);
return getSelf();
}
public T GROUP_BY(String columns) {
sql().groupBy.add(columns);
return getSelf();
}
/**
* Group by.
*
* @param columns
* the columns
*
* @return the t
*
* @since 3.4.2
*/
public T GROUP_BY(String... columns) {
sql().groupBy.addAll(Arrays.asList(columns));
return getSelf();
}
public T HAVING(String conditions) {
sql().having.add(conditions);
sql().lastList = sql().having;
return getSelf();
}
/**
* Having.
*
* @param conditions
* the conditions
*
* @return the t
*
* @since 3.4.2
*/
public T HAVING(String... conditions) {
sql().having.addAll(Arrays.asList(conditions));
sql().lastList = sql().having;
return getSelf();
}
public T ORDER_BY(String columns) {
sql().orderBy.add(columns);
return getSelf();
}
/**
* Order by.
*
* @param columns
* the columns
*
* @return the t
*
* @since 3.4.2
*/
public T ORDER_BY(String... columns) {
sql().orderBy.addAll(Arrays.asList(columns));
return getSelf();
}
/**
* Set the limit variable string(e.g. {@code "#{limit}"}).
*
* @param variable
* a limit variable string
*
* @return a self instance
*
* @see #OFFSET(String)
*
* @since 3.5.2
*/
public T LIMIT(String variable) {
sql().limit = variable;
sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.OFFSET_LIMIT;
return getSelf();
}
/**
* Set the limit value.
*
* @param value
* an offset value
*
* @return a self instance
*
* @see #OFFSET(long)
*
* @since 3.5.2
*/
public T LIMIT(int value) {
return LIMIT(String.valueOf(value));
}
/**
* Set the offset variable string(e.g. {@code "#{offset}"}).
*
* @param variable
* a offset variable string
*
* @return a self instance
*
* @see #LIMIT(String)
*
* @since 3.5.2
*/
public T OFFSET(String variable) {
sql().offset = variable;
sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.OFFSET_LIMIT;
return getSelf();
}
/**
* Set the offset value.
*
* @param value
* an offset value
*
* @return a self instance
*
* @see #LIMIT(int)
*
* @since 3.5.2
*/
public T OFFSET(long value) {
return OFFSET(String.valueOf(value));
}
/**
* Set the fetch first rows variable string(e.g. {@code "#{fetchFirstRows}"}).
*
* @param variable
* a fetch first rows variable string
*
* @return a self instance
*
* @see #OFFSET_ROWS(String)
*
* @since 3.5.2
*/
public T FETCH_FIRST_ROWS_ONLY(String variable) {
sql().limit = variable;
sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.ISO;
return getSelf();
}
/**
* Set the fetch first rows value.
*
* @param value
* a fetch first rows value
*
* @return a self instance
*
* @see #OFFSET_ROWS(long)
*
* @since 3.5.2
*/
public T FETCH_FIRST_ROWS_ONLY(int value) {
return FETCH_FIRST_ROWS_ONLY(String.valueOf(value));
}
/**
* Set the offset rows variable string(e.g. {@code "#{offset}"}).
*
* @param variable
* a offset rows variable string
*
* @return a self instance
*
* @see #FETCH_FIRST_ROWS_ONLY(String)
*
* @since 3.5.2
*/
public T OFFSET_ROWS(String variable) {
sql().offset = variable;
sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.ISO;
return getSelf();
}
/**
* Set the offset rows value.
*
* @param value
* an offset rows value
*
* @return a self instance
*
* @see #FETCH_FIRST_ROWS_ONLY(int)
*
* @since 3.5.2
*/
public T OFFSET_ROWS(long value) {
return OFFSET_ROWS(String.valueOf(value));
}
/**
* used to add a new inserted row while do multi-row insert.
*
* @return the t
*
* @since 3.5.2
*/
public T ADD_ROW() {
sql().valuesList.add(new ArrayList<>());
return getSelf();
}
private SQLStatement sql() {
return sql;
}
public <A extends Appendable> A usingAppender(A a) {
sql().sql(a);
return a;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sql().sql(sb);
return sb.toString();
}
private static class SafeAppendable {
private final Appendable appendable;
private boolean empty = true;
public SafeAppendable(Appendable a) {
this.appendable = a;
}
public SafeAppendable append(CharSequence s) {
try {
if (empty && s.length() > 0) {
empty = false;
}
appendable.append(s);
} catch (IOException e) {
throw new RuntimeException(e);
}
return this;
}
public boolean isEmpty() {
return empty;
}
}
private static class SQLStatement {
public enum StatementType {
DELETE,
INSERT,
SELECT,
UPDATE
}
private enum LimitingRowsStrategy {
NOP {
@Override
protected void appendClause(SafeAppendable builder, String offset, String limit) {
// NOP
}
},
ISO {
@Override
protected void appendClause(SafeAppendable builder, String offset, String limit) {
if (offset != null) {
builder.append(" OFFSET ").append(offset).append(" ROWS");
}
if (limit != null) {
builder.append(" FETCH FIRST ").append(limit).append(" ROWS ONLY");
}
}
},
OFFSET_LIMIT {
@Override
protected void appendClause(SafeAppendable builder, String offset, String limit) {
if (limit != null) {
builder.append(" LIMIT ").append(limit);
}
if (offset != null) {
builder.append(" OFFSET ").append(offset);
}
}
};
protected abstract void appendClause(SafeAppendable builder, String offset, String limit);
}
StatementType statementType;
List<String> sets = new ArrayList<>();
List<String> select = new ArrayList<>();
List<String> tables = new ArrayList<>();
List<String> join = new ArrayList<>();
List<String> innerJoin = new ArrayList<>();
List<String> outerJoin = new ArrayList<>();
List<String> leftOuterJoin = new ArrayList<>();
List<String> rightOuterJoin = new ArrayList<>();
List<String> where = new ArrayList<>();
List<String> having = new ArrayList<>();
List<String> groupBy = new ArrayList<>();
List<String> orderBy = new ArrayList<>();
List<String> lastList = new ArrayList<>();
List<String> columns = new ArrayList<>();
List<List<String>> valuesList = new ArrayList<>();
boolean distinct;
String offset;
String limit;
LimitingRowsStrategy limitingRowsStrategy = LimitingRowsStrategy.NOP;
public SQLStatement() {
// Prevent Synthetic Access
valuesList.add(new ArrayList<>());
}
private void sqlClause(SafeAppendable builder, String keyword, List<String> parts, String open, String close,
String conjunction) {
if (!parts.isEmpty()) {
if (!builder.isEmpty()) {
builder.append("\n");
}
builder.append(keyword);
builder.append(" ");
builder.append(open);
String last = "________";
for (int i = 0, n = parts.size(); i < n; i++) {
String part = parts.get(i);
if (i > 0 && !part.equals(AND) && !part.equals(OR) && !last.equals(AND) && !last.equals(OR)) {
builder.append(conjunction);
}
builder.append(part);
last = part;
}
builder.append(close);
}
}
private String selectSQL(SafeAppendable builder) {
if (distinct) {
sqlClause(builder, "SELECT DISTINCT", select, "", "", ", ");
} else {
sqlClause(builder, "SELECT", select, "", "", ", ");
}
sqlClause(builder, "FROM", tables, "", "", ", ");
joins(builder);
sqlClause(builder, "WHERE", where, "(", ")", " AND ");
sqlClause(builder, "GROUP BY", groupBy, "", "", ", ");
sqlClause(builder, "HAVING", having, "(", ")", " AND ");
sqlClause(builder, "ORDER BY", orderBy, "", "", ", ");
limitingRowsStrategy.appendClause(builder, offset, limit);
return builder.toString();
}
private void joins(SafeAppendable builder) {
sqlClause(builder, "JOIN", join, "", "", "\nJOIN ");
sqlClause(builder, "INNER JOIN", innerJoin, "", "", "\nINNER JOIN ");
sqlClause(builder, "OUTER JOIN", outerJoin, "", "", "\nOUTER JOIN ");
sqlClause(builder, "LEFT OUTER JOIN", leftOuterJoin, "", "", "\nLEFT OUTER JOIN ");
sqlClause(builder, "RIGHT OUTER JOIN", rightOuterJoin, "", "", "\nRIGHT OUTER JOIN ");
}
private String insertSQL(SafeAppendable builder) {
sqlClause(builder, "INSERT INTO", tables, "", "", "");
sqlClause(builder, "", columns, "(", ")", ", ");
for (int i = 0; i < valuesList.size(); i++) {
sqlClause(builder, i > 0 ? "," : "VALUES", valuesList.get(i), "(", ")", ", ");
}
return builder.toString();
}
private String deleteSQL(SafeAppendable builder) {
sqlClause(builder, "DELETE FROM", tables, "", "", "");
sqlClause(builder, "WHERE", where, "(", ")", " AND ");
limitingRowsStrategy.appendClause(builder, null, limit);
return builder.toString();
}
private String updateSQL(SafeAppendable builder) {
sqlClause(builder, "UPDATE", tables, "", "", "");
joins(builder);
sqlClause(builder, "SET", sets, "", "", ", ");
sqlClause(builder, "WHERE", where, "(", ")", " AND ");
limitingRowsStrategy.appendClause(builder, null, limit);
return builder.toString();
}
public String sql(Appendable a) {
SafeAppendable builder = new SafeAppendable(a);
if (statementType == null) {
return null;
}
String answer;
switch (statementType) {
case DELETE:
answer = deleteSQL(builder);
break;
case INSERT:
answer = insertSQL(builder);
break;
case SELECT:
answer = selectSQL(builder);
break;
case UPDATE:
answer = updateSQL(builder);
break;
default:
answer = null;
}
return answer;
}
}
}

72
src/main/java/xyz/zhouxy/plusone/commons/sql/JdbcSql.java
View File

@ -1,72 +0,0 @@
/*
* Copyright 2023-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.sql;
import java.util.Collection;
import xyz.zhouxy.plusone.commons.util.StringTools;
public class JdbcSql extends SQL<JdbcSql> {
JdbcSql() {
super();
}
public static JdbcSql newSql() {
return new JdbcSql();
}
@Override
public JdbcSql getSelf() {
return this;
}
public static String IN(String col, Collection<?> c) { // NOSONAR
return IN(col, c.size());
}
public static <T> String IN(String col, T[] c) { // NOSONAR
return IN(col, c.length);
}
private static String IN(String col, int length) { // NOSONAR
if (length == 0) {
return "false";
}
return col + " IN (" + buildQuestionsList(length) + ')';
}
public static String NOT_IN(String col, Collection<?> c) { // NOSONAR
return NOT_IN(col, c.size());
}
public static <T> String NOT_IN(String col, T[] c) { // NOSONAR
return NOT_IN(col, c.length);
}
private static String NOT_IN(String col, int length) { // NOSONAR
if (length == 0) {
return "true";
}
return col + " NOT IN (" + buildQuestionsList(length) + ')';
}
private static String buildQuestionsList(int times) {
final int length = times <= 0 ? 0 : (times * 3 - 2);
return StringTools.repeat("?, ", times, length);
}
}

73
src/main/java/xyz/zhouxy/plusone/commons/sql/MyBatisSql.java
View File

@ -1,73 +0,0 @@
/*
* Copyright 2023-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.sql;
import com.google.common.annotations.Beta;
@Beta
public class MyBatisSql extends SQL<MyBatisSql> {
private final boolean withScript;
MyBatisSql(boolean withScript) {
super();
this.withScript = withScript;
}
public static MyBatisSql newSql() {
return new MyBatisSql(false);
}
public static MyBatisSql newScriptSql() {
return new MyBatisSql(true);
}
@Override
public MyBatisSql getSelf() {
return this;
}
public static String IN(String col, String paramName) { // NOSONAR
return " " + col + " IN" + buildForeach(col, paramName);
}
public static String NOT_IN(String col, String paramName) { // NOSONAR
return col + " NOT IN" + buildForeach(col, paramName);
}
private static String buildForeach(String col, String paramName) {
final String format = "<foreach" +
" item=\"%s\"" +
" index=\"index\"" +
" collection=\"%s\"" +
" open=\"(\"" +
" separator=\",\"" +
" close=\")\"" +
">" +
"#{%s}" +
"</foreach>";
return String.format(format, col, paramName, col);
}
@Override
public String toString() {
if (withScript) {
return "<script>\n" + super.toString() + "\n</script>";
}
return super.toString();
}
}

47
src/main/java/xyz/zhouxy/plusone/commons/sql/SQL.java
View File

@ -1,47 +0,0 @@
/*
* Copyright 2023-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.sql;
import org.apache.ibatis.jdbc.AbstractSQL;
import com.google.common.annotations.Beta;
/**
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
@Beta
public abstract class SQL<T> extends AbstractSQL<T> {
public static JdbcSql newJdbcSql() {
return new JdbcSql();
}
public static MyBatisSql newMyBatisSql(boolean withScript) {
return new MyBatisSql(withScript);
}
public T WHERE(boolean condition, String sqlCondition) { // NOSONAR
if (condition) {
return WHERE(sqlCondition);
}
return getSelf();
}
public T WHERE(boolean condition, String ifSqlCondition, String elseSqlCondition) { // NOSONAR
return WHERE(condition ? ifSqlCondition : elseSqlCondition);
}
}

37
src/test/java/xyz/zhouxy/plusone/commons/sql/MyBatisSqlBuilderTests.java
View File

@ -1,37 +0,0 @@
/*
* Copyright 2023-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.sql;
import static xyz.zhouxy.plusone.commons.sql.MyBatisSql.IN;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
class MyBatisSqlBuilderTests {
private static final Logger log = LoggerFactory.getLogger(MyBatisSqlBuilderTests.class);
@Test
void test() {
// List<String> ids = Arrays.asList("2333", "4501477");
MyBatisSql sql = MyBatisSql.newScriptSql()
.SELECT("*")
.FROM("test_table")
.WHERE(IN("id", "ids"));
log.info("sql: {}", sql);
}
}