Browse Source

补充javadoc和单元测试

pull/22/head
richie 5 years ago
parent
commit
59def55dcb
  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

@ -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

@ -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);
}
}
Loading…
Cancel
Save