Java Condition.or方法代码示例

import org.jooq.Condition; //导入方法依赖的package包/类
private Condition handleConnectiveP(String key, ConnectiveP predicate) {
    List<P> predicates = predicate.getPredicates();
    List<Condition> queries = predicates.stream().map(p -> {
        if (p instanceof ConnectiveP) return handleConnectiveP(key, (ConnectiveP) p);
        Object pValue = p.getValue();
        BiPredicate pBiPredicate = p.getBiPredicate();
        return predicateToQuery(key, pValue, pBiPredicate);
    }).collect(Collectors.toList());
    Condition condition = queries.get(0);
    if (predicate instanceof AndP){
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.and(queries.get(i));
        }
    }
    else if (predicate instanceof OrP){
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.or(queries.get(i));
        }
    }
    else throw new IllegalArgumentException("Connective predicate not supported by unipop");
    return condition;
}
 

import org.jooq.Condition; //导入方法依赖的package包/类
@Override
public List<? extends ProjectMember> getProjectMembersByIdentity(long projectId, Set<Identity> identities) {
    Condition allMembers = DSL.falseCondition();
    for (Identity identity : identities) {
        allMembers = allMembers.or(PROJECT_MEMBER.EXTERNAL_ID.eq(identity.getExternalId())
                .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(identity.getExternalIdType()))
                .and(PROJECT_MEMBER.REMOVED.isNull())
                .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE))
                .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId)));
    }
    SelectQuery<Record> query = create().selectQuery();
    query.addFrom(PROJECT_MEMBER);
    query.addConditions(allMembers);
    query.setDistinct(true);
    return query.fetchInto(PROJECT_MEMBER);
}
 

import org.jooq.Condition; //导入方法依赖的package包/类
@Override
public boolean isProjectOwner(long projectId, Long usingAccount, boolean isAdmin, Set<Identity> identities) {
    if (identities == null) {
        return false;
    }
    if (isAdmin) {
        return true;
    }
    if (usingAccount != null && usingAccount.equals(projectId)) {
        return false;
    }
    Set<ProjectMemberRecord> projectMembers = new HashSet<>();
    Condition allMembers = DSL.falseCondition();
    for (Identity id : identities) {
        allMembers = allMembers.or(PROJECT_MEMBER.EXTERNAL_ID.eq(id.getExternalId())
                .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(id.getExternalIdType()))
                .and(PROJECT_MEMBER.ROLE.eq(ProjectConstants.OWNER))
                .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId))
                .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE))
                .and(PROJECT_MEMBER.REMOVED.isNull()));
    }
    projectMembers.addAll(create().selectFrom(PROJECT_MEMBER).where(allMembers).fetch());
    return !projectMembers.isEmpty();
}
 

import org.jooq.Condition; //导入方法依赖的package包/类
@Override
public boolean isProjectMember(long projectId, Long usingAccount, boolean isAdmin, Set<Identity> identities) {
    if (identities == null) {
        return false;
    }
    if ((usingAccount != null && usingAccount.equals(projectId)) || isAdmin) {
        return true;
    }
    Set<ProjectMemberRecord> projectMembers = new HashSet<>();
    Condition allMembers = DSL.falseCondition();
    for (Identity id : identities) {
        allMembers = allMembers.or(PROJECT_MEMBER.EXTERNAL_ID.eq(id.getExternalId())
                .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(id.getExternalIdType()))
                .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId))
                .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE))
                .and(PROJECT_MEMBER.REMOVED.isNull()));
    }
    projectMembers.addAll(create().selectFrom(PROJECT_MEMBER).where(allMembers).fetch());
    return !projectMembers.isEmpty();
}
 

import org.jooq.Condition; //导入方法依赖的package包/类
protected Condition groupCondition() {
    if ( groupManager.shouldHandleWildcard() ) {
        return DSL.trueCondition();
    }

    Condition condition = DSL.falseCondition();
    Set<Long> supported = groupManager.supportedGroups();

    if ( supported.size() > 0 ) {
        condition = AGENT.AGENT_GROUP_ID.in(supported);
    }

    if ( groupManager.shouldHandleUnassigned() ) {
        condition = condition.or(AGENT.AGENT_GROUP_ID.isNull());
    }

    return condition;
}
 

import org.jooq.Condition; //导入方法依赖的package包/类
private Condition addCondition(QueryParams queryParams, Map<String, Object> queryMap) {

		List<Condition> ccc = new LinkedList<Condition>();
		String queryOperator = null;
		for (QueryParam queryParam : queryParams) {
			queryOperator = queryParam.getOperator().toString();
			switch (queryParam.getOperator()) {
			case EQ:
			case GT:
			case GTE:
			case LT:
			case LTE:
			case NE:
			case IN:
			case LIKE:
			case NIN:
				ccc.add(getSimpleCondition(queryParam.getOperator(), DSL.field(queryParam.getKey()),
						queryMap.get(queryParam.getKey())));
				break;
			case OR:
			case AND:

				QueryParam qp = queryParam.getParams().get(0);

				Condition condition = getSimpleCondition(qp.getOperator(), DSL.field(qp.getKey()),
						queryMap.get(qp.getKey()));

				for (int i = 1; i < queryParam.getParams().size(); i++) {

					QueryParam orQueryParam = queryParam.getParams().get(i);

					Condition c = getSimpleCondition(orQueryParam.getOperator(), DSL.field(orQueryParam.getKey()),
							queryMap.get(orQueryParam.getKey()));

					switch (queryParam.getOperator()) {
					case OR:
						condition = condition.or(c);
						break;
					case AND:
						condition = condition.and(c);
						break;
					default:
						break;
					}
				}

				ccc.add(condition);
				break;
			default:
				break;
			}
		}
		Condition rc = null;
		for (Condition xc : ccc) {
			if (rc == null) {
				rc = xc;
			} else {
				if (queryOperator.equals("LIKE")) {
					rc = rc.and(xc);
				} else {
					rc = rc.or(xc);
				}
			}
		}
		return rc;
	}