From 59def55dcbe6db1f55684cd4f901540bcedb8bf3 Mon Sep 17 00:00:00 2001 From: richie Date: Thu, 26 Sep 2019 09:10:37 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A1=A5=E5=85=85javadoc=E5=92=8C=E5=8D=95?= =?UTF-8?q?=E5=85=83=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/fanruan/api/query/RestrictionKit.java | 212 ++++++++++++++++++ .../fanruan/api/query/RestrictionKitTest.java | 41 ++++ 2 files changed, 253 insertions(+) create mode 100644 src/test/java/com/fanruan/api/query/RestrictionKitTest.java diff --git a/src/main/java/com/fanruan/api/query/RestrictionKit.java b/src/main/java/com/fanruan/api/query/RestrictionKit.java index 0f637be..9bac9b7 100644 --- a/src/main/java/com/fanruan/api/query/RestrictionKit.java +++ b/src/main/java/com/fanruan/api/query/RestrictionKit.java @@ -20,126 +20,338 @@ public class RestrictionKit { } + /** + * 指定列中和指定值相等的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction eq(String columnName, Object columnValue) { return RestrictionFactory.eq(columnName, columnValue); } + /** + * 指定列中和指定值相等的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction eq(Column column, Object columnValue) { return RestrictionFactory.eq(column, columnValue); } + /** + * 指定列中大于指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction gt(String columnName, Object columnValue) { return RestrictionFactory.gt(columnName, columnValue); } + /** + * 指定列中大于指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction gt(Column column, Object columnValue) { return RestrictionFactory.gt(column, columnValue); } + /** + * 指定列中大于等于指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction gte(String columnName, Object columnValue) { return RestrictionFactory.gte(columnName, columnValue); } + /** + * 指定列中大于等于指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction gte(Column column, Object columnValue) { return RestrictionFactory.gte(column, columnValue); } + /** + * 指定列中小于指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction lt(String columnName, Object columnValue) { return RestrictionFactory.lt(columnName, columnValue); } + /** + * 指定列中小于指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction lt(Column column, Object columnValue) { return RestrictionFactory.lt(column, columnValue); } + /** + * 指定列中小于等于指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction lte(String columnName, Object columnValue) { return RestrictionFactory.lte(columnName, columnValue); } + /** + * 指定列中小于等于指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction lte(Column column, Object columnValue) { return RestrictionFactory.lte(column, columnValue); } + /** + * 指定列中不等于指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction neq(String columnName, Object columnValue) { return RestrictionFactory.neq(columnName, columnValue); } + /** + * 指定列中不等于指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction neq(Column column, Object columnValue) { return RestrictionFactory.neq(column, columnValue); } + /** + * 指定列中匹配指定值的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction like(String columnName, Object columnValue) { return RestrictionFactory.like(columnName, columnValue); } + /** + * 指定列中匹配指定值的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction like(Column column, Object columnValue) { return RestrictionFactory.like(column, columnValue); } + /** + * 指定列中以指定值开头的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction startWith(String columnName, Object columnValue) { return RestrictionFactory.startWith(columnName, columnValue); } + /** + * 指定列中以指定值开头的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction startWith(Column column, Object columnValue) { return RestrictionFactory.startWith(column, columnValue); } + /** + * 指定列中以指定值结尾的限制条件 + * + * @param columnName 列名 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction endWith(String columnName, Object columnValue) { return RestrictionFactory.endWith(columnName, columnValue); } + /** + * 指定列中以指定值结尾的限制条件 + * + * @param column 列 + * @param columnValue 列值 + * @return 限制条件 + */ public static Restriction endWith(Column column, Object columnValue) { return RestrictionFactory.endWith(column, columnValue); } + /** + * 指定列中包含在指定值中的限制条件 + * + * @param columnName 列名 + * @param columnValues 列值 + * @return 限制条件 + */ public static Restriction in(String columnName, Set columnValues) { return RestrictionFactory.in(columnName, columnValues); } + /** + * 指定列中包含在指定值中的限制条件 + * + * @param column 列 + * @param columnValues 列值 + * @return 限制条件 + */ public static Restriction in(Column column, Set columnValues) { return RestrictionFactory.in(column, columnValues); } + /** + * 指定列中包含在指定值中的限制条件 + * + * @param columnName 列名 + * @param query 子查询 + * @return 限制条件 + */ public static Restriction inQuery(String columnName, SubQuery query) { return RestrictionFactory.inQuery(columnName, query); } + /** + * 指定列中包含在指定值中的限制条件 + * + * @param column 列 + * @param query 子查询 + * @return 限制条件 + */ public static Restriction inQuery(Column column, SubQuery query) { return RestrictionFactory.inQuery(column, query); } + /** + * 指定列中不包含在指定值中的限制条件 + * + * @param columnName 列名 + * @param columnValues 列值 + * @return 限制条件 + */ public static Restriction notIn(String columnName, Set columnValues) { return RestrictionFactory.notIn(columnName, columnValues); } + /** + * 指定列中不包含在指定值中的限制条件 + * + * @param column 列 + * @param columnValues 列值 + * @return 限制条件 + */ public static Restriction notIn(Column column, Set columnValues) { return RestrictionFactory.notIn(column, columnValues); } + /** + * 指定列中不包含在指定值中的限制条件 + * + * @param columnName 列名 + * @param query 子查询 + * @return 限制条件 + */ public static Restriction notInQuery(String columnName, SubQuery query) { return RestrictionFactory.notInQuery(columnName, query); } + /** + * 指定列中不包含在指定值中的限制条件 + * + * @param column 列 + * @param query 子查询 + * @return 限制条件 + */ public static Restriction notInQuery(Column column, SubQuery query) { return RestrictionFactory.notInQuery(column, query); } + /** + * 将多个限制条件以或的方式组合到一起 + * + * @param restrictions 多个限制条件 + * @return 限制条件 + */ public static Restriction or(Restriction... restrictions) { return RestrictionFactory.or(restrictions); } + /** + * 将多个限制条件以或的方式组合到一起 + * + * @param restrictionList 多个限制条件 + * @return 限制条件 + */ public static Restriction or(List restrictionList) { return RestrictionFactory.or(restrictionList); } + /** + * 将多个限制条件以且的方式组合到一起 + * + * @param restrictions 多个限制条件 + * @return 限制条件 + */ public static Restriction and(Restriction... restrictions) { return RestrictionFactory.and(restrictions); } + /** + * 将多个限制条件以且的方式组合到一起 + * + * @param restrictionList 多个限制条件 + * @return 限制条件 + */ public static Restriction and(List restrictionList) { return RestrictionFactory.and(restrictionList); } + /** + * 排除掉指定的限制条件 + * + * @param restriction 条件 + * @return 限制条件 + */ public static Restriction not(Restriction restriction) { return RestrictionFactory.not(restriction); } diff --git a/src/test/java/com/fanruan/api/query/RestrictionKitTest.java b/src/test/java/com/fanruan/api/query/RestrictionKitTest.java new file mode 100644 index 0000000..e68f462 --- /dev/null +++ b/src/test/java/com/fanruan/api/query/RestrictionKitTest.java @@ -0,0 +1,41 @@ +package com.fanruan.api.query; + +import com.fanruan.api.Prepare; +import com.fr.stable.query.restriction.RestrictionType; +import com.fr.stable.query.restriction.impl.LteRestriction; +import org.junit.Test; + +import java.util.HashSet; +import java.util.Set; + +import static org.junit.Assert.assertEquals; + +/** + * @author richie + * @version 10.0 + * Created by richie on 2019/9/26 + */ +public class RestrictionKitTest extends Prepare { + + @Test + public void testRestriction() { + assertEquals(RestrictionKit.eq("a", 1).getType(), RestrictionType.EQ); + assertEquals(RestrictionKit.neq("a", 1).getType(), RestrictionType.NEQ); + assertEquals(RestrictionKit.gt("a", 1).getType(), RestrictionType.GT); + assertEquals(RestrictionKit.gte("a", 1).getType(), RestrictionType.GTE); + assertEquals(RestrictionKit.lt("a", 1).getType(), RestrictionType.LT); + assertEquals(RestrictionKit.lte("a", 1).getType(), RestrictionType.LTE); + assertEquals(RestrictionKit.startWith("a", 1).getType(), RestrictionType.STARTWITH); + assertEquals(RestrictionKit.endWith("a", 1).getType(), RestrictionType.ENDWITH); + assertEquals(RestrictionKit.like("a", 1).getType(), RestrictionType.LIKE); + assertEquals(RestrictionKit.or(new LteRestriction()).getType(), RestrictionType.OR); + assertEquals(RestrictionKit.and(new LteRestriction()).getType(), RestrictionType.AND); + Set testSet = new HashSet(); + testSet.add("a"); + testSet.add("b"); + assertEquals(RestrictionKit.in("a", testSet).getType(), RestrictionType.IN); + assertEquals(RestrictionKit.notIn("a", testSet).getType(), RestrictionType.NIN); + + } + +} \ No newline at end of file