Esempio n. 1
0
 public static Map<String, Integer> termFrequencies(
     IndexSearcher indexSearcher,
     Query documentFilterQuery,
     String fieldName,
     String propName,
     String altName) {
   try {
     String luceneField = ComplexFieldUtil.propertyField(fieldName, propName, altName);
     Weight weight = indexSearcher.createNormalizedWeight(documentFilterQuery, false);
     Map<String, Integer> freq = new HashMap<>();
     IndexReader indexReader = indexSearcher.getIndexReader();
     for (LeafReaderContext arc : indexReader.leaves()) {
       if (weight == null) throw new RuntimeException("weight == null");
       if (arc == null) throw new RuntimeException("arc == null");
       if (arc.reader() == null) throw new RuntimeException("arc.reader() == null");
       Scorer scorer = weight.scorer(arc, arc.reader().getLiveDocs());
       if (scorer != null) {
         while (scorer.nextDoc() != DocIdSetIterator.NO_MORE_DOCS) {
           getFrequenciesFromTermVector(
               indexReader, scorer.docID() + arc.docBase, luceneField, freq);
         }
       }
     }
     return freq;
   } catch (IOException e) {
     throw ExUtil.wrapRuntimeException(e);
   }
 }
  public String optDesensitize(String value) {

    final String s = ComplexFieldUtil.SENSITIVE_ALT_NAME;
    final String i = ComplexFieldUtil.INSENSITIVE_ALT_NAME;
    final String ci = ComplexFieldUtil.CASE_INSENSITIVE_ALT_NAME;
    final String di = ComplexFieldUtil.DIACRITICS_INSENSITIVE_ALT_NAME;

    String[] parts = ComplexFieldUtil.getNameComponents(luceneField());

    String alt = parts.length >= 3 ? parts[2] : "";
    if (alt.equals(s)) {
      // Don't desensitize
      return value;
    }
    if (alt.equals(i)) {
      // Fully desensitize;
      return StringUtil.removeAccents(value).toLowerCase();
    }
    if (alt.equals(ci)) {
      // Only case-insensitive
      return value.toLowerCase();
    }
    if (alt.equals(di)) {
      // Only diacritics-insensitive
      return StringUtil.removeAccents(value);
    }

    // Unknown alternative; don't change value
    return value;
  }
  /**
   * Returns the correct current Lucene field name to use, based on the complex field name, property
   * name and list of alternatives.
   *
   * @param includeAlternative if true, also includes the default alternative at the end of the
   *     field name (alternatives determine stuff like case-/diacritics-sensitivity).
   * @return null if field, property or alternative not found; valid Lucene field name otherwise
   */
  public String luceneField(boolean includeAlternative) {

    // Determine available alternatives based on sensitivity preferences.
    String[] alternatives = includeAlternative ? getAlternatives() : null;

    if (searcher == null) {
      // Mostly for testing. Don't check, just combine field parts.
      if (alternatives == null || alternatives.length == 0)
        return ComplexFieldUtil.propertyField(fieldName, propName);
      return ComplexFieldUtil.propertyField(fieldName, propName, alternatives[0]);
    }

    // Find the field and the property.
    ComplexFieldDesc cfd = searcher.getIndexStructure().getComplexFieldDesc(fieldName);
    if (cfd == null) return null;

    if (ComplexFieldUtil.isBookkeepingSubfield(propName)) {
      // Not a property but a bookkeeping subfield (prob. starttag/endtag); ok, return it
      // (can be removed when old field naming scheme is removed)
      return ComplexFieldUtil.bookkeepingField(fieldName, propName);
    }

    // Find the property
    PropertyDesc pd = cfd.getPropertyDesc(propName);
    if (pd == null)
      return ComplexFieldUtil.propertyField(
          fieldName, propName); // doesn't exist? use plain property name

    if (alternatives == null || alternatives.length == 0) {
      // Don't use any alternatives
      return ComplexFieldUtil.propertyField(fieldName, propName);
    }

    // Find the first available alternative to use
    for (String alt : alternatives) {
      if (pd.hasAlternative(alt)) {
        // NOTE: is this loop necessary at all? getAlternatives() only
        //  returns available alternatives, so the first one should always
        //  be okay, right?
        return ComplexFieldUtil.propertyField(fieldName, propName, alt);
      }
    }

    // No valid alternative found. Use plain property.
    // NOTE: should never happen, and doesn't make sense anymore as there are
    // no 'plain properties' anymore.
    return ComplexFieldUtil.propertyField(fieldName, propName);
  }
 /**
  * Get a simple execution context for a field. Used for testing/debugging purposes.
  *
  * @param fieldName field to get an execution context for
  * @return the context
  */
 public static QueryExecutionContext getSimple(String fieldName) {
   String mainPropName = ComplexFieldUtil.getDefaultMainPropName();
   return new QueryExecutionContext(null, fieldName, mainPropName, false, false);
 }