fanruan
/
finekit
7
4
Fork 14
Code Issues 1 Pull Requests 1 Releases 1 Wiki Activity
Browse Source

补充javadoc和单元测试

pull/22/head
richie 5 years ago
parent
ab1f42b965
commit
59def55dcb
2 changed files with 253 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 212
      src/main/java/com/fanruan/api/query/RestrictionKit.java
  2. 41
      src/test/java/com/fanruan/api/query/RestrictionKitTest.java

212
src/main/java/com/fanruan/api/query/RestrictionKit.java
Unescape View File

@ -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<Restriction> 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<Restriction> restrictionList) {
return RestrictionFactory.and(restrictionList);
}
/**
* 排除掉指定的限制条件
*
* @param restriction 条件
* @return 限制条件
*/
public static Restriction not(Restriction restriction) {
return RestrictionFactory.not(restriction);
}

41
src/test/java/com/fanruan/api/query/RestrictionKitTest.java
Unescape View File

@ -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<String> testSet = new HashSet<String>();
testSet.add("a");
testSet.add("b");
assertEquals(RestrictionKit.in("a", testSet).getType(), RestrictionType.IN);
assertEquals(RestrictionKit.notIn("a", testSet).getType(), RestrictionType.NIN);
}
}
Write Preview
Loading…
Cancel
Save