Java Criteria类代码示例

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
/** adds a predicate to a Criteria.*/
private void addPredicate(Predicate p, Criteria parent, LookupCustomizer.Transform<Predicate, Predicate> transform) {
    p = transform.apply(p);

    if (p instanceof PropertyPathPredicate) {
        final String pp = ((PropertyPathPredicate) p).getPropertyPath();
        if (p instanceof NotNullPredicate) {
            parent.addNotNull(pp);
        } else if (p instanceof NullPredicate) {
            parent.addIsNull(pp);
        } else if (p instanceof SingleValuedPredicate) {
            addSingleValuePredicate((SingleValuedPredicate) p, parent);
        } else if (p instanceof MultiValuedPredicate) {
            addMultiValuePredicate((MultiValuedPredicate) p, parent);
        } else {
            throw new UnsupportedPredicateException(p);
        }
    } else if (p instanceof CompositePredicate) {
        addCompositePredicate((CompositePredicate) p, parent, transform);
    } else {
        throw new UnsupportedPredicateException(p);
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
public Criteria getCollectionCriteriaFromMapUsingPrimaryKeysOnly(Class businessObjectClass, Map formProps) {
    BusinessObject businessObject = checkBusinessObjectClass(businessObjectClass);
    Criteria criteria = new Criteria();
    List pkFields = KRADServiceLocatorWeb.getLegacyDataAdapter().listPrimaryKeyFieldNames(businessObjectClass);
    Iterator pkIter = pkFields.iterator();
    while (pkIter.hasNext()) {
        String pkFieldName = (String) pkIter.next();
        String pkValue = (String) formProps.get(pkFieldName);

        if (StringUtils.isBlank(pkValue)) {
            throw new RuntimeException("Missing pk value for field " + pkFieldName + " when a search based on PK values only is performed.");
        }
        else {
            for (SearchOperator op : SearchOperator.QUERY_CHARACTERS) {
                if (pkValue.contains(op.op())) {
                    throw new RuntimeException("Value \"" + pkValue + "\" for PK field " + pkFieldName + " contains wildcard/operator characters.");
                }
            }
        }
        boolean treatWildcardsAndOperatorsAsLiteral = KNSServiceLocator.
        		getBusinessObjectDictionaryService().isLookupFieldTreatWildcardsAndOperatorsAsLiteral(businessObjectClass, pkFieldName);
        createCriteria(businessObject, pkValue, pkFieldName, false, treatWildcardsAndOperatorsAsLiteral, criteria);
    }
    return criteria;
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
/**
 * This method applies the search results limit to the search criteria for this BO
 *
 * @param businessObjectClass BO class to search on / get limit for
 * @param criteria search criteria
 * @param platform database platform
 * @param limit limit to use.  If limit is null, getSearchResultsLimit will be called using the businessObjectClass
 * to see if a limit can be found for this particular businessObjectClass.
 */
protected void applySearchResultsLimit(Class businessObjectClass, Criteria criteria, DatabasePlatform platform,
        Integer limit) {
    String limitSql = null;
    if (limit != null) {
        limitSql = platform.applyLimitSql(limit);
    } else {
        limit = LookupUtils.getSearchResultsLimit(businessObjectClass, null);
        if (limit != null) {
            limitSql = platform.applyLimitSql(limit);
        }
    }
    if (StringUtils.isNotBlank(limitSql)) {
        criteria.addSql(limitSql);
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
private void addNotCriteria(String propertyName, String propertyValue, Class propertyType, boolean caseInsensitive, Criteria criteria) {

        String[] splitPropVal = StringUtils.split(propertyValue, SearchOperator.NOT.op());
        try {
            int strLength = splitPropVal.length;
            // if Not'ed empty criteria
            if (strLength == 0)
                throw new IllegalArgumentException("Improper syntax of NOT operator in " + propertyName);
            // if more than one NOT operator assume an implicit and (i.e. !a!b = !a&!b)
            if (strLength > 1) {
                String expandedNot = SearchOperator.NOT + StringUtils.join(splitPropVal, SearchOperator.AND.op() + SearchOperator.NOT.op());
                // we know that since this method was called, treatWildcardsAndOperatorsAsLiteral must be false
                addCriteria(propertyName, expandedNot, propertyType, caseInsensitive, false, criteria);
            }
            else {
                // only one so add a not like
                criteria.addNotLike(propertyName, splitPropVal[0]);
            }
        } catch (IllegalArgumentException ex) {
            GlobalVariables.getMessageMap().putError("lookupCriteria[" + propertyName + "]", RiceKeyConstants.ERROR_NOT_SYNTAX, propertyName);
        }
    }
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
/**
 * Builds a sub criteria object joined with an 'AND' or 'OR' (depending on splitValue) using the split values of propertyValue. Then joins back the
 * sub criteria to the main criteria using an 'AND'.
 */
private void addLogicalOperatorCriteria(String propertyName, String propertyValue, Class propertyType, boolean caseInsensitive, Criteria criteria, String splitValue) {
    String[] splitPropVal = StringUtils.split(propertyValue, splitValue);

    Criteria subCriteria = new Criteria();
    for (int i = 0; i < splitPropVal.length; i++) {
    	Criteria predicate = new Criteria();

        addCriteria(propertyName, splitPropVal[i], propertyType, caseInsensitive, false, predicate);
        if (splitValue.equals(SearchOperator.OR.op())) {
        	subCriteria.addOrCriteria(predicate);
        }
        if (splitValue.equals(SearchOperator.AND.op())) {
        	subCriteria.addAndCriteria(predicate);
        }
    }

    criteria.addAndCriteria(subCriteria);
}
 

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包/类
/**
 * Retrieve a List of Document instances with the given ids
 *
 * @param clazz
 * @param idList
 * @return List
 */
@Override
public <T extends Document> List<T> findByDocumentHeaderIds(Class<T> clazz, List<String> idList) {
    Criteria criteria = new Criteria();
    criteria.addIn(KRADPropertyConstants.DOCUMENT_NUMBER, idList);

    QueryByCriteria query = QueryFactory.newQuery(clazz, criteria);
    
    // this cast is correct because OJB produces a collection which contains elements of the class defined on the query
    @SuppressWarnings("unchecked")
    List<T> tempList = new ArrayList<T>(this.getPersistenceBrokerTemplate().getCollectionByQuery(query));
    
    for (T doc : tempList) {
    	documentAdHocService.addAdHocs(doc);
    }
    return tempList;
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.dao.BusinessObjectDao#findBySinglePrimaryKey(java.lang.Class, java.lang.Object)
 */
public <T extends BusinessObject> T findBySinglePrimaryKey(Class<T> clazz, Object primaryKey) {
	if (primaryKey.getClass().getName().startsWith("java.lang.")
               || primaryKey.getClass().getName().startsWith("java.sql.")
               || primaryKey.getClass().getName().startsWith("java.math.")
               || primaryKey.getClass().getName().startsWith("java.util.")) {
		try {
			return (T) getPersistenceBrokerTemplate().getObjectById(clazz, primaryKey);
		} catch (  ObjectRetrievalFailureException ex  ) {
    		// it doesn't exist, just return null
			return null;
		}
	} else {
		Criteria criteria = buildCriteria(clazz, primaryKey);

        return (T) getPersistenceBrokerTemplate().getObjectByQuery(QueryFactory.newQuery(clazz, criteria));
	}
}
 

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包/类
/**
 * This method will build out criteria in the key-value paradigm (attribute-value).
 *
 * @param negativeFieldValues
 * @return
 */
private Criteria buildNegativeCriteria(Map<String, ?> negativeFieldValues) {
    Criteria criteria = new Criteria();
    for (Iterator i = negativeFieldValues.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.addNotIn(key, (Collection) value);
        }
        else {
            criteria.addNotEqualTo(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包/类
public static void addNumericCriteria(Criteria criteria, String propertyName, String propertyValue) {
    if (StringUtils.contains(propertyValue, SearchOperator.BETWEEN.op())) {
        String[] rangeValues = StringUtils.split(propertyValue, SearchOperator.BETWEEN.op());
        criteria.addBetween(propertyName, TKUtils.cleanNumeric(rangeValues[0]), TKUtils.cleanNumeric( rangeValues[1] ));
    } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN_EQUAL.op())) {
        criteria.addGreaterOrEqualThan(propertyName, TKUtils.cleanNumeric(propertyValue));
    } else if (propertyValue.startsWith(SearchOperator.LESS_THAN_EQUAL.op())) {
        criteria.addLessOrEqualThan(propertyName, TKUtils.cleanNumeric(propertyValue));
    } else if (propertyValue.startsWith(SearchOperator.GREATER_THAN.op())) {
        criteria.addGreaterThan(propertyName, TKUtils.cleanNumeric( propertyValue ) );
    } else if (propertyValue.startsWith(SearchOperator.LESS_THAN.op())) {
        criteria.addLessThan(propertyName, TKUtils.cleanNumeric(propertyValue));
    } else {
        criteria.addEqualTo(propertyName, TKUtils.cleanNumeric(propertyValue));
    }
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
/**
 * Fetches the reversal record that would affected by the posting of the given transaction
 * 
 * @param t the transaction to find the related reversal for
 * @return the reversal affected by the given transaction
 * @see org.kuali.kfs.gl.dataaccess.ReversalDao#getByTransaction(org.kuali.kfs.gl.businessobject.Transaction)
 */
public Reversal getByTransaction(Transaction t) {
    LOG.debug("getByTransaction() started");

    Criteria crit = new Criteria();
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_DOCUMENT_REVERSAL_DATE, t.getFinancialDocumentReversalDate());
    crit.addEqualTo(KFSPropertyConstants.UNIVERSITY_FISCAL_YEAR, t.getUniversityFiscalYear());
    crit.addEqualTo(KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE, t.getChartOfAccountsCode());
    crit.addEqualTo(KFSPropertyConstants.ACCOUNT_NUMBER, t.getAccountNumber());
    crit.addEqualTo(KFSPropertyConstants.SUB_ACCOUNT_NUMBER, t.getSubAccountNumber());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_OBJECT_CODE, t.getFinancialObjectCode());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_SUB_OBJECT_CODE, t.getFinancialSubObjectCode());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_BALANCE_TYPE_CODE, t.getFinancialBalanceTypeCode());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_OBJECT_TYPE_CODE, t.getFinancialObjectTypeCode());
    crit.addEqualTo(KFSPropertyConstants.UNIVERSITY_FISCAL_PERIOD_CODE, t.getUniversityFiscalPeriodCode());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_DOCUMENT_TYPE_CODE, t.getFinancialDocumentTypeCode());
    crit.addEqualTo(KFSPropertyConstants.FINANCIAL_SYSTEM_ORIGINATION_CODE, t.getFinancialSystemOriginationCode());
    crit.addEqualTo(KFSPropertyConstants.DOCUMENT_NUMBER, t.getDocumentNumber());
    crit.addEqualTo(KFSPropertyConstants.TRANSACTION_ENTRY_SEQUENCE_NUMBER, t.getTransactionLedgerEntrySequenceNumber());

    QueryByCriteria qbc = QueryFactory.newQuery(Reversal.class, crit);
    return (Reversal) getPersistenceBrokerTemplate().getObjectByQuery(qbc);
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
protected void readAcctReportsTo() {
    // we will use a report query, to bypass the "persistence" bureaucracy and its cache, saving memory and time
    // we will use the OJB class as a convenient container object in the hashmap
    Integer sqlChartOfAccountsCode = 0;
    Integer sqlAccountNumber = 1;
    Integer sqlReportsToChartofAccountsCode = 2;
    Integer sqlOrganizationCode = 3;
    Criteria criteriaID = ReportQueryByCriteria.CRITERIA_SELECT_ALL;
    // we always get a new copy of the map
    acctRptsToMap = new HashMap<String, BudgetConstructionAccountReports>(hashObjectSize(BudgetConstructionAccountReports.class, criteriaID));
    String[] queryAttr = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE, KFSPropertyConstants.ACCOUNT_NUMBER, KFSPropertyConstants.REPORTS_TO_CHART_OF_ACCOUNTS_CODE, KFSPropertyConstants.REPORTS_TO_ORGANIZATION_CODE };
    ReportQueryByCriteria queryID = new ReportQueryByCriteria(BudgetConstructionAccountReports.class, queryAttr, criteriaID);
    Iterator Results = getPersistenceBrokerTemplate().getReportQueryIteratorByQuery(queryID);
    while (Results.hasNext()) {
        Object[] ReturnList = (Object[]) Results.next();
        BudgetConstructionAccountReports acctRpts = new BudgetConstructionAccountReports();
        acctRpts.setChartOfAccountsCode((String) ReturnList[sqlChartOfAccountsCode]);
        acctRpts.setAccountNumber((String) ReturnList[sqlAccountNumber]);
        acctRpts.setReportsToChartOfAccountsCode((String) ReturnList[sqlReportsToChartofAccountsCode]);
        acctRpts.setReportsToOrganizationCode((String) ReturnList[sqlOrganizationCode]);
        String TestKey = getAcctRptsToKey(acctRpts);
        acctRptsToMap.put(TestKey, acctRpts);
    }
    LOG.info("\nAccount Reports To for Organization Hierarchy:");
    LOG.info(String.format("\nNumber of account-reports-to rows: %d", acctRptsToMap.size()));
}
 

import org.apache.ojb.broker.query.Criteria; //导入依赖的package包/类
public String getSuppLevelQualifierByWorkflowId(String workflowId, String nodeName) {
    String qualifier = null;

    Criteria criteria = new Criteria();
    criteria.addEqualTo(EdoPropertyConstants.EdoSuppReviewLayerDefinitionFields.WORKFLOW_ID, workflowId);
    criteria.addEqualTo(EdoPropertyConstants.EdoSuppReviewLayerDefinitionFields.NODE_NAME, nodeName);

    ReportQueryByCriteria query = QueryFactory.newReportQuery(EdoSuppReviewLayerDefinitionBo.class, criteria);

    Collection c = this.getPersistenceBrokerTemplate().getCollectionByQuery(query);

    for (Object obj : c ) {
        EdoSuppReviewLayerDefinitionBo suppReviewLayer = (EdoSuppReviewLayerDefinitionBo)obj;
        // We don't have qualifier in EdoSuppReviewLayerDefinition any more
        //qualifier = suppReviewLayer.getWorkflowQualifier();
    }

    return qualifier;
}