Java 类org.hibernate.criterion.Junction 实例源码

@Override
public DetachedCriteria getCriteria() {
    DetachedCriteria crit = getParent().getCriteria();
    Junction junction = null;
    if (disjunction) {
        junction = Restrictions.disjunction();
    } else {
        junction = Restrictions.conjunction();
    }
    for (Iterator iter = attributeExpressions.iterator(); iter.hasNext();) {
        AttributeExpression aExpr = (AttributeExpression) iter.next();
        DetachedCriteria attrCriteria = aExpr.getCriteria();
        junction.add(Property.forName("longId").in(attrCriteria.setProjection(Projections.property("ownerId"))));
    }
    crit.add(junction);

    return(crit);
}

/**
 * Complements a criteria by processing an enumeration query structure.
 *
 * @param path
 *     the path to the comparable property.
 * @param enumQueryStructure
 *     the collection of checked / unchecked enumeration values.
 * @return the created criterion or null if no criterion necessary.
 */
protected Criterion createEnumQueryStructureRestriction(String path, EnumQueryStructure enumQueryStructure) {
  Set<String> inListValues = new HashSet<>();
  boolean nullAllowed = false;
  for (EnumValueQueryStructure inListValue : enumQueryStructure.getSelectedEnumerationValues()) {
    if (inListValue.getValue() == null || "".equals(inListValue.getValue())) {
      nullAllowed = true;
    } else {
      inListValues.add(inListValue.getValue());
    }
  }
  Junction queryStructureRestriction = null;
  if (!inListValues.isEmpty() || nullAllowed) {
    queryStructureRestriction = Restrictions.disjunction();
    if (!inListValues.isEmpty()) {
      queryStructureRestriction.add(Restrictions.in(path, inListValues));
    }
    if (nullAllowed) {
      queryStructureRestriction.add(Restrictions.isNull(path));
    }
  }
  return queryStructureRestriction;
}

@Override
public DetachedCriteria getCriteria() {
    DetachedCriteria crit = getParent().getCriteria();
    Junction junction = null;
    if (disjunction) {
        junction = Restrictions.disjunction();
    } else {
        junction = Restrictions.conjunction();
    }
    for (Iterator iter = attributeExpressions.iterator(); iter.hasNext();) {
        AttributeExpression aExpr = (AttributeExpression) iter.next();
        DetachedCriteria attrCriteria = aExpr.getCriteria();
        junction.add(Property.forName("longId").in(attrCriteria.setProjection(Projections.property("ownerId"))));
    }
    crit.add(junction);

    return(crit);
}

private Junction getDatumJunction(AdvancedSampleSearchBean searchBean) {
    // if AND and more than one type of datum, don't use junction
    if (searchBean.getCharacterizationLogicalOperator().equals("and")
            && searchBean.getDatumTypeCount() > 1) {
        return null;
    }
    Disjunction datumDisjunction = Restrictions.disjunction();
    Conjunction datumConjunction = Restrictions.conjunction();
    for (CharacterizationQueryBean charQuery : searchBean
            .getCharacterizationQueries()) {
        Criterion datumCrit = getDatumCriterion(charQuery);
        if (datumCrit != null) {
            datumDisjunction.add(datumCrit);
            if (searchBean.getDatumTypeCount() == 1) {
                datumConjunction.add(datumCrit);
            }
        }
    }
    // default to or if only one query
    Junction junction = (searchBean.getCharacterizationLogicalOperator()
            .equals("or") || searchBean.getCharacterizationQueries().size() == 1) ? datumDisjunction
            : datumConjunction;
    return junction;
}

/**
 * Get the sample name junction used in sample queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getSampleNameJunction(AdvancedSampleSearchBean searchBean)
        throws Exception {
    Disjunction sampleDisjunction = Restrictions.disjunction();
    Conjunction sampleConjunction = Restrictions.conjunction();
    for (SampleQueryBean query : searchBean.getSampleQueries()) {
        if (query.getNameType().equals("sample name")) {
            Criterion sampleNameCrit = getSampleNameCriterion(query);
            if (sampleNameCrit != null) {
                sampleDisjunction.add(sampleNameCrit);
                sampleConjunction.add(sampleNameCrit);
            }
        }
    }
    Junction junction = (searchBean.getSampleLogicalOperator().equals("or") || searchBean
            .getSampleQueries().size() == 1) ? sampleDisjunction
            : sampleConjunction;
    return junction;
}

public boolean applySearchFilters(Criteria criteria, String searchTerm) {
    boolean filterAdded = false;
    //If search string is integer type, it only searches on Id field
    if (NumberUtils.isDigits(searchTerm)) {
        criteria.add(Restrictions.eq(getIdField(), Integer.parseInt(searchTerm)));
        filterAdded = true;
    } else if (getSearchFields() != null && getSearchFields().size() != 0) {
        //Text filtering is applied only if you have specified getSearchFields().
        String likeTerm = "%" + searchTerm + "%";
        Junction disjunction = Restrictions.disjunction();
        for (String field : getSearchFields()) {
            //Performs case insensitive search on all search fields.
            //Also does not searches on associations. Only value types are searched.
            disjunction.add(Restrictions.ilike(field, likeTerm));
        }
        criteria.add(disjunction);
        filterAdded = true;
    }
    return filterAdded;
}

public boolean applySearchFilters(Criteria criteria, String searchTerm) {
    boolean filterAdded = false;
    //If search string is integer type, it only searches on Id field
    if (NumberUtils.isDigits(searchTerm)) {
        criteria.add(Restrictions.eq(getIdField(), Integer.parseInt(searchTerm)));
        filterAdded = true;
    } else if (getSearchFields() != null && getSearchFields().size() != 0) {
        //Text filtering is applied only if you have specified getSearchFields().
        String likeTerm = "%" + searchTerm + "%";
        Junction disjunction = Restrictions.disjunction();
        for (String field : getSearchFields()) {
            //Performs case insensitive search on all search fields.
            //Also does not searches on associations. Only value types are searched.
            disjunction.add(Restrictions.ilike(field, likeTerm));
        }
        criteria.add(disjunction);
        filterAdded = true;
    }
    return filterAdded;
}

private void addChromosomeCoordinatesToCriterion(Integer chromosomeCoordinateHigh,
        Integer chromosomeCoordinateLow, Criteria segmentDataCrit, String chromosomeNumber) {
    if (chromosomeCoordinateHigh == null || chromosomeCoordinateLow == null) {
        segmentDataCrit.add(chromosomeNumberExpression(chromosomeNumber));
        if (chromosomeCoordinateHigh != null) {
            segmentDataCrit.add(segmentEndLessThanHigh(chromosomeCoordinateHigh));
        }
        if (chromosomeCoordinateLow != null) {
            segmentDataCrit.add(segmentStartGreaterThanLow(chromosomeCoordinateLow));
        }
    } else {
        Junction overallOrStatement = Restrictions.disjunction();
        // (loc.startPos <= lowerInput && loc.endPos >= lowerInput && loc.chromosome == chromosomeInput)
        //  || (loc.startPos >= lowerInput  && loc.startPos <= higherInput && loc.chromosome == chromosomeInput)
        overallOrStatement.add(Restrictions.conjunction().add(segmentStartLessThanLow(chromosomeCoordinateLow))
                .add(segmentEndGreaterThanLow(chromosomeCoordinateLow)).add(
                        chromosomeNumberExpression(chromosomeNumber)));
        overallOrStatement.add(Restrictions.conjunction().add(segmentStartGreaterThanLow(chromosomeCoordinateLow))
                .add(segmentStartLessThanHigh(chromosomeCoordinateHigh)).add(
                        chromosomeNumberExpression(chromosomeNumber)));
        segmentDataCrit.add(overallOrStatement);
    }
}

private void addMultipleChromosomeCoordinatesToCriterion(Criteria segmentDataCrit,
        List<GeneChromosomalLocation> geneLocations) {
    Junction overallOrStatement = Restrictions.disjunction();
    // (loc.startPos <= lowerInput && loc.endPos >= lowerInput && loc.chromosome == chromosomeInput)
    //  || (loc.startPos >= lowerInput  && loc.startPos <= higherInput && loc.chromosome == chromosomeInput)
    for (GeneChromosomalLocation geneLocation : geneLocations) {
        Integer chromosomeCoordinateLow = geneLocation.getLocation().getStartPosition();
        Integer chromosomeCoordinateHigh = geneLocation.getLocation().getEndPosition();
        overallOrStatement.add(Restrictions.conjunction().add(segmentStartLessThanLow(chromosomeCoordinateLow))
                .add(segmentEndGreaterThanLow(chromosomeCoordinateLow)).add(
                        chromosomeNumberExpression(Cai2Util.getInternalChromosomeNumber(
                                geneLocation.getLocation().getChromosome()))));
        overallOrStatement.add(Restrictions.conjunction().add(segmentStartGreaterThanLow(chromosomeCoordinateLow))
                .add(segmentStartLessThanHigh(chromosomeCoordinateHigh)).add(
                        chromosomeNumberExpression(Cai2Util.getInternalChromosomeNumber(
                                geneLocation.getLocation().getChromosome()))));
    }
    segmentDataCrit.add(overallOrStatement);

}

/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings(UNCHECKED) // Hibernate operations are untyped
public List<SegmentData> findMatchingSegmentDatasByLocation(List<SegmentData> segmentDatasToMatch,
        Study study, Platform platform) {
    Criteria segmentDataCrit = getCurrentSession().createCriteria(SegmentData.class);
    Criteria arrayDataCrit = segmentDataCrit.createCriteria("arrayData");
    Criteria reporterListsCrit = arrayDataCrit.createCriteria("reporterLists");
    reporterListsCrit.add(Restrictions.eq(PLATFORM_ASSOCIATION, platform));
    arrayDataCrit.add(Restrictions.eq(STUDY_ASSOCIATION, study));
    Junction overallOrStatement = Restrictions.disjunction();
    for (SegmentData segmentData : segmentDatasToMatch) {
        ChromosomalLocation location = segmentData.getLocation();
        overallOrStatement.add(Restrictions.conjunction().
                add(Restrictions.eq("Location.startPosition", location.getStartPosition())).
                add(Restrictions.eq("Location.endPosition", location.getEndPosition())));
    }
    segmentDataCrit.add(overallOrStatement);
    return segmentDataCrit.list();
}

private static boolean applyCategoryCriterion(Object criteriaJunction, CategoryCriterion categoryCriterion) {
    Criterion restriction = getCategoryCriterionRestriction(categoryCriterion);
    if (restriction != null) {
        if (criteriaJunction instanceof Criteria) {
            ((Criteria) criteriaJunction).add(restriction);
            return true;
        } else if (criteriaJunction instanceof Junction) {
            ((Junction) criteriaJunction).add(restriction);
            return true;
        }
    }
    return false;
}

private static void applyCategoryCriterions(Criteria criteria, Junction junction, CategoryCriterion... categoryCriterions) {
    if (criteria != null && junction != null && categoryCriterions != null) {
        if (categoryCriterions.length > 0) {
            boolean applied = false;
            for (int i = 0; i < categoryCriterions.length; i++) {
                applied |= applyCategoryCriterion(junction, categoryCriterions[i]);
            }
            if (applied) {
                criteria.add(junction);
            }
        }
    }
}

private Criterion createCriterion(CriteriaWrapper crit, AndOrPredicate pred,
        String contextAlias) {
    Operator op = pred.getOperator();
    Junction junction = (op == Operator.And) ? Restrictions.conjunction()
            : Restrictions.disjunction();

    for (Predicate subPred : pred.getPredicates()) {
        Criterion cr = toCriterion(crit, subPred, contextAlias);
        junction.add(cr);
    }

    return junction;
}

@Override
public void visitAllComplete(final AllRestriction restriction) {
    final int restrictionSize = restriction.getRestrictions().size();
    final int criterionSize = m_criterions.size();
    if (criterionSize < restrictionSize) {
        throw new IllegalStateException("AllRestriction with " + restrictionSize + " entries encountered, but we only have " + criterionSize + " criterions!");
    }
    final List<Criterion> criterions = m_criterions.subList(criterionSize - restrictionSize, criterionSize);
    final Junction j = org.hibernate.criterion.Restrictions.conjunction();
    for (final Criterion crit : criterions) {
        j.add(crit);
    }
    criterions.clear();
    m_criterions.add(j);
}

@Override
public void visitAnyComplete(final AnyRestriction restriction) {
    final int restrictionSize = restriction.getRestrictions().size();
    final int criterionSize = m_criterions.size();
    if (criterionSize < restrictionSize) {
        throw new IllegalStateException("AllRestriction with " + restrictionSize + " entries encountered, but we only have " + criterionSize + " criterions!");
    }
    final List<Criterion> criterions = m_criterions.subList(criterionSize - restrictionSize, criterionSize);
    final Junction j = org.hibernate.criterion.Restrictions.disjunction();
    for (final Criterion crit : criterions) {
        j.add(crit);
    }
    criterions.clear();
    m_criterions.add(j);
}

/**
 * Get the junction used in function queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getFunctionJunction(AdvancedSampleSearchBean searchBean,
        DetachedCriteria crit) throws Exception {
    // if AND and more than one query per type, don't use junction
    if (searchBean.getCompositionLogicalOperator().equals("and")
            && searchBean.getFuncCount() > 1) {
        return null;
    }
    Disjunction compDisjunction = Restrictions.disjunction();
    Conjunction compConjunction = Restrictions.conjunction();
    for (CompositionQueryBean compQuery : searchBean
            .getCompositionQueries()) {
        // function
        if (compQuery.getCompositionType().equals("function")) {
            Criterion funcCrit = this.getFunctionCriterion(compQuery, "",
                    "");
            if (funcCrit != null) {
                compDisjunction.add(funcCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getFuncCount() == 1) {
                    compConjunction.add(funcCrit);
                }
            }
        }
    }
    // default to or if only one query
    Junction junction = (searchBean.getCompositionLogicalOperator().equals(
            "or") || searchBean.getCompositionQueries().size() == 1) ? compDisjunction
            : compConjunction;
    return junction;
}

/**
 * Get the junction used in nanomaterial entity queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getNanomaterialEntityJunction(
        AdvancedSampleSearchBean searchBean, DetachedCriteria crit)
        throws Exception {
    // if AND and more than one query per type, don't use junction
    if (searchBean.getCompositionLogicalOperator().equals("and")
            && searchBean.getNanoEntityCount() > 1) {
        return null;
    }
    Disjunction compDisjunction = Restrictions.disjunction();
    Conjunction compConjunction = Restrictions.conjunction();
    for (CompositionQueryBean compQuery : searchBean
            .getCompositionQueries()) {
        // nanomaterial entity
        if (compQuery.getCompositionType().equals("nanomaterial entity")) {
            Criterion nanoEntityCrit = getNanomaterialEntityCriterion(
                    compQuery, "");
            if (nanoEntityCrit != null) {
                compDisjunction.add(nanoEntityCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getNanoEntityCount() == 1) {
                    compConjunction.add(nanoEntityCrit);
                }
            }
        }
    }
    // default to or if only one query
    Junction junction = (searchBean.getCompositionLogicalOperator().equals(
            "or") || searchBean.getCompositionQueries().size() == 1) ? compDisjunction
            : compConjunction;
    return junction;
}

/**
 * Get the junction used in functionalizing entity queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getFunctionalizingEntityJunction(
        AdvancedSampleSearchBean searchBean, DetachedCriteria crit)
        throws Exception {
    // if AND and more than one query per type, don't use junction
    if (searchBean.getCompositionLogicalOperator().equals("and")
            && searchBean.getFuncEntityCount() > 1) {
        return null;
    }
    Disjunction compDisjunction = Restrictions.disjunction();
    Conjunction compConjunction = Restrictions.conjunction();
    for (CompositionQueryBean compQuery : searchBean
            .getCompositionQueries()) {
        // functionalizing entity
        if (compQuery.getCompositionType().equals("functionalizing entity")) {
            Criterion funcEntityCrit = getFunctionalizingEntityCriterion(
                    compQuery, "");
            if (funcEntityCrit != null) {
                compDisjunction.add(funcEntityCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getFuncEntityCount() == 1) {
                    compConjunction.add(funcEntityCrit);
                }
            }
        }
    }
    // default to or if only one query
    Junction junction = (searchBean.getCompositionLogicalOperator().equals(
            "or") || searchBean.getCompositionQueries().size() == 1) ? compDisjunction
            : compConjunction;
    return junction;
}

/**
 * Get the sample disjunction used in sample queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getSampleJunction(AdvancedSampleSearchBean searchBean)
        throws Exception {
    // if there are more than one POC query in AND, don't use junction.
    if (searchBean.getSampleLogicalOperator().equals("and")
            && searchBean.getPocCount() > 1) {
        return null;
    }
    Disjunction sampleDisjunction = Restrictions.disjunction();
    Conjunction sampleConjunction = Restrictions.conjunction();
    for (SampleQueryBean query : searchBean.getSampleQueries()) {
        if (query.getNameType().equals("sample name")) {
            Criterion sampleNameCrit = getSampleNameCriterion(query);
            if (sampleNameCrit != null) {
                sampleDisjunction.add(sampleNameCrit);
                sampleConjunction.add(sampleNameCrit);
            }
        }
        if (query.getNameType().equals("point of contact name")) {
            Disjunction pocDisjunction = getPointOfContactDisjunction(
                    searchBean, "poc.", "otherPOC.");
            if (pocDisjunction != null) {
                sampleDisjunction.add(pocDisjunction);
                if (searchBean.getPocCount() == 1) {
                    sampleConjunction.add(pocDisjunction);
                }
            }
        }
    }
    Junction junction = (searchBean.getSampleLogicalOperator().equals("or") || searchBean
            .getSampleQueries().size() == 1) ? sampleDisjunction
            : sampleConjunction;
    return junction;
}

/**
 * Set the DetachedCriteria for sample queries
 * 
 * @param searchBean
 * @param crit
 * @throws Exception
 */
private void setSampleCriteria(AdvancedSampleSearchBean searchBean,
        DetachedCriteria crit) throws Exception {
    if (searchBean.getSampleQueries().isEmpty()) {
        return;
    }
    // join POC
    if (searchBean.getHasPOC()) {
        crit.createAlias("primaryPointOfContact", "poc");
        crit.createAlias("poc.organization", "organization");
        crit.createAlias("otherPointOfContactCollection", "otherPOC",
                CriteriaSpecification.LEFT_JOIN);
        crit.createAlias("otherPOC.organization", "otherOrg",
                CriteriaSpecification.LEFT_JOIN);
    }
    Junction junction = getSampleJunction(searchBean);
    if (junction != null) {
        crit.add(junction);
    }
    // more than one POC and AND
    else {
        crit.add(getSampleNameJunction(searchBean));
        for (SampleQueryBean query : searchBean.getSampleQueries()) {
            if (query.getNameType().equals("point of contact name")) {
                DetachedCriteria subCrit = getPointOfContactSubquery(query,
                        "poc.", "otherPOC.", "id");
                crit.add(Subqueries.exists(subCrit));
            }
        }
    }
}

/**
 * @param criterion
 * @see #visit(edu.utah.further.core.data.search.JunctionCriterionImpl)
 */
public void visitJunction()
{
    final SearchType searchType = criterion.getSearchType();
    switch (searchType)
    {
        case CONJUNCTION:
        {
            result = Restrictions.conjunction();
            break;
        }

        case DISJUNCTION:
        {
            result = Restrictions.disjunction();
            break;
        }

        default:
        {
            throw new BusinessRuleException(unsupportedMessage(searchType));
        }
    }

    // Add junction arguments
    for (final Criterion c : convertedCriteria)
    {
        ((Junction) result).add(c);
    }
}

private void addAnnotationCriterionValues(Criteria c, Junction junction, Set<String> values,
        String assocPath, String alias) {
    if (!values.isEmpty()) {
        c.createAlias(assocPath, alias);
        junction.add(Restrictions.in(alias + ".value", values));
    }
}

@Test
public void or() {
    Criterion o1 = Restrictions.eq(property, value);
    Criterion o2 = Restrictions.in(property, values);
    Criterion o3 = Restrictions.lt(property, value);
    Junction expected = Restrictions.disjunction().add(o1).add(o2).add(o3);
    assertEquivalent(expected, translator.or(o1, o2, o3));
}

@Test
public void and() {
    Criterion o1 = Restrictions.eq(property, value);
    Criterion o2 = Restrictions.in(property, values);
    Criterion o3 = Restrictions.lt(property, value);
    Junction expected = Restrictions.conjunction().add(o1).add(o2).add(o3);
    assertEquivalent(expected, translator.and(o1, o2, o3));
}

@Override
public void visitAllComplete(final AllRestriction restriction) {
    final int restrictionSize = restriction.getRestrictions().size();
    final int criterionSize = m_criterions.size();
    if (criterionSize < restrictionSize) {
        throw new IllegalStateException("AllRestriction with " + restrictionSize + " entries encountered, but we only have " + criterionSize + " criterions!");
    }
    final List<Criterion> criterions = m_criterions.subList(criterionSize - restrictionSize, criterionSize);
    final Junction j = org.hibernate.criterion.Restrictions.conjunction();
    for (final Criterion crit : criterions) {
        j.add(crit);
    }
    criterions.clear();
    m_criterions.add(j);
}

@Override
public void visitAnyComplete(final AnyRestriction restriction) {
    final int restrictionSize = restriction.getRestrictions().size();
    final int criterionSize = m_criterions.size();
    if (criterionSize < restrictionSize) {
        throw new IllegalStateException("AllRestriction with " + restrictionSize + " entries encountered, but we only have " + criterionSize + " criterions!");
    }
    final List<Criterion> criterions = m_criterions.subList(criterionSize - restrictionSize, criterionSize);
    final Junction j = org.hibernate.criterion.Restrictions.disjunction();
    for (final Criterion crit : criterions) {
        j.add(crit);
    }
    criterions.clear();
    m_criterions.add(j);
}

/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings(UNCHECKED) // Hibernate operations are untyped
public List<Gene> findGenesByLocation(String chromosome, Integer startPosition, Integer endPosition,
        GenomeBuildVersionEnum genomeBuildVersion) {
    String locStartPosition = "location.startPosition";
    String locEndPosition = "location.endPosition";
    Criteria geneLocationCriteria = getCurrentSession().createCriteria(GeneChromosomalLocation.class);
    // (gene.startPos <= startPosition && gene.endPos >= startPosition)
    //  || (gene.startPos >= lowerInput  && gene.startPos <= higherInput)
    Junction overallOrStatement = Restrictions.disjunction();
    overallOrStatement.add(Restrictions.conjunction().add(Restrictions.le(locStartPosition, startPosition))
            .add(Restrictions.ge(locEndPosition, startPosition)));
    overallOrStatement.add(Restrictions.conjunction().add(Restrictions.ge(locStartPosition, startPosition)).add(
            Restrictions.le(locStartPosition, endPosition)));
    geneLocationCriteria.add(overallOrStatement);
    geneLocationCriteria.add(getChromosomeRestriction(chromosome));
    geneLocationCriteria.createCriteria("geneLocationConfiguration").
        add(Restrictions.eq("genomeBuildVersion", genomeBuildVersion));
    geneLocationCriteria.setProjection(Projections.property("geneSymbol"));
    List<String> geneSymbols = geneLocationCriteria.list();
    return geneSymbols.isEmpty() ? new ArrayList<Gene>()
            : getCurrentSession().createCriteria(Gene.class).setProjection(
                    Projections.distinct(Projections.property(SYMBOL_ATTRIBUTE))).
                    add(Restrictions.in(SYMBOL_ATTRIBUTE, geneSymbols)).
                    addOrder(Order.asc(SYMBOL_ATTRIBUTE)).list();
}

/**
 * Complete criteria with translations.
 *
 * @param currentCriteria
 *     the current criteria
 * @param translationsPath
 *     the translations path
 * @param translationsAlias
 *     the translations alias
 * @param property
 *     the property
 * @param propertyDescriptor
 *     the property descriptor
 * @param prefixedProperty
 *     the prefixed property
 * @param locale
 *     the locale
 * @param componentDescriptor
 *     the component descriptor
 * @param queryComponent
 *     the query component
 * @param context
 *     the context
 */
@SuppressWarnings("unchecked")
protected void completeCriteriaWithTranslations(DetachedCriteria currentCriteria, String translationsPath,
                                                String translationsAlias, Map.Entry<String, Object> property,
                                                IPropertyDescriptor propertyDescriptor, String prefixedProperty,
                                                Locale locale, IComponentDescriptor<?> componentDescriptor,
                                                IQueryComponent queryComponent, Map<String, Object> context) {
  if (propertyDescriptor instanceof IStringPropertyDescriptor && ((IStringPropertyDescriptor) propertyDescriptor)
      .isTranslatable()) {
    String nlsOrRawValue = null;
    String nlsValue = (String) property.getValue();
    String barePropertyName = property.getKey();
    if (property.getKey().endsWith(IComponentDescriptor.NLS_SUFFIX)) {
      barePropertyName = barePropertyName.substring(0,
          barePropertyName.length() - IComponentDescriptor.NLS_SUFFIX.length());
    } else {
      nlsOrRawValue = nlsValue;
    }
    if (nlsValue != null) {
      Junction translationRestriction = Restrictions.conjunction();
      translationRestriction.add(createStringRestriction(
          ((ICollectionPropertyDescriptor<IPropertyTranslation>) componentDescriptor.getPropertyDescriptor(
              translationsPath)).getCollectionDescriptor().getElementDescriptor().getPropertyDescriptor(
              IPropertyTranslation.TRANSLATED_VALUE), translationsAlias + "." + IPropertyTranslation.TRANSLATED_VALUE,
          nlsValue, componentDescriptor, queryComponent, context));
      String languagePath = translationsAlias + "." + IPropertyTranslation.LANGUAGE;
      translationRestriction.add(Restrictions.eq(languagePath, locale.getLanguage()));
      translationRestriction.add(Restrictions.eq(translationsAlias + "." + IPropertyTranslation.PROPERTY_NAME,
          barePropertyName));

      Junction disjunction = Restrictions.disjunction();
      disjunction.add(translationRestriction);
      if (nlsOrRawValue != null) {
        Junction rawValueRestriction = Restrictions.conjunction();
        rawValueRestriction.add(Restrictions.disjunction().add(Restrictions.isNull(languagePath)).add(Restrictions.ne(
            languagePath, locale.getLanguage())));
        String rawPropertyName = barePropertyName + IComponentDescriptor.RAW_SUFFIX;
        rawValueRestriction.add(createStringRestriction(componentDescriptor.getPropertyDescriptor(rawPropertyName),
            rawPropertyName, nlsOrRawValue, componentDescriptor, queryComponent, context));
        disjunction.add(rawValueRestriction);
      }
      currentCriteria.add(disjunction);
    }
  } else {
    completeCriteria(currentCriteria, createStringRestriction(propertyDescriptor, prefixedProperty,
        (String) property.getValue(), componentDescriptor, queryComponent, context));
  }
}

/**
 * Creates a string based restriction.
 *
 * @param propertyDescriptor
 *     the property descriptor.
 * @param prefixedProperty
 *     the full path of the property.
 * @param propertyValue
 *     the string property value.
 * @param componentDescriptor
 *     the component descriptor
 * @param queryComponent
 *     the query component
 * @param context
 *     the context
 * @return the created criterion or null if no criterion necessary.
 */
protected Criterion createStringRestriction(IPropertyDescriptor propertyDescriptor, String prefixedProperty,
                                            String propertyValue, IComponentDescriptor<?> componentDescriptor,
                                            IQueryComponent queryComponent, Map<String, Object> context) {
  Junction disjunction = null;
  if (propertyValue.length() > 0) {
    String[] stringDisjunctions = propertyValue.split(IQueryComponent.DISJUNCT);
    disjunction = Restrictions.disjunction();
    for (String stringDisjunction : stringDisjunctions) {
      Junction conjunction = Restrictions.conjunction();
      String[] stringConjunctions = stringDisjunction.split(IQueryComponent.CONJUNCT);
      for (String stringConjunction : stringConjunctions) {
        String val = stringConjunction;
        if (val.length() > 0) {
          Criterion crit;
          boolean negate = false;
          if (val.startsWith(IQueryComponent.NOT_VAL)) {
            val = val.substring(1);
            negate = true;
          }
          if (IQueryComponent.NULL_VAL.equals(val)) {
            crit = Restrictions.isNull(prefixedProperty);
          } else {
            if (IEntity.ID.equals(propertyDescriptor.getName())
                || propertyDescriptor instanceof IEnumerationPropertyDescriptor) {
              crit = Restrictions.eq(prefixedProperty, val);
            } else {
              crit = createLikeRestriction(propertyDescriptor, prefixedProperty, val, componentDescriptor,
                  queryComponent, context);
            }
          }
          if (negate) {
            crit = Restrictions.not(crit);
          }
          conjunction.add(crit);
        }
      }
      disjunction.add(conjunction);
    }
  }
  return disjunction;
}

/**
 * Creates a criterion by processing a comparable query structure.
 *
 * @param path
 *     the path to the comparable property.
 * @param queryStructure
 *     the comparable query structure.
 * @param componentDescriptor
 *     the component descriptor
 * @param queryComponent
 *     the query component
 * @param context
 *     the context
 * @return the created criterion or null if no criterion necessary.
 */
protected Criterion createComparableQueryStructureRestriction(String path, ComparableQueryStructure queryStructure,
                                                              IComponentDescriptor<?> componentDescriptor,
                                                              IQueryComponent queryComponent,
                                                              Map<String, Object> context) {
  Junction queryStructureRestriction = null;
  if (queryStructure.isRestricting()) {
    queryStructureRestriction = Restrictions.conjunction();
    String comparator = queryStructure.getComparator();
    Object infValue = queryStructure.getInfValue();
    Object supValue = queryStructure.getSupValue();
    Object compareValue = infValue;
    if (compareValue == null) {
      compareValue = supValue;
    }
    switch (comparator) {
      case ComparableQueryStructureDescriptor.EQ:
        queryStructureRestriction.add(Restrictions.eq(path, compareValue));
        break;
      case ComparableQueryStructureDescriptor.GT:
        queryStructureRestriction.add(Restrictions.gt(path, compareValue));
        break;
      case ComparableQueryStructureDescriptor.GE:
        queryStructureRestriction.add(Restrictions.ge(path, compareValue));
        break;
      case ComparableQueryStructureDescriptor.LT:
        queryStructureRestriction.add(Restrictions.lt(path, compareValue));
        break;
      case ComparableQueryStructureDescriptor.LE:
        queryStructureRestriction.add(Restrictions.le(path, compareValue));
        break;
      case ComparableQueryStructureDescriptor.NU:
        queryStructureRestriction.add(Restrictions.isNull(path));
        break;
      case ComparableQueryStructureDescriptor.NN:
        queryStructureRestriction.add(Restrictions.isNotNull(path));
        break;
      case ComparableQueryStructureDescriptor.BE:
        if (infValue != null && supValue != null) {
          queryStructureRestriction.add(Restrictions.between(path, infValue, supValue));
        } else if (infValue != null) {
          queryStructureRestriction.add(Restrictions.ge(path, infValue));
        } else {
          queryStructureRestriction.add(Restrictions.le(path, supValue));
        }
        break;
      default:
        break;
    }
  }
  return queryStructureRestriction;
}

private static Junction buildQueryWithKeywords(List<Keyword> words, int target, boolean any) {
    final String[] targetColumns = {
            null, "TAG_NAME", "TITLE", "CONTENT", "this_.FRAGMENT_ID"
    };

    final String column = targetColumns[target];
    if (column == null) {
        throw new IllegalArgumentException();
    }

    final Junction junction = any ?
            Restrictions.disjunction() : Restrictions.conjunction();

for (SearchParams.Keyword w : words) {
    final Pair<String, Character> tmp = getPatternFromKeyword(w);
    final String pattern = tmp.getFirst();
    final char escapeChar = tmp.getSecond();
    String sql = null;

    if (w.isTrivial()) {
        if (w.isCaseSensitive()) {
                  sql = column + " like " + "'" + pattern + "'";
              }
              else {
                  sql = "lower(" + column + ") like " + "'" + pattern.toLowerCase() + "'";
              }
        if (escapeChar != 0) {
            sql += " escape '" + escapeChar + "'";
        }
          }
    else {
        if (w.isId()) {
            sql = column + " = " + pattern;
        }
        else if (w.isRegex()) {
            sql = column + " regexp " + "'" + pattern + "'";
        }
        else if (w.isWholeWord()) {
            if (w.isCaseSensitive()) {
                sql = column + " regexp " + "'\\b" + pattern + "\\b'";
            }
            else {
                sql = "lower(" + column + ") regexp " + "'\\b" + pattern.toLowerCase() + "\\b'";
            }
        }
        else if (w.isBeginningWith()) {
            if (w.isCaseSensitive()) {
                sql = column + " regexp " + "'\\b" + pattern + "'";
            }
            else {
                sql = "lower(" + column + ") regexp " + "'\\b" + pattern.toLowerCase() + "'";
            }
        }
        else if (w.isEndingWith()) {
            if (w.isCaseSensitive()) {
                sql = column + " regexp " + "'" + pattern + "\\b'";
            }
            else {
                sql = "lower(" + column + ") regexp " + "'" + pattern.toLowerCase() + "\\b'";
            }
        }
        else {
            throw new UnsupportedOperationException();
        }
    }

    if (w.isInverse()) {
        sql = "not " + sql;
    }

    // [TODO] research compatibility issues with other DBMS vendors
    junction.add(Restrictions.sqlRestriction(sql));
}

return junction;
  }

/**
 * Get the junction used in composition queries
 * 
 * @param searchBean
 * @param crit
 * @return
 * @throws Exception
 */
private Junction getCompositionJunction(
        AdvancedSampleSearchBean searchBean, DetachedCriteria crit)
        throws Exception {
    // if AND and more than one query per type, don't use junction
    if (searchBean.getCompositionLogicalOperator().equals("and")
            && searchBean.getFuncCount() > 1
            && searchBean.getNanoEntityCount() > 1
            && searchBean.getFuncEntityCount() > 1) {
        return null;
    }
    Disjunction compDisjunction = Restrictions.disjunction();
    Conjunction compConjunction = Restrictions.conjunction();
    for (CompositionQueryBean compQuery : searchBean
            .getCompositionQueries()) {
        // function
        if (compQuery.getCompositionType().equals("function")) {
            Criterion funcCrit = this.getFunctionCriterion(compQuery,
                    "inherentFunction.", "function.");
            if (funcCrit != null) {
                compDisjunction.add(funcCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getFuncCount() == 1) {
                    compConjunction.add(funcCrit);
                }
            }
        }
        // nanomaterial entity
        else if (compQuery.getCompositionType().equals(
                "nanomaterial entity")) {
            Criterion nanoEntityCrit = getNanomaterialEntityCriterion(
                    compQuery, "nanoEntity.");
            if (nanoEntityCrit != null) {
                compDisjunction.add(nanoEntityCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getNanoEntityCount() == 1) {
                    compConjunction.add(nanoEntityCrit);
                }
            }
        }
        // functionalizing entity
        else if (compQuery.getCompositionType().equals(
                "functionalizing entity")) {
            Criterion funcEntityCrit = getFunctionalizingEntityCriterion(
                    compQuery, "funcEntity.");
            if (funcEntityCrit != null) {
                compDisjunction.add(funcEntityCrit);
                // only add to conjunction if there is only one query for
                // the type
                if (searchBean.getFuncEntityCount() == 1) {
                    compConjunction.add(funcEntityCrit);
                }
            }
        }
    }
    // default to or if only one query
    Junction junction = (searchBean.getCompositionLogicalOperator().equals(
            "or") || searchBean.getCompositionQueries().size() == 1) ? compDisjunction
            : compConjunction;
    return junction;
}

/**
     * Set the DetachedCriteria used for composition queries
     * 
     * @param searchBean
     * @param crit
     * @throws Exception
     */
    private void setCompositionCriteriaBase(AdvancedSampleSearchBean searchBean,
            DetachedCriteria crit) throws Exception {
        if (searchBean.getCompositionQueries().isEmpty()) {
            return;
        }
        // composition queries
        crit.createAlias("sampleComposition", "comp",
                CriteriaSpecification.LEFT_JOIN);
        Boolean hasChemicalName = searchBean.getHasChemicalName();
        // join function
        if (searchBean.getHasFunction()) {
            crit.createAlias("comp.nanomaterialEntityCollection", "nanoEntity",
                    CriteriaSpecification.LEFT_JOIN);
            crit.createAlias("nanoEntity.composingElementCollection",
                    "compElement", CriteriaSpecification.LEFT_JOIN);
            crit.createAlias("compElement.inherentFunctionCollection",
                    "inherentFunction", CriteriaSpecification.LEFT_JOIN);
            crit.createAlias("comp.functionalizingEntityCollection",
                    "funcEntity", CriteriaSpecification.LEFT_JOIN);
            crit.createAlias("funcEntity.functionCollection", "function",
                    CriteriaSpecification.LEFT_JOIN);
        }
        // join nanomaterialEntity
        if (searchBean.getHasNanomaterial() && !searchBean.getHasFunction()) {
            crit.createAlias("comp.nanomaterialEntityCollection", "nanoEntity",
                    CriteriaSpecification.LEFT_JOIN);
            if (hasChemicalName) {
                crit.createAlias("nanoEntity.composingElementCollection",
                        "compElement", CriteriaSpecification.LEFT_JOIN);
            }
        }
        // join functionalizing entity
        if (searchBean.getHasAgentMaterial() && !searchBean.getHasFunction()) {
            crit.createAlias("comp.functionalizingEntityCollection",
                    "funcEntity", CriteriaSpecification.LEFT_JOIN);
        }
        Junction junction = getCompositionJunction(searchBean, crit);
        if (junction != null) {
            crit.add(junction);
        }
/*      if (searchBean.getNanoEntityCount() > 1) {
            setNanomaterialEntityAndCriteria(searchBean, crit, "id");
        }
        if (searchBean.getFuncEntityCount() > 1) {
            setFunctionalizingEntityAndCriteria(searchBean, crit, "id");
        }
        if (searchBean.getFuncCount() > 1) {
            setFunctionAndCriteria(searchBean, crit, "id");
        }  */
    }

/**
 * @param request
 * @return
 * @see edu.utah.further.core.chain.AbstractRequestHandler#process(edu.utah.further.core.api.chain.ChainRequest)
 */
@Override
public boolean process(final ChainRequest request)
{
    // Read input arguments
    final HibernateExecReq executionReq = new HibernateExecReq(request);
    final SessionFactory sessionFactory = executionReq.getSessionFactory();
    notNull(sessionFactory, "Expected SessionFactory");

    final Class<? extends PersistentEntity<?>> rootEntity = executionReq
            .getRootEntity();
    notNull(rootEntity, "Expected root entity class");

    // Read the search criteria's root entity meta data
    final List<Object> list = executionReq.getResult();
    final Object[] listArray = CollectionUtil.toArrayNullSafe(list);
    final ClassMetadata classMetadata = sessionFactory.getClassMetadata(rootEntity);
    final String identifierName = classMetadata.getIdentifierPropertyName();
    final Type identifierType = classMetadata.getIdentifierType();
    final int numTypes = listArray.length;
    final Type[] types = new Type[numTypes];
    for (int i = 0; i < numTypes; i++)
    {
        types[i] = identifierType;
    }

    // Build Hibernate criteria
    final GenericCriteria criteria = GenericCriteriaFactory.criteria(
            CriteriaType.CRITERIA, rootEntity, sessionFactory.getCurrentSession());
    if (identifierType.isComponentType())
    {
        final String sqlInClause = HibernateUtil.sqlRestrictionCompositeIn(
                rootEntity, sessionFactory, numTypes);
        criteria.add(Restrictions.sqlRestriction(sqlInClause, listArray, types));
    }
    else
    {
        final int size = list.size();
        if (size > MAX_IN)
        {
            // Create a disjunction of IN clauses. Add MAX_IN elements at a time to
            // each IN clause (except the last IN, whose size is size % MAX_IN).
            final Junction junction = Restrictions.disjunction();
            for (int i = 0; i < size; i += MAX_IN)
            {
                junction.add(Restrictions.in(THIS + identifierName,
                        list.subList(i, Math.max(size, MAX_IN + i))));
            }
            criteria.add(junction);
        }
        else
        {
            // Single chunk, add directly as a criterion without the junction trick
            criteria.add(Restrictions.in(THIS + identifierName, list));
        }

    }

    executionReq.setResult(criteria);
    return false;
}

/**
 * {@inheritDoc}
 */
@SuppressWarnings({ "unchecked", "PMD" })
public <T extends AbstractBioMaterial> List<T> searchByCriteria(PageSortParams<T> params,
        BiomaterialSearchCriteria criteria) {
    Criteria c = getCurrentSession().createCriteria(AbstractBioMaterial.class);

    if (criteria.getExperiment() != null) {
        c.add(Restrictions.eq("experiment", criteria.getExperiment()));
    }

    if (!criteria.getNames().isEmpty()) {
        c.add(Restrictions.in("name", criteria.getNames()));
    }

    if (!criteria.getExternalIds().isEmpty()) {
        c.add(Restrictions.in("externalId", criteria.getExternalIds()));
    }

    if (!criteria.getBiomaterialClasses().isEmpty()) {
        // unfortunately due to a hibernate bug we have to explicitly specify discriminators
        // rather than being able to use classnames
        Set<String> discriminators = new HashSet<String>();
        for (Class<? extends AbstractBioMaterial> bmClass : criteria.getBiomaterialClasses()) {
            discriminators.add(getDiscriminator(bmClass));
        }
        c.add(Restrictions.in("class", discriminators));
    }

    if (!criteria.getAnnotationCriterions().isEmpty()) {
        Set<String> diseaseStates = new HashSet<String>();
        Set<String> tissueSites = new HashSet<String>();
        Set<String> cellTypes = new HashSet<String>();
        Set<String> materialTypes = new HashSet<String>();
        for (AnnotationCriterion ac : criteria.getAnnotationCriterions()) {
            if (ac.getCategory().getName()
                    .equals(ExperimentOntologyCategory.DISEASE_STATE.getCategoryName())) {
                diseaseStates.add(ac.getValue());
            } else if (ac.getCategory().getName()
                    .equals(ExperimentOntologyCategory.CELL_TYPE.getCategoryName())) {
                cellTypes.add(ac.getValue());
            } else if (ac.getCategory().getName()
                    .equals(ExperimentOntologyCategory.MATERIAL_TYPE.getCategoryName())) {
                materialTypes.add(ac.getValue());
            } else if (ac.getCategory().getName()
                    .equals(ExperimentOntologyCategory.ORGANISM_PART.getCategoryName())) {
                tissueSites.add(ac.getValue());
            }
        }

        if (!diseaseStates.isEmpty() || !tissueSites.isEmpty() || !cellTypes.isEmpty()
                || !materialTypes.isEmpty()) {
            Junction and = Restrictions.conjunction();
            addAnnotationCriterionValues(c, and, diseaseStates, "diseaseState", "ds");
            addAnnotationCriterionValues(c, and, tissueSites, "tissueSite", "ts");
            addAnnotationCriterionValues(c, and, materialTypes, "materialType", "mt");
            addAnnotationCriterionValues(c, and, cellTypes, "cellType", "ct");
            c.add(and);
        }
    }

    c.setFirstResult(params.getIndex());
    if (params.getPageSize() > 0) {
        c.setMaxResults(params.getPageSize());
    }
    c.addOrder(toOrder(params));
    return c.list();
}