import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
Sort convertToSort(JsonArray sortKeys) {
    if (sortKeys == null || sortKeys.size() == 0)
        return null;
    SortField[] sortFields = new SortField[sortKeys.size()];
    for (int i = 0; i < sortKeys.size(); i++) {
        JsonObject sortKey = sortKeys.getJsonObject(i);
        String sortBy = sortKey.getString("sortBy");
        boolean sortDescending = sortKey.getBoolean("sortDescending", false);
        String core = sortKey.getString("core", null);
        SortField field;
        if (sortBy.equals(SORT_ON_SCORE))
            field = new SortField(null, SortField.Type.SCORE, !sortDescending);
        else {
            Type type = typeForSortField(sortKey.getString("type"));
            if (core == null || core.equals(coreName))
                field = new SortField(sortBy, type, sortDescending);
            else
                field = new JoinSortField(sortBy, type, sortDescending, core);
            Object missingValue = missingSortValue(sortKey, type);
            if (missingValue != null)
                field.setMissingValue(missingValue);
        }
        sortFields[i] = field;
    }
    return new Sort(sortFields);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
private Object missingSortValue(JsonObject sortKey, Type type) {
    JsonValue missingValue = sortKey.getOrDefault("missingValue", null);
    if (missingValue == null)
        return null;
    if (missingValue instanceof JsonString) {
        if (((JsonString) missingValue).getString().equals("STRING_FIRST"))
            return SortField.STRING_FIRST;
        else if (((JsonString) missingValue).getString().equals("STRING_LAST"))
            return SortField.STRING_LAST;
    } else {
        switch (type) {
            case INT:
                return ((JsonNumber) missingValue).intValue();
            case LONG:
                return ((JsonNumber) missingValue).longValue();
            case DOUBLE:
                return ((JsonNumber) missingValue).doubleValue();
            default:
                break;
        }
    }
    return null;
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/**
    * Finds the top n hits from whole Index where all results are after a
    * previous result (after)
    * 
    * @param after
    *            the last doc from previous search
    * @param nDocs
    *            nb of elements to retrieve in total
    * @return
    */
   public BrowseAllDocsResponse browseAllDocs(ScoreDoc after, int nDocs) {
List<String> listOfDocReferences = new ArrayList<String>();
IndexSearcher searcher = null;
try {
    searcher = iaviewSearcherManager.acquire();

    TopDocs topDocs = searcher.searchAfter(after, new MatchAllDocsQuery(), nDocs, new Sort(new SortField(null,
	    Type.DOC)));
    ScoreDoc scoreDoc = null;
    for (int i = 0; i < topDocs.scoreDocs.length; i++) {
	scoreDoc = topDocs.scoreDocs[i];
	Document document = searcher.doc(scoreDoc.doc,
		new HashSet<String>(Arrays.asList(InformationAssetViewFields.DOCREFERENCE.toString())));
	String docReferenceFromLuceneDocument = LuceneTaxonomyMapper
		.getDocReferenceFromLuceneDocument(document);

	listOfDocReferences.add(docReferenceFromLuceneDocument);
    }
    return new BrowseAllDocsResponse(listOfDocReferences, scoreDoc);

} catch (IOException ioException) {
    throw new TaxonomyException(TaxonomyErrorType.LUCENE_IO_EXCEPTION, ioException);
} finally {
    LuceneHelperTools.releaseSearcherManagerQuietly(iaviewSearcherManager, searcher);
}
   }
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.LONG, reverse);
  }
  return new SortField(getFieldName(), Type.LONG);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.STRING, reverse);
  }
  return new SortField(getFieldName(), Type.STRING);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.DOUBLE, reverse);
  }
  return new SortField(getFieldName(), Type.DOUBLE);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.INT, reverse);
  }
  return new SortField(getFieldName(), Type.INT);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Override
public SortField getSortField(boolean reverse) {
  if (reverse) {
    return new SortField(getFieldName(), Type.FLOAT, reverse);
  }
  return new SortField(getFieldName(), Type.FLOAT);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@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();
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
public FieldComparator<?> getComparator(String field, Type type, boolean reverse, final int numHits, final int sortPos, Object missingValue) {
    switch(type) {
        case STRING:
            return new JoinTermOrdValComparator(numHits, field, missingValue == SortField.STRING_LAST, this);
        case INT:
            return new JoinIntComparator(numHits, field, (Integer) missingValue, this);
        case DOUBLE:
            return new JoinDoubleComparator(numHits, field, (Double) missingValue, this);
        default:
            throw new IllegalStateException("Illegal join sort type: " + type);
    }
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
private SortField.Type typeForSortField(String type) {
    switch (type) {
        case "String":
            return SortField.Type.STRING;
        case "Int":
            return SortField.Type.INT;
        case "Double":
            return SortField.Type.DOUBLE;
        case "Long":
            return SortField.Type.LONG;
    }
    return null;
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
@Test
public void testEmptyIndex() throws Exception {
  // LUCENE-5045: make sure DrillSideways works with an empty index
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  writer = new RandomIndexWriter(random(), dir);
  taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);
  IndexSearcher searcher = newSearcher(writer.getReader());
  writer.close();
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);
  taxoWriter.close();

  // Count "Author"
  FacetSearchParams fsp = new FacetSearchParams(new CountFacetRequest(new CategoryPath("Author"), 10));

  DrillSideways ds = new DrillSideways(searcher, taxoReader);
  DrillDownQuery ddq = new DrillDownQuery(fsp.indexingParams, new MatchAllDocsQuery());
  ddq.add(new CategoryPath("Author", "Lisa"));
  
  DrillSidewaysResult r = ds.search(null, ddq, 10, fsp); // this used to fail on IllegalArgEx
  assertEquals(0, r.hits.totalHits);

  r = ds.search(ddq, null, null, 10, new Sort(new SortField("foo", Type.INT)), false, false, fsp); // this used to fail on IllegalArgEx
  assertEquals(0, r.hits.totalHits);
  
  IOUtils.close(searcher.getIndexReader(), taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.LONG, reverse);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.STRING, reverse);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.FLOAT, reverse);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.INT, reverse);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public SortField sortField(String field, boolean reverse) {
    return new SortField(field, Type.DOUBLE, reverse);
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
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;
    try {
      sorts = QueryParsing.parseSort(input.toString(), req).getSort();
    } catch (RuntimeException e) {
      throw new RuntimeException("Failed to parse sort: " + input, e);
    }
    assertEquals("parsed sorts had unexpected size", 
                 names.length, sorts.length);
    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)) {

        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());
      }
    }
  }
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
Lucene(Type fieldType) {
	this.fieldType = fieldType;
}
 

import org.apache.lucene.search.SortField.Type; //导入依赖的package包/类
/**
 * Creates a new instance with all properties.
 * @param id the id of the {@link ESortField}.
 * @param name the name of the {@link Field} in the {@link News} {@link Document} to which
 * 			will be sorted.
 * @param type the {@link Type} of the field set in {@link #name()}.
 * @param defaultOrder the default {@link ESortOrder} for this field.
 */
private ESortField(final int id, final String name, final Type type, final ESortOrder defaultOrder) {
	this.id = id;
	this.name = name;
	this.type = type;
	this.defaultOrder = defaultOrder;
}