org.apache.lucene.search.SortField.Type Java Examples

private static SortField getStringSortField(String fieldName, boolean reverse, boolean nullLast, boolean nullFirst) {
  SortField sortField = new SortField(fieldName, SortField.Type.STRING, reverse);
  
  // 4 cases:
  // missingFirst / forward: default lucene behavior
  // missingFirst / reverse: set sortMissingLast
  // missingLast  / forward: set sortMissingLast
  // missingLast  / reverse: default lucene behavior
  
  if (nullFirst && reverse) {
    sortField.setMissingValue(SortField.STRING_LAST);
  } else if (nullLast && !reverse) {
    sortField.setMissingValue(SortField.STRING_LAST);
  }
  return sortField;
}
 

@Test
public void testSimpleSearchPagingWithSorting() throws Exception {
  IndexReader reader = getReaderFlatScore(length);
  IndexSearcherCloseable searcher = getSearcher(reader);

  TotalHitsRef totalHitsRef = new TotalHitsRef();
  ProgressRef progressRef = new ProgressRef();

  printHeapSize();
  TermQuery query = new TermQuery(new Term("f1", "value"));
  Sort sort = new Sort(new SortField("index", Type.INT, true));
  IterablePaging paging = new IterablePaging(new AtomicBoolean(true), searcher, query, 100, null, null, false, sort,
      new DeepPagingCache());
  IterablePaging itPaging = paging.skipTo(90).gather(20).totalHits(totalHitsRef).progress(progressRef);
  BlurIterator<ScoreDoc, BlurException> iterator = itPaging.iterator();
  int position = 90;
  int searches = 1;
  while (iterator.hasNext()) {
    ScoreDoc sd = iterator.next();
    assertEquals(position, progressRef.currentHitPosition());
    assertEquals(searches, progressRef.searchesPerformed());
    System.out.println("time [" + progressRef.queryTime() + "] " + "total hits [" + totalHitsRef.totalHits() + "] "
        + "searches [" + progressRef.searchesPerformed() + "] " + "position [" + progressRef.currentHitPosition()
        + "] " + "doc id [" + sd.doc + "] " + "score [" + sd.score + "]");
    position++;
    if (position == 100) {
      searches++;
    }
  }
  printHeapSize();
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.FLOAT, reverse);
  }
  return new SortField(getFieldName(), Type.FLOAT);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.STRING, reverse);
  }
  return new SortField(getFieldName(), Type.STRING);
}
 

@Override
public SortField getSortField(boolean reverse) {
  final Type type = childField.getSortField(reverse).getType();
    return new ToParentBlockJoinSortField(childField.getName(), 
        type, reverse, 
        parentFilter, childFilter) {
      @SuppressWarnings("unchecked")
      @Override
      public FieldComparator<?> getComparator(int numHits, int sortPos) {
        final FieldComparator<?> comparator = super.getComparator(numHits, sortPos);
        return type ==Type.STRING ?  new BytesToStringComparator((FieldComparator<BytesRef>) comparator)
            : comparator;
      }
    };
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.INT, reverse);
  }
  return new SortField(getFieldName(), Type.INT);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.STRING, reverse);
  }
  return new SortField(getFieldName(), Type.STRING);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.DOUBLE, reverse);
  }
  return new SortField(getFieldName(), Type.DOUBLE);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.LONG, reverse);
  }
  return new SortField(getFieldName(), Type.LONG);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.STRING, reverse);
  }
  return new SortField(getFieldName(), Type.STRING);
}
 

@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.LONG, reverse);
  }
  return new SortField(getFieldName(), Type.LONG);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.LONG, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.DOUBLE, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

@Override
public SortField getSortField(boolean reverse) {
  return new SortField(field, Type.FLOAT, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.LONG, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.INT, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.FLOAT, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.LONG, reverse);
}
 

public void testRandomFieldNameSorts() throws Exception {
  SolrQueryRequest req = lrf.makeRequest("q", "*:*");

  final int iters = atLeast(5000);

  // infinite loop abort when trying to generate a non-blank sort "name"
  final int nonBlankAttempts = 37;

  for (int i = 0; i < iters; i++) {
    final StringBuilder input = new StringBuilder();
    final String[] names = new String[TestUtil.nextInt(r, 1, 10)];
    final boolean[] reverse = new boolean[names.length];
    for (int j = 0; j < names.length; j++) {
      names[j] = null;
      for (int k = 0; k < nonBlankAttempts && null == names[j]; k++) {
        names[j] = TestUtil.randomRealisticUnicodeString(r, 1, 100);

        // munge anything that might make this a function
        names[j] = names[j].replaceFirst("\\{","\\}\\{");
        names[j] = names[j].replaceFirst("\\(","\\)\\(");
        names[j] = names[j].replaceFirst("(\\\"|\\')","$1$1z");
        names[j] = names[j].replaceFirst("(\\d)","$1x");

        // eliminate pesky problem chars
        names[j] = names[j].replaceAll("\\p{Cntrl}|\\p{javaWhitespace}","");
        
        if (0 == names[j].length()) {
          names[j] = null;
        }
      }
      // with luck this bad, never go to vegas
      // alternatively: if (null == names[j]) names[j] = "never_go_to_vegas";
      assertNotNull("Unable to generate a (non-blank) names["+j+"] after "
                    + nonBlankAttempts + " attempts", names[j]);

      reverse[j] = r.nextBoolean();

      input.append(r.nextBoolean() ? " " : "");
      input.append(names[j]);
      input.append(" ");
      input.append(reverse[j] ? "desc," : "asc,");
    }
    input.deleteCharAt(input.length()-1);
    SortField[] sorts = null;
    List<SchemaField> fields = null;
    try {
      SortSpec spec = SortSpecParsing.parseSortSpec(input.toString(), req);
      sorts = spec.getSort().getSort();
      fields = spec.getSchemaFields();
    } catch (RuntimeException e) {
      throw new RuntimeException("Failed to parse sort: " + input, e);
    }
    assertEquals("parsed sorts had unexpected size", 
                 names.length, sorts.length);
    assertEquals("parsed sort schema fields had unexpected size", 
                 names.length, fields.size());
    for (int j = 0; j < names.length; j++) {
      assertEquals("sorts["+j+"] had unexpected reverse: " + input,
                   reverse[j], sorts[j].getReverse());

      final Type type = sorts[j].getType();

      if (Type.SCORE.equals(type)) {
        assertEquals("sorts["+j+"] is (unexpectedly) type score : " + input,
                     "score", names[j]);
      } else if (Type.DOC.equals(type)) {
        assertEquals("sorts["+j+"] is (unexpectedly) type doc : " + input,
                     "_docid_", names[j]);
      } else if (Type.CUSTOM.equals(type) || Type.REWRITEABLE.equals(type)) {
        log.error("names[{}] : {}", j, names[j]);
        log.error("sorts[{}] : {}", j, sorts[j]);
        fail("sorts["+j+"] resulted in a '" + type.toString()
             + "', either sort parsing code is broken, or func/query " 
             + "semantics have gotten broader and munging in this test "
             + "needs improved: " + input);

      } else {
        assertEquals("sorts["+j+"] ("+type.toString()+
                     ") had unexpected field in: " + input,
                     names[j], sorts[j].getField());
        assertEquals("fields["+j+"] ("+type.toString()+
                     ") had unexpected name in: " + input,
                     names[j], fields.get(j).getName());
      }
    }
  }
}
 

@Override
public SortField getSortField(boolean reverse) {
  return new SortField(field, Type.DOUBLE, reverse);
}
 

@Override
public SortField getSortField(boolean reverse) {
  return new SortField(field, Type.INT, reverse);
}
 

@Override
public SortField getSortField(boolean reverse) {
  return new SortField(field, Type.LONG, reverse);
}