org.apache.solr.common.util.NamedList java code examples

Refine search

List<String> collectionNames = listResponse.get("collections") == null ? collectionNames = new ArrayList<>() : (List<String>) listResponse.get("collections");
collectionNames = listResponse.get("collections") == null ? collectionNames = new ArrayList<>() : (List<String>) listResponse.get("collections");

@SuppressWarnings("unchecked")
public NamedList getStatistics()
{
  NamedList lst = new SimpleOrderedMap();
  lst.add("rollbacks", rollbackCommands.get());
  lst.add("adds", addCommands.get());
  lst.add("deletesById", deleteByIdCommands.get());
  lst.add("deletesByQuery", deleteByQueryCommands.get());
  lst.add("errors", numErrors.get());
  lst.add("cumulative_adds", addCommandsCumulative.get());
  lst.add("cumulative_deletesById", deleteByIdCommandsCumulative.get());
  lst.add("cumulative_deletesByQuery", deleteByQueryCommandsCumulative.get());
  lst.add("cumulative_errors", numErrorsCumulative.get());
  return lst;
}

@Override
@SuppressWarnings("unchecked")
public Map<String, SolrJSONFacet> resolveJSONFacetResponse(QueryResponse response) {
  Map<String, SolrJSONFacet> jsonFacetMap = new HashMap<>();
  NamedList facetResponse = (NamedList) response.getResponse().get("facets");
  if (facetResponse != null) {
    Iterator<Map.Entry<String, Object>> facetIterator = facetResponse.iterator();
    while (facetIterator.hasNext()) {
      Map.Entry<String, Object> entry = facetIterator.next();
      if (NamedList.class.isAssignableFrom(entry.getValue().getClass())) {
        jsonFacetMap.put(entry.getKey(), resolveJSONFacet((NamedList) entry.getValue()));
      }
    }
  }
  return jsonFacetMap;
}

public void execute(SolrRequestHandler handler, SolrQueryRequest req, SolrQueryResponse rsp) {
 if (handler==null) {
  log.warn(logid+"Null Request Handler '" + req.getParams().get(CommonParams.QT) +"' :" + req);
  throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,"Null Request Handler '" + req.getParams().get(CommonParams.QT) + "'", true);
 }
 // setup response header and handle request
 final NamedList<Object> responseHeader = new SimpleOrderedMap<Object>();
 rsp.add("responseHeader", responseHeader);
 NamedList toLog = rsp.getToLog();
 //toLog.add("core", getName());
 toLog.add("webapp", req.getContext().get("webapp"));
 toLog.add("path", req.getContext().get("path"));
 toLog.add("params", "{" + req.getParamString() + "}");
 handler.handleRequest(req,rsp);
 setResponseHeaderValues(handler,req,rsp);
 StringBuilder sb = new StringBuilder();
 for (int i=0; i<toLog.size(); i++) {
    String name = toLog.getName(i);
    Object val = toLog.getVal(i);
    sb.append(name).append("=").append(val).append(" ");
 }
 log.info(logid +  sb.toString());
 /*log.info(logid+"" + req.getContext().get("path") + " "
     + req.getParamString()+ " 0 "+
   (int)(rsp.getEndTime() - req.getStartTime()));*/
}

@Override
@SuppressWarnings("unchecked")
public void process(ResponseBuilder rb) throws IOException {
  SolrParams params = rb.req.getParams();
  if (!params.getBool(COMPONENT_NAME, false) || spellCheckers.isEmpty()) {
    return;
  boolean shardRequest = "true".equals(params.get(ShardParams.IS_SHARD));
  String q = params.get(SPELLCHECK_Q);
  SolrSpellChecker spellChecker = getSpellChecker(params);
  Collection<Token> tokens = null;
    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "The spellcheck.q parameter is required.");
  } else {
      Integer hitsInteger = (Integer) rb.rsp.getToLog().get("hits");
      long hits = 0;
      if (hitsInteger == null) {
        IndexReader reader = rb.req.getSearcher().getIndexReader();
        SpellingOptions options = new SpellingOptions(tokens, reader, count,
            alternativeTermCount, suggestMode, extendedResults, accuracy,
      response.add("suggestions", suggestions);
      rb.rsp.add("spellcheck", response);
      throw new SolrException(SolrException.ErrorCode.NOT_FOUND,
          "Specified dictionaries do not exist: " + getDictionaryNameAsSingleString(getDictionaryNames(params)));

 throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Illegal query type.  The incoming query must be a Lucene SpanNearQuery and it was a " + origQuery.getClass().getName());
createWeights(params.get(CommonParams.Q), sQuery, termWeights, bigramWeights, reader);
float adjWeight = params.getFloat(ADJACENT_WEIGHT, DEFAULT_ADJACENT_WEIGHT);
NamedList qaResp = new NamedList();
rb.rsp.add("qaResponse", qaResp);
  Passage passage = rankedPassages.pop();
  if (passage != null) {
   NamedList passNL = new NamedList();
   qaResp.add(("answer"), passNL);
   String idName;
   String idValue;
    fields.add(idName);
   passNL.add(idName, idValue);
   passNL.add("field", passage.field);
    if (start >= 0 && start < fldValue.length() &&
        end >= 0 && end < fldValue.length()) {
     passNL.add("window", fldValue.substring(start, end + passage.terms.last().term.length()));
    } else {
     log.debug("Passage does not have correct offset information");
     passNL.add("window", fldValue);//we don't have offsets, or they are incorrect, return the whole field value

@Override
public void write(Writer writer, SolrQueryRequest request, SolrQueryResponse response) throws IOException {
  String xsl = request.getParams().get("lux.xml-xsl-stylesheet");
  @SuppressWarnings("unchecked")
  List<String> errors = response.getValues().getAll("xpath-error");
  String contentType = getContentType (request, response);
  NamedList<?> values = (NamedList<?>) response.getValues().get("xpath-results");
  if (values == null && !errors.isEmpty()) {
    StringBuilder buf = new StringBuilder();
      buf.append(e).append("\n");
    throw new SolrException(ErrorCode.BAD_REQUEST, buf.toString());
  } else if (response.getException() != null) {
    String error = (String) ((NamedList<?>) response.getValues().get("error")).get("msg");
    if (error == null) {
      error = response.getException().toString();
          (values.size() == 0 || values.size() > 1 || ! errors.isEmpty() || 
          (! (values.getName(0).equals("document") || values.getName(0).equals("element"))));
      if (wrapResults) {
        writer.write("<results>");
      for (int i = 0; i < values.size(); i++) {
        Object val = values.getVal(i);
        writer.write(val.toString());

private void addDebugInfo(SolrQueryRequest req, SolrQueryResponse rsp, String q, List<Query> mltFqFilters, MLTResult mltResult) {
  DocListAndSet mltDocs = mltResult.getResults();
  boolean dbg = req.getParams().getBool(CommonParams.DEBUG_QUERY, false);
  boolean dbgQuery = false, dbgResults = false;
  if (dbg == false){//if it's true, we are doing everything anyway.
    String[] dbgParams = req.getParams().getParams(CommonParams.DEBUG);
    if (dbgParams != null) {
      for (int i = 0; i < dbgParams.length; i++) {
      NamedList<Object> dbgInfo = new NamedList<Object>();
      NamedList<Object> stdDbg = SolrPluginUtils.doStandardDebug(req, q, mltResult.getQuery(), mltDocs.docList, dbgQuery, dbgResults);
      if (null != dbgInfo) {
        rsp.add("debug", dbgInfo);
        dbgInfo.add( "mltTerms", it );
        dbgInfo.addAll(stdDbg);
          dbgInfo.add("filter_queries",req.getParams().getParams(CommonParams.FQ));
          List<String> fqs = new ArrayList<String>(mltFqFilters.size());
          for (Query fq : mltFqFilters) {
            fqs.add(QueryParsing.toString(fq, req.getSchema()));
          dbgInfo.add("mlt_filter_queries",fqs);
      SolrException.log(log, "Exception during debug", e);
      rsp.add("exception_during_debug", SolrException.toStr(e));

String resourceName = req.getParams().get(ExtractingParams.RESOURCE_NAME, null);
if (resourceName != null) {
 metadata.add(TikaMetadataKeys.RESOURCE_NAME_KEY, resourceName);
   InputStream is = req.getCore().getResourceLoader().openResource(pwMapFile);
   if(is != null) {
    log.debug("Password file supplied: "+pwMapFile);
     .append(". metadata=").append(metadata.toString()).toString());
  else
   throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, e);
   serializer.endDocument();
  rsp.add(stream.getName(), writer.toString());
  writer.close();
  String[] names = metadata.names();
  NamedList metadataNL = new NamedList();
  for (int i = 0; i < names.length; i++) {
   String[] vals = metadata.getValues(names[i]);
   metadataNL.add(names[i], vals);
  rsp.add(stream.getName() + "_metadata", metadataNL);
throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Stream type of " + streamType + " didn't match any known parsers.  Please supply the " + ExtractingParams.STREAM_TYPE + " parameter.");

long timeAllowed = rb.req.getParams().getLong(CommonParams.TIME_ALLOWED, -1L);
if (timeAllowed > 0L) {
 SolrQueryTimeoutImpl.set(timeAllowed);
     if (rb.req.getCore().getSolrConfig().luceneMatchVersion.onOrAfter(Version.LUCENE_6_0_0)) {
      String reqPath = (String) rb.req.getContext().get(PATH);
      if (!"/select".equals(reqPath)) {
       params.set(CommonParams.QT, reqPath);
  boolean tolerant = rb.req.getParams().getBool(ShardParams.SHARDS_TOLERANT, false);
  while (rb.outgoing.size() == 0) {
   ShardResponse srsp = tolerant ? shardHandler1.takeCompletedIncludingErrors() : shardHandler1
      throw (SolrException) srsp.getException();
     } else {
      throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, srsp.getException());
     if(rb.rsp.getResponseHeader().get(SolrQueryResponse.RESPONSE_HEADER_PARTIAL_RESULTS_KEY) == null) {
      rb.rsp.getResponseHeader().add(SolrQueryResponse.RESPONSE_HEADER_PARTIAL_RESULTS_KEY, Boolean.TRUE);
shardInfo.add(shardInfoName, nl);   
rb.rsp.getValues().add(ShardParams.SHARDS_INFO,shardInfo);

public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
  rsp.setHttpCaching(false);
  final SolrParams solrParams = req.getParams();
  String dicPath = solrParams.get("dicPath");
  Dictionary dict = Utils.getDict(dicPath, loader);
  NamedList<Object> result = new NamedList<Object>();
  result.add("dicPath", dict.getDicPath().toURI());
  boolean check = solrParams.getBool("check", false);	//仅仅用于检测词库是否有变化
  //用于尝试加载词库，有此参数, check 参数可以省略。
  boolean reload = solrParams.getBool("reload", false);	
  check |= reload;
  boolean changed = false;
  boolean reloaded = false;
  if(check) {
    changed = dict.wordsFileIsChange();
    result.add("changed", changed);
  }
  if(changed && reload) {
    reloaded = dict.reload();
    result.add("reloaded", reloaded);
  }
  rsp.add("result", result);
}

SolrParams params = req.getParams();
if (!params.getBool(COMPONENT_NAME, true)) {
 return;
SolrIndexSearcher searcher = req.getSearcher();
 throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "'start' parameter cannot be negative");
long timeAllowed = (long)params.getInt( CommonParams.TIME_ALLOWED, -1 );
  List<Query> filters = rb.getFilters();
  if (filters != null) queries.addAll(filters);
  res.docSet = searcher.getDocSet(queries);
cmd.setTimeAllowed(timeAllowed);
SolrIndexSearcher.QueryResult result = new SolrIndexSearcher.QueryResult();
searcher.search(result,cmd);
rb.setResult( result );
rsp.getToLog().add("hits", rb.getResults().docList.matches());

@Override
public void process(ResponseBuilder rb) throws IOException {
  // Handle the initial facets
  super.process(rb);
  // And do the facet tree, if required
  if (rb.doFacets && rb.req.getParams().getBool(FACET_TREE, false)) {
    HierarchicalFacets ftp = new HierarchicalFacets(rb.req, rb.getResults().docSet, rb.req.getParams(), rb, parameters);
    @SuppressWarnings("rawtypes")
    SimpleOrderedMap<NamedList> ftpResponse = ftp.process(rb.req.getParams().getParams(FACET_TREE_FIELD));
    
    @SuppressWarnings("unchecked")
    NamedList<Object> facetCounts = (NamedList<Object>) rb.rsp.getValues().get("facet_counts");
    if (facetCounts != null) {
      facetCounts.add("facet_trees", ftpResponse);
    } else {
      facetCounts = new NamedList<>();
      facetCounts.add("facet_trees", ftpResponse);
      rb.rsp.add("facet_counts", facetCounts);
    }
  }
}

@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception
 IndexSchema schema = req.getSchema();
 SolrIndexSearcher searcher = req.getSearcher();
 IndexReader reader = searcher.getReader();
 SolrParams params = req.getParams();
 int numTerms = params.getInt( NUMTERMS, DEFAULT_COUNT );
 Integer docId = params.getInt( DOC_ID );
 if( docId == null && params.get( ID ) != null ) {
  String v = uniqueKey.getType().toInternal( params.get(ID) );
  Term t = new Term( uniqueKey.getName(), v );
  docId = searcher.getFirstMatch( t );
  if( docId < 0 ) {
   throw new SolrException( SolrException.ErrorCode.NOT_FOUND, "Can't find document: "+params.get( ID ) );
   throw new SolrException( SolrException.ErrorCode.NOT_FOUND, "Can't find document: "+docId );
 info.add( "key", getFieldFlagsKey() );
 info.add( "NOTE", "Document Frequency (df) is not updated when a document is marked for deletion.  df values include deleted documents." ); 
 rsp.add( "info", info );
 rsp.setHttpCaching(false);

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void writeResponse() throws IOException {
  writer.write(XML_PROCESSING_INSTR);
  final String stylesheet = req.getParams().get("stylesheet");
  if (isNotNullOrEmptyString(stylesheet)) {
    writer.write(XML_STYLESHEET);
    escapeAttributeValue(stylesheet, writer);
    
    writer.write(XML_STYLESHEET_END);
  }
  writer.write(RESPONSE_ROOT_ELEMENT_START);
  final NamedList<?> responseValues = rsp.getValues();
  if (req.getParams().getBool(CommonParams.OMIT_HEADER, false)) {
    responseValues.remove(RESPONSE_HEADER);
  } else {
    ((NamedList)responseValues.get(RESPONSE_HEADER)).add(Names.QUERY, responseValues.remove(Names.QUERY).toString());
  }
  
  for (final Entry<String, ?> entry : responseValues) {
    writeValue(entry.getKey(), entry.getValue(), responseValues);            
  }

  writer.write(RESPONSE_ROOT_ELEMENT_END);
}

 public void forEach(BiConsumer<String, T> action) {
  int sz = size();
  for (int i = 0; i < sz; i++) {
   action.accept(getName(i), getVal(i));
  }
 }
}

@Override
@SuppressWarnings("unchecked")
public void process(ResponseBuilder rb) throws IOException {
 SolrParams params = rb.req.getParams();
 if (!params.getBool(COMPONENT_NAME, false) || spellCheckers.isEmpty()) {
  return;
 String q = params.get(SPELLCHECK_Q);
 SolrSpellChecker spellChecker = getSpellChecker(params);
 Collection<Token> tokens = null;
  q = rb.getQueryString();
  if (q == null) {
   q = params.get(CommonParams.Q);
     false);
   NamedList response = new SimpleOrderedMap();
   IndexReader reader = rb.req.getSearcher().getReader();
   boolean collate = params.getBool(SPELLCHECK_COLLATE, false);
   SpellingResult spellingResult = spellChecker.getSuggestions(tokens,
     reader, count, onlyMorePopular, extendedResults);
   if (spellingResult != null) {
    response.add("suggestions", toNamedList(spellingResult, q,
      extendedResults, collate));
    rb.rsp.add("spellcheck", response);
   throw new SolrException(SolrException.ErrorCode.NOT_FOUND,
     "Specified dictionary does not exist.");

  public static SolrQueryRequest substituteField(SolrQueryRequest req){
    SolrParams params = req.getParams();
    String query = params.get("q");
    System.out.println("query before ="+query);
    query = query.replace(' ', '_');
    System.out.println("query after ="+query);
    NamedList values = params.toNamedList();
    values.remove("q");
    values.add("q", query);
    params = SolrParams.toSolrParams(values);
    req.setParams(params);
    return req;
  }
}

public static void setResponseHeaderValues(SolrRequestHandler handler, SolrQueryRequest req, SolrQueryResponse rsp) {
 responseHeader.add("status",status);
 responseHeader.add("QTime",qtime);
 rsp.getToLog().add("status",status);
 rsp.getToLog().add("QTime",qtime);
 SolrParams params = req.getParams();
 if( params.getBool(CommonParams.HEADER_ECHO_HANDLER, false) ) {
  responseHeader.add("handler", handler.getName() );
 String ep = params.get( CommonParams.HEADER_ECHO_PARAMS, null );
 if( ep != null ) {
  EchoParamStyle echoParams = EchoParamStyle.get( ep );
  if( echoParams == null ) {
   throw new SolrException( SolrException.ErrorCode.BAD_REQUEST,"Invalid value '" + ep + "' for " + CommonParams.HEADER_ECHO_PARAMS 
     + " parameter, use '" + EchoParamStyle.EXPLICIT + "' or '" + EchoParamStyle.ALL + "'" );
   responseHeader.add("params", req.getOriginalParams().toNamedList());
  } else if( echoParams == EchoParamStyle.ALL ) {
   responseHeader.add("params", req.getParams().toNamedList());

@Override
public NamedList<Object> processResponse(InputStream body, String encoding) {
 try {
  StringWriter writer = new StringWriter();
  IOUtils.copy(body, writer, encoding);
  String output = writer.toString();
  NamedList<Object> list = new NamedList<>();
  list.add("response", output);
  return list;
 } catch (IOException e) {
  throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "parsing error", e);
 }
}

Javadoc

A simple container class for modeling an ordered list of name/value pairs.

Unlike Maps:

Names may be repeated
Order of elements is maintained
Elements may be accessed by numeric index
Names and Values can both be null

A NamedList provides fast access by element number, but not by name.

When a NamedList is serialized, order is considered more important than access by key, so ResponseWriters that output to a format such as JSON will normally choose a data structure that allows order to be easily preserved in various clients (i.e. not a straight map). If access by key is more important, see SimpleOrderedMap, or simply use a regular Map

Most used methods

get
Gets the value for the first instance of the specified name found starting at the specified index.
add
Adds a name/value pair to the end of the list.
size
The total number of name/value pairs
<init>
Creates a NamedList instance containing the "name,value" pairs contained in the Entry[]. Modifying t
getName
The name of the pair at the specified List index
getVal
The value of the pair at the specified List index
remove
NOTE: this runs in linear time (it scans starting at the beginning of the list until it finds the fi
toString
getAll
Gets the values for the the specified name
iterator
Support the Iterable interface
getBooleanArg
Used for getting a boolean argument from a NamedList object. If the name is not present, returns nul
addAll
Appends the elements of the given NamedList to this one.

Popular in Java

Reactive rest calls using spring rest template
requestLocationUpdates (LocationManager)
addToBackStack (FragmentTransaction)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
Pointer (com.sun.jna)
An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
Time (java.sql)
Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
Iterator (java.util)
An iterator over a sequence of objects, such as a collection.If a collection has been changed since
IsNull (org.hamcrest.core)
Is the value null?
From CI to AI: The AI layer in your organization

How to useNamedList in org.apache.solr.common.util

Best Java code snippets using org.apache.solr.common.util.NamedList (Showing top 20 results out of 675)

Refine search

How to use
NamedList
in
org.apache.solr.common.util