Java Criteria.addEqualTo方法代码示例

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * Adds to the criteria object based on query characters given
 */
private void addStringRangeCriteria(String propertyName, String propertyValue, Criteria criteria) {

    try {
        if (StringUtils.contains(propertyValue, SearchOperator.BETWEEN.op())) {
            String[] rangeValues = StringUtils.split(propertyValue, SearchOperator.BETWEEN.op());
            if (rangeValues.length < 2)
                throw new IllegalArgumentException("Improper syntax of BETWEEN operator in " + propertyName);

            criteria.addBetween(propertyName, rangeValues[0], rangeValues[1]);
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN_EQUAL.op())) {
            criteria.addGreaterOrEqualThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN_EQUAL.op())) {
            criteria.addLessOrEqualThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN.op())) {
            criteria.addGreaterThan(propertyName, ObjectUtils.clean(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN.op())) {
            criteria.addLessThan(propertyName, ObjectUtils.clean(propertyValue));
        } else {
            criteria.addEqualTo(propertyName, ObjectUtils.clean(propertyValue));
        }
    } catch (IllegalArgumentException ex) {
        GlobalVariables.getMessageMap().putError("lookupCriteria[" + propertyName + "]", RiceKeyConstants.ERROR_BETWEEN_SYNTAX, propertyName);
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * This method will build out criteria in the key-value paradigm (attribute-value).
 *
 * @param fieldValues
 * @return
 */
private Criteria buildCriteria(Map<String, ?> fieldValues) {
    Criteria criteria = new Criteria();
    for (Iterator i = fieldValues.entrySet().iterator(); i.hasNext();) {
        Map.Entry<String, Object> e = (Map.Entry<String, Object>) i.next();

        String key = e.getKey();
        Object value = e.getValue();
        if (value instanceof Collection) {
            criteria.addIn(key, (Collection) value);
        } else {
            criteria.addEqualTo(key, value);
        }
    }

    return criteria;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.dao.MaintenanceDocumentDao#getLockingDocumentNumber(java.lang.String, java.lang.String)
 */
public String getLockingDocumentNumber(String lockingRepresentation, String documentNumber) {

    String lockingDocNumber = "";

    // build the query criteria
    Criteria criteria = new Criteria();
    criteria.addEqualTo("lockingRepresentation", lockingRepresentation);

    // if a docHeaderId is specified, then it will be excluded from the
    // locking representation test.
    if (StringUtils.isNotBlank(documentNumber)) {
        criteria.addNotEqualTo(KRADPropertyConstants.DOCUMENT_NUMBER, documentNumber);
    }

    // attempt to retrieve a document based off this criteria
    MaintenanceLock maintenanceLock = (MaintenanceLock) getPersistenceBrokerTemplate().getObjectByQuery(QueryFactory.newQuery(MaintenanceLock.class, criteria));

    // if a document was found, then there's already one out there pending, and
    // we consider it 'locked' and we return the docnumber.
    if (maintenanceLock != null) {
        lockingDocNumber = maintenanceLock.getDocumentNumber();
    }
    return lockingDocNumber;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * @see org.kuali.ole.gl.dataaccess.BalanceDao#findGeneralBalancesToForwardForFiscalYear(java.lang.Integer, java.util.List,
 *      java.lang.String[])
 */
public Iterator<Balance> findGeneralBalancesToForwardForFiscalYear(Integer year, Collection<String> generalForwardBalanceObjectTypes, Collection<String> generalBalanceForwardBalanceTypes) {

    Criteria c = new Criteria();
    c.addEqualTo(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR, year);
    c.addIn(OLEPropertyConstants.BALANCE_TYPE_CODE, generalBalanceForwardBalanceTypes);
    c.addIn(OLEPropertyConstants.OBJECT_TYPE_CODE, generalForwardBalanceObjectTypes);

    QueryByCriteria query = QueryFactory.newQuery(Balance.class, c);
    query.addOrderByAscending(OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE);
    query.addOrderByAscending(OLEPropertyConstants.ACCOUNT_NUMBER);
    query.addOrderByAscending(OLEPropertyConstants.SUB_ACCOUNT_NUMBER);
    query.addOrderByAscending(OLEPropertyConstants.OBJECT_CODE);
    query.addOrderByAscending(OLEPropertyConstants.SUB_OBJECT_CODE);
    query.addOrderByAscending(OLEPropertyConstants.BALANCE_TYPE_CODE);
    query.addOrderByAscending(OLEPropertyConstants.OBJECT_TYPE_CODE);

    Iterator<Balance> balances = getPersistenceBrokerTemplate().getIteratorByQuery(query);

    return balances;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public List<String> getPrincipalIdsInPosition(String positionNumber, LocalDate asOfDate) {
    Set<String> principalIdsInPosition = new HashSet<String>();
	
	Criteria root = new Criteria();
    root.addEqualTo("positionNumber", positionNumber);
    root.addEqualTo("effectiveDate", OjbSubQueryUtil.getEffectiveDateSubQuery(JobBo.class, asOfDate, JobBo.BUSINESS_KEYS, false));
    root.addEqualTo("timestamp", OjbSubQueryUtil.getTimestampSubQuery(JobBo.class, JobBo.BUSINESS_KEYS, false));

    Criteria activeFilter = new Criteria();
    activeFilter.addEqualTo("active", true);
    root.addAndCriteria(activeFilter);

    Query query = QueryFactory.newQuery(JobBo.class, root);
    Collection<JobBo> jobs = getPersistenceBrokerTemplate().getCollectionByQuery(query);
    
    for (JobBo job : jobs) {
    	principalIdsInPosition.add(job.getPrincipalId());
    }
    
    return new ArrayList<String>(principalIdsInPosition);
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
@Override
public List <AccrualCategoryBo> getInActiveLeaveAccrualCategoriesForLeavePlan(String leavePlan, LocalDate asOfDate) {
	Criteria root = new Criteria();
	root.addEqualTo("leavePlan", leavePlan);
	root.addNotEqualTo("accrualEarnInterval", "N");
	root.addLessOrEqualThan("effectiveDate", asOfDate.toDate());
	root.addEqualTo("active", false);
	Query query = QueryFactory.newQuery(AccrualCategoryBo.class, root);
	Collection c = this.getPersistenceBrokerTemplate().getCollectionByQuery(query);
	List<AccrualCategoryBo> accrualCategories = new ArrayList<AccrualCategoryBo>();

	if (c != null) {
		accrualCategories.addAll(c);
	}
	return accrualCategories;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * @see org.kuali.kfs.pdp.dataaccess.PaymentGroupDao#getDisbursementNumbersByDisbursementType(java.lang.Integer, java.lang.String, java.lang.String)
 */
public List<Integer> getDisbursementNumbersByDisbursementTypeAndBankCode(Integer pid, String disbursementType, String bankCode) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("getDisbursementNumbersByDisbursementType() started");
    }

    List<Integer> results = new ArrayList<Integer>();

    Criteria criteria = new Criteria();
    criteria.addEqualTo(PdpPropertyConstants.PaymentGroup.PAYMENT_GROUP_PROCESS_ID, pid);
    criteria.addEqualTo(PdpPropertyConstants.PaymentGroup.PAYMENT_GROUP_DISBURSEMENT_TYPE_CODE, disbursementType);
    criteria.addEqualTo(PdpPropertyConstants.PaymentGroup.PAYMENT_GROUP_BANK_CODE, bankCode);

    String[] fields = new String[] { PdpPropertyConstants.PaymentGroup.PAYMENT_GROUP_DISBURSEMENT_NBR };

    ReportQueryByCriteria rq = QueryFactory.newReportQuery(PaymentGroup.class, fields, criteria, true);
    rq.addOrderBy(PdpPropertyConstants.PaymentGroup.PAYMENT_GROUP_DISBURSEMENT_NBR, true);

    Iterator i = getPersistenceBrokerTemplate().getReportQueryIteratorByQuery(rq);
    while ( i.hasNext() ) {
        Object[] data = (Object[])i.next();
        BigDecimal d = (BigDecimal)data[0];
        results.add( new Integer(d.intValue()) );
    }
    return results;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
public void testComplexCriteriaWithPathClasses_1()
{
    Criteria criteria         = new Criteria();
    Criteria categoryCriteria = new Criteria();
    Criteria topicCriteria    = new Criteria();

    topicCriteria.addEqualTo("qualifiers.importance", "important");
    topicCriteria.addPathClass("qualifiers", Topic.class);
    criteria.addOrCriteria(topicCriteria);
    categoryCriteria.addNotNull("qualifiers.description");
    categoryCriteria.addPathClass("qualifiers", Category.class);
    criteria.addOrCriteria(categoryCriteria);

    QueryByCriteria query   = QueryFactory.newQuery(BaseContentImpl.class, criteria, true);
    List            content = (List)broker.getCollectionByQuery(query);

    assertEquals(1, content.size());
    assertEquals(2, ((News)content.get(0)).getId());
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
private FarAwayClass doReferenceMatchingStore(PBKey key) throws Exception
{
    FarAwayClass fa = createFarAwayObject();
    FarAwayReferenceIF ref = new FarAwayReference();
    ref.setName(REFERENCE_NAME);

    PersistenceBroker farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(key);
    farAwayPB.beginTransaction();
    farAwayPB.store(ref);
    fa.setReference(ref);
    farAwayPB.store(fa);
    farAwayPB.commitTransaction();
    farAwayPB.close();

    farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(key);
    Criteria criteria = new Criteria();
    criteria.addEqualTo("id", new Integer(fa.getId()));
    FarAwayClass result = (FarAwayClass)farAwayPB.getObjectByQuery(
            new QueryByCriteria(FarAwayClass.class, criteria));
    farAwayPB.close();

    int refId = result.getReference().getId();
    assertEquals(ref.getId(), refId);
    return result;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/** adds a single valued predicate to a Criteria. */
private void addSingleValuePredicate(SingleValuedPredicate p, Criteria parent) {
    final Object value = getVal(p.getValue());
    final String pp = p.getPropertyPath();
    if (p instanceof EqualPredicate) {
        parent.addEqualTo(pp, value);
    } else if (p instanceof EqualIgnoreCasePredicate) {
        parent.addEqualTo(genUpperFunc(pp), ((String) value).toUpperCase());
    } else if (p instanceof GreaterThanOrEqualPredicate) {
        parent.addGreaterOrEqualThan(pp, value);
    } else if (p instanceof GreaterThanPredicate) {
        parent.addGreaterThan(pp, value);
    } else if (p instanceof LessThanOrEqualPredicate) {
        parent.addLessOrEqualThan(pp, value);
    } else if (p instanceof LessThanPredicate) {
        parent.addLessThan(pp, value);
    } else if (p instanceof LikePredicate) {
        //no need to convert * or ? since ojb handles the conversion/escaping
        parent.addLike(genUpperFunc(pp), ((String) value).toUpperCase());
    } else if (p instanceof NotEqualPredicate) {
        parent.addNotEqualTo(pp, value);
    } else if (p instanceof NotEqualIgnoreCasePredicate) {
        parent.addNotEqualTo(genUpperFunc(pp), ((String) value).toUpperCase());
    } else if (p instanceof NotLikePredicate) {
        parent.addNotLike(pp, value);
    } else {
        throw new UnsupportedPredicateException(p);
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
* Adds to the criteria object based on query characters given
*/
  private void addDateRangeCriteria(String propertyName, String propertyValue, boolean treatWildcardsAndOperatorsAsLiteral, Criteria criteria) {

      try {
          if (StringUtils.contains(propertyValue, SearchOperator.BETWEEN.op())) {
              if (treatWildcardsAndOperatorsAsLiteral)
                  throw new RuntimeException("Wildcards and operators are not allowed on this date field: " + propertyName);
              String[] rangeValues = StringUtils.split(propertyValue, SearchOperator.BETWEEN.op());
              if (rangeValues.length < 2)
                  throw new IllegalArgumentException("Improper syntax of BETWEEN operator in " + propertyName);

              criteria.addBetween(propertyName, parseDate( ObjectUtils.clean(rangeValues[0] ) ), parseDate( ObjectUtils.clean(rangeValues[1] ) ) );
          } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN_EQUAL.op())) {
              if (treatWildcardsAndOperatorsAsLiteral)
                  throw new RuntimeException("Wildcards and operators are not allowed on this date field: " + propertyName);
              criteria.addGreaterOrEqualThan(propertyName, parseDate( ObjectUtils.clean(propertyValue) ) );
          } else if (propertyValue.startsWith(SearchOperator.LESS_THAN_EQUAL.op())) {
              if (treatWildcardsAndOperatorsAsLiteral)
                  throw new RuntimeException("Wildcards and operators are not allowed on this date field: " + propertyName);
              criteria.addLessOrEqualThan(propertyName, parseDate( ObjectUtils.clean(propertyValue) ) );
          } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN.op())) {
              if (treatWildcardsAndOperatorsAsLiteral)
                  throw new RuntimeException("Wildcards and operators are not allowed on this date field: " + propertyName);
              criteria.addGreaterThan(propertyName, parseDate( ObjectUtils.clean(propertyValue) ) );
          } else if (propertyValue.startsWith(SearchOperator.LESS_THAN.op())) {
              if (treatWildcardsAndOperatorsAsLiteral)
                  throw new RuntimeException("Wildcards and operators are not allowed on this date field: " + propertyName);
              criteria.addLessThan(propertyName, parseDate( ObjectUtils.clean(propertyValue) ) );
          } else {
              criteria.addEqualTo(propertyName, parseDate( ObjectUtils.clean(propertyValue) ) );
          }
      } catch (IllegalArgumentException ex) {
          GlobalVariables.getMessageMap().putError("lookupCriteria[" + propertyName + "]", RiceKeyConstants.ERROR_BETWEEN_SYNTAX, propertyName);
      }
  }
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * Adds to the criteria object based on query characters given
 */
private void addNumericRangeCriteria(String propertyName, String propertyValue, boolean treatWildcardsAndOperatorsAsLiteral, Criteria criteria) {

    try {
        if (StringUtils.contains(propertyValue, SearchOperator.BETWEEN.op())) {
            if (treatWildcardsAndOperatorsAsLiteral)
                throw new RuntimeException("Cannot use wildcards and operators on numeric field " + propertyName);
            String[] rangeValues = StringUtils.split(propertyValue, SearchOperator.BETWEEN.op());
            if (rangeValues.length < 2)
                throw new IllegalArgumentException("Improper syntax of BETWEEN operator in " + propertyName);

            criteria.addBetween(propertyName, cleanNumeric( rangeValues[0] ), cleanNumeric( rangeValues[1] ));
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN_EQUAL.op())) {
            if (treatWildcardsAndOperatorsAsLiteral)
                throw new RuntimeException("Cannot use wildcards and operators on numeric field " + propertyName);
            criteria.addGreaterOrEqualThan(propertyName, cleanNumeric(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN_EQUAL.op())) {
            if (treatWildcardsAndOperatorsAsLiteral)
                throw new RuntimeException("Cannot use wildcards and operators on numeric field " + propertyName);
            criteria.addLessOrEqualThan(propertyName, cleanNumeric(propertyValue));
        } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN.op())) {
            if (treatWildcardsAndOperatorsAsLiteral)
                throw new RuntimeException("Cannot use wildcards and operators on numeric field " + propertyName);
            criteria.addGreaterThan(propertyName, cleanNumeric( propertyValue ) );
        } else if (propertyValue.startsWith(SearchOperator.LESS_THAN.op())) {
            if (treatWildcardsAndOperatorsAsLiteral)
                throw new RuntimeException("Cannot use wildcards and operators on numeric field " + propertyName);
            criteria.addLessThan(propertyName, cleanNumeric(propertyValue));
        } else {
            criteria.addEqualTo(propertyName, cleanNumeric(propertyValue));
        }
    } catch (IllegalArgumentException ex) {
        GlobalVariables.getMessageMap().putError("lookupCriteria[" + propertyName + "]", RiceKeyConstants.ERROR_BETWEEN_SYNTAX, propertyName);
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * Builds a Criteria object for active field set to true
 * @return Criteria
 */
private Criteria buildActiveCriteria(){
    Criteria criteria = new Criteria();
    criteria.addEqualTo(KRADPropertyConstants.ACTIVE, true);

    return criteria;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
/**
 * Builds a Criteria object for active field set to true
 * @return Criteria
 */
private Criteria buildInactiveCriteria(){
    Criteria criteria = new Criteria();
    criteria.addEqualTo(KRADPropertyConstants.ACTIVE, false);

    return criteria;
}
 

import org.apache.ojb.broker.query.Criteria; //导入方法依赖的package包/类
public boolean isDuplicateEntry(Entry glEntry) {
    // find matching entry from CB_GL_ENTRY_T
    Map<String, Object> glKeys = new LinkedHashMap<String, Object>();
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.UNIVERSITY_FISCAL_YEAR, glEntry.getUniversityFiscalYear());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.CHART_OF_ACCOUNTS_CODE, glEntry.getChartOfAccountsCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.ACCOUNT_NUMBER, glEntry.getAccountNumber());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.SUB_ACCOUNT_NUMBER, glEntry.getSubAccountNumber());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_OBJECT_CODE, glEntry.getFinancialObjectCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_SUB_OBJECT_CODE, glEntry.getFinancialSubObjectCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_BALANCE_TYPE_CODE, glEntry.getFinancialBalanceTypeCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_OBJECT_TYPE_CODE, glEntry.getFinancialObjectTypeCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.UNIVERSITY_FISCAL_PERIOD_CODE, glEntry.getUniversityFiscalPeriodCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_DOCUMENT_TYPE_CODE, glEntry.getFinancialDocumentTypeCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.FINANCIAL_SYSTEM_ORIGINATION_CODE, glEntry.getFinancialSystemOriginationCode());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.DOCUMENT_NUMBER, glEntry.getDocumentNumber());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.TRANSACTION_LEDGER_ENTRY_SEQUENCE_NUMBER, glEntry.getTransactionLedgerEntrySequenceNumber());
    glKeys.put(CabPropertyConstants.GeneralLedgerEntry.PROJECT_CD, glEntry.getProjectCode());

    Criteria criteria = OJBUtility.buildCriteriaFromMap(glKeys, new GeneralLedgerEntry());
    // is equal to or is null criteria
    Criteria tempCriteria1 = new Criteria();
    Criteria tempCriteria2 = new Criteria();
    tempCriteria1.addEqualTo(CabPropertyConstants.GeneralLedgerEntry.ORGNIZATION_REFERENCE_ID,  glEntry.getOrganizationReferenceId());
    if (StringUtils.isEmpty(glEntry.getOrganizationReferenceId())) {
        tempCriteria2.addIsNull(CabPropertyConstants.GeneralLedgerEntry.ORGNIZATION_REFERENCE_ID);
        tempCriteria1.addOrCriteria(tempCriteria2);
    }
    criteria.addAndCriteria(tempCriteria1);
    Query query = QueryFactory.newQuery(GeneralLedgerEntry.class, criteria);
    Collection<GeneralLedgerEntry> matchingEntries = getPersistenceBrokerTemplate().getCollectionByQuery(query);

    // if not found, return false
    if (matchingEntries == null || matchingEntries.isEmpty()) {
        return false;
    }
    return true;
}