Java QueryParserBase类代码示例

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Returns the identity id.
 *
 * @param identity the identity
 * @return the identity id
 * @throws Exception the exception
 */
public long getIdentityId(Identity identity) throws Exception {

  // Set up the "full text query"
  final List<Long> results = handler.getIdResults(null, null,
      Branch.ROOT, "identityCode:\""
          + QueryParserBase.escape(identity.getIdentityCode()) + "\"",
      null, identity.getClass(), null, new int[1], manager);

  if (results.isEmpty()) {
    return -1L;
  }

  if (results.size() > 1) {
    throw new Exception("Error: identity code returned more than one id: "
        + identity.getIdentityCode());
  }

  return results.get(0);
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public WorkflowConfig getWorkflowConfig(Project project, String type)
  throws Exception {
  Logger.getLogger(getClass())
      .debug("Workflow Service - get project workflow config "
          + project.getId() + ", " + type);
  final SearchHandler searchHandler = getSearchHandler(null);
  final int[] totalCt = new int[1];

  final List<WorkflowConfigJpa> results =
      searchHandler.getQueryResults(null, null, "",
          composeQuery(project, "") + " AND type:\""
              + QueryParserBase.escape(type) + "\"",
          "", WorkflowConfigJpa.class, null, totalCt, manager);

  if (results.size() == 0) {
    return null;
  } else if (results.size() == 1) {
    return results.get(0);
  } else {
    throw new Exception(
        "Unexpected number of workflow configs for project and type "
            + project.getId() + "," + type);
  }

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@SuppressWarnings({
    "rawtypes", "unchecked"
})
@Override
public SubsetMemberList findAtomSubsetMembers(String subsetId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {
  Logger.getLogger(getClass())
      .debug("Content Service - find atom subset members " + subsetId + "/"
          + terminology + "/" + version + ", query=" + query);
  // Prepare the query string

  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (subsetId != null && !subsetId.isEmpty()) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("subsetTerminologyId:" + QueryParserBase.escape(subsetId));
  }
  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final SubsetMemberList list = new SubsetMemberListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "memberNameSort",
      AtomSubsetMemberJpa.class, pfs, totalCt, manager));
  list.setTotalCount(totalCt[0]);
  return list;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@SuppressWarnings({
    "unchecked", "rawtypes"
})
@Override
public SubsetMemberList findConceptSubsetMembers(String subsetId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {
  Logger.getLogger(getClass())
      .debug("Content Service - find concept subset members " + subsetId + "/"
          + terminology + "/" + version + ", query=" + query);
  // Prepare the query string

  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (subsetId != null && !subsetId.isEmpty()) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("subsetTerminologyId:" + QueryParserBase.escape(subsetId));
  }

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final SubsetMemberList list = new SubsetMemberListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "memberNameSort",
      ConceptSubsetMemberJpa.class, pfs, totalCt, manager));
  list.setTotalCount(totalCt[0]);

  return list;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find mappings for component helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param pfs the pfs
 * @return the mapping list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private MappingList findMappingsForComponentHelper(String terminologyId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs) throws Exception {

  if (terminologyId == null || terminologyId.isEmpty()) {
    throw new Exception("Terminology id is required");
  }

  final MappingList results = new MappingListJpa();

  // Prepare the query string
  final StringBuilder finalQuery = new StringBuilder();
  finalQuery.append(query == null ? "" : query);
  if (!finalQuery.toString().isEmpty()) {
    finalQuery.append(" AND ");
  }

  finalQuery.append("fromTerminologyId:"
      + QueryParserBase.escape(terminologyId) + " AND fromTerminology:"
      + terminology + " AND fromVersion:" + version);

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  // pass empty terminology/version because it's handled above
  results.setObjects((List) searchHandler.getQueryResults("", "", branch,
      finalQuery.toString(), "fromNameSort", MappingJpa.class, pfs, totalCt,
      manager));
  results.setTotalCount(totalCt[0]);

  for (final Mapping mapping : results.getObjects()) {
    getGraphResolutionHandler(terminology).resolve(mapping);
  }
  return results;

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Returns the query results.
 *
 * @param <T> the
 * @param query the query
 * @param clazz the clazz
 * @param pfs the pfs
 * @param totalCt the total ct
 * @return the query results
 * @throws Exception the exception
 */
// TODO This should no longer exist, use search handlers from RootServiceJpa
public <T> List<?> getQueryResults(final String query, final Class<T> clazz,
  final PfsParameter pfs, int[] totalCt) throws Exception {

  if (query == null || query.isEmpty()) {
    throw new Exception("Unexpected empty query.");
  }

  FullTextQuery fullTextQuery = null;
  try {
    fullTextQuery =
        IndexUtility.applyPfsToLuceneQuery(clazz, query, pfs, manager);
  } catch (ParseException e) {
    // If parse exception, try a literal query
    final StringBuilder escapedQuery = new StringBuilder();
    if (query != null && !query.isEmpty()) {
      escapedQuery.append(QueryParserBase.escape(query));
    }
    fullTextQuery = IndexUtility.applyPfsToLuceneQuery(clazz,
        escapedQuery.toString(), pfs, manager);
  }

  totalCt[0] = fullTextQuery.getResultSize();
  return fullTextQuery.getResultList();

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Compose clause.
 *
 * @param fieldName the field name
 * @param fieldValue the field value
 * @param escapeValue - whether the value can have characters that need to be
 *          escaped
 * @return the string
 * @throws Exception the exception
 */
public static String composeClause(String fieldName, String fieldValue,
  boolean escapeValue) throws Exception {

  if (!ConfigUtility.isEmpty(fieldValue)) {
    if (escapeValue) {
      return fieldName + ":\"" + QueryParserBase.escape(fieldValue) + "\"";
    } else {
      return fieldName + ":" + fieldValue;
    }
  } else {
    return "NOT " + fieldName + ":[* TO *]";
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public void assertEscapedQueryEquals(String query, Analyzer a, String result)
  throws Exception {
  String escapedQuery = QueryParserBase.escape(query);
  if (!escapedQuery.equals(result)) {
    fail("Query /" + query + "/ yielded /" + escapedQuery
        + "/, expecting /" + result + "/");
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public QueryParser getParser(Analyzer a, Extensions extensions)
    throws Exception {
  if (a == null)
    a = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true);
  QueryParser qp = extensions == null ? new ExtendableQueryParser(
      TEST_VERSION_CURRENT, getDefaultField(), a) : new ExtendableQueryParser(
      TEST_VERSION_CURRENT, getDefaultField(), a, extensions);
  qp.setDefaultOperator(QueryParserBase.OR_OPERATOR);
  return qp;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public void testDefaultOperator() throws Exception {
  SQPTestingConfig qp = (SQPTestingConfig)getParserConfig(new MockAnalyzer(random()));
  // make sure OR is the default:
  assertEquals(QueryParserBase.OR_OPERATOR, qp.getDefaultOperator());
  setDefaultOperatorAND(qp);
  assertEquals(QueryParserBase.AND_OPERATOR, qp.getDefaultOperator());
  setDefaultOperatorOR(qp);
  assertEquals(QueryParserBase.OR_OPERATOR, qp.getDefaultOperator());
  
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public CommonQueryParserConfiguration getParserConfig(Analyzer a, Analyzer mtAnalyzer)
    throws Exception {
  if (a == null) {
    a = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true);
  }
  if (mtAnalyzer == null) {
    mtAnalyzer = new MockAnalyzer(random(), MockTokenizer.KEYWORD, true);
  }

  SQPTestingConfig qp = new SQPTestingConfig(getDefaultField(), a, mtAnalyzer);
  qp.setDefaultOperator(QueryParserBase.OR_OPERATOR);
  qp.setAnalyzeRangeTerms(true);
  return qp;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
public void assertEscapedQueryEquals(String query, Analyzer a, String result)
    throws Exception {
  String escapedQuery = QueryParserBase.escape(query);
  if (!escapedQuery.equals(result)) {
    fail("Query /" + query + "/ yielded /" + escapedQuery
        + "/, expecting /" + result + "/");
  }
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
@Override
public Query parse(QualityQuery qq) throws ParseException {
  QueryParser qp = queryParser.get();
  if (qp==null) {
    qp = new QueryParser(Version.LUCENE_CURRENT, indexField, new StandardAnalyzer(Version.LUCENE_CURRENT));
    queryParser.set(qp);
  }
  BooleanQuery bq = new BooleanQuery();
  for (int i = 0; i < qqNames.length; i++)
    bq.add(qp.parse(QueryParserBase.escape(qq.getValue(qqNames[i]))), BooleanClause.Occur.SHOULD);
  
  return bq;
}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find relationships for component helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param inverseFlag the inverse flag
 * @param pfs the pfs
 * @param clazz the clazz
 * @return the relationship list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private RelationshipList findRelationshipsForComponentHelper(
  String terminologyId, String terminology, String version, String branch,
  String query, boolean inverseFlag, PfsParameter pfs,
  Class<? extends Relationship> clazz) throws Exception {

  final RelationshipList results = new RelationshipListJpa();

  final List<String> clauses = new ArrayList<>();
  // Parts to combine
  // 1. query
  clauses.add(query);

  // escape special chars
  // 2. to/fromTerminologyId
  if (inverseFlag && !ConfigUtility.isEmpty(terminologyId)) {
    clauses.add("toTerminologyId:" + QueryParserBase.escape(terminologyId));
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(terminologyId)) {
    clauses.add("fromTerminologyId:" + QueryParserBase.escape(terminologyId));
  }

  // 3. to/fromTerminology
  if (inverseFlag && !ConfigUtility.isEmpty(terminology)) {
    clauses.add("toTerminology:" + terminology);
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(terminology)) {
    clauses.add("fromTerminology:" + terminology);
  }

  // r. to/fromVersion clause
  if (inverseFlag && !ConfigUtility.isEmpty(version)) {
    clauses.add("toVersion:" + version);
  }
  if (!inverseFlag && !ConfigUtility.isEmpty(version)) {
    clauses.add("fromVersion:" + version);
  }

  final String finalQuery = ConfigUtility.composeQuery("AND", clauses);

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  // pass empty terminology/version because it's handled above
  results.setObjects((List) searchHandler.getQueryResults("", "", branch,
      finalQuery, "toNameSort", clazz, pfs, totalCt, manager));
  results.setTotalCount(totalCt[0]);

  for (final Relationship<? extends ComponentInfo, ? extends ComponentInfo> rel : results
      .getObjects()) {
    getGraphResolutionHandler(terminology).resolve(rel);
  }
  return results;

}
 

import org.apache.lucene.queryparser.classic.QueryParserBase; //导入依赖的package包/类
/**
 * Find tree positions helper.
 *
 * @param terminologyId the terminology id
 * @param terminology the terminology
 * @param version the version
 * @param branch the branch
 * @param query the query
 * @param pfs the pfs
 * @param clazz the clazz
 * @return the tree position list
 * @throws Exception the exception
 */
@SuppressWarnings({
    "unchecked", "rawtypes"
})
private TreePositionList findTreePositionsHelper(String terminologyId,
  String terminology, String version, String branch, String query,
  PfsParameter pfs, Class<? extends TreePosition> clazz) throws Exception {

  // Prepare the query string
  final StringBuilder finalQuery = new StringBuilder();

  // add the query, if not null and not empty
  finalQuery.append(query == null || query.isEmpty() ? "" : query);
  if (terminologyId != null) {
    if (finalQuery.length() > 0) {
      finalQuery.append(" AND ");
    }
    finalQuery
        .append("nodeTerminologyId:" + QueryParserBase.escape(terminologyId));
  }

  final SearchHandler searchHandler = getSearchHandler(terminology);
  final int[] totalCt = new int[1];
  final TreePositionList list = new TreePositionListJpa();
  list.setObjects((List) searchHandler.getQueryResults(terminology, version,
      branch, finalQuery.toString(), "nodeNameSort", clazz, pfs, totalCt,
      manager));
  list.setTotalCount(totalCt[0]);

  // If the list has <30 entries and all are roman numerals
  // and the sortField is "nodeTerminologyId" then use a roman numeral sort
  // This is a hack for roman numeral sorted top-level hierarchies
  if (list.size() < 30 && pfs != null && pfs.getSortField() != null
      && pfs.getSortField().equals("nodeTerminologyId")) {
    boolean nonRomanFound = false;
    for (final TreePosition treepos : list.getObjects()) {
      if (!ConfigUtility
          .isRomanNumeral(treepos.getNode().getTerminologyId())) {
        nonRomanFound = true;
        break;
      }
    }
    if (!nonRomanFound) {
      Collections.sort(list.getObjects(), new Comparator<TreePosition>() {
        @Override
        public int compare(TreePosition o1, TreePosition o2) {
          try {
            return ConfigUtility.toArabic(o1.getNode().getTerminologyId())
                - ConfigUtility.toArabic(o2.getNode().getTerminologyId());
          } catch (Exception e) {
            // just return zero, don't worry about handling the error
            e.printStackTrace();
            return 0;
          }
        }

      });
    }
  }
  return list;

}