All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.solr.client.solrj.response.QueryResponse Maven / Gradle / Ivy

Go to download

Apache Solr Solrj

There is a newer version: 9.5.0
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.solr.client.solrj.response;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.beans.DocumentObjectBinder;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.params.CursorMarkParams;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.common.util.SimpleOrderedMap;

/**
 * 
 *
 * @since solr 1.3
 */
@SuppressWarnings("unchecked")
public class QueryResponse extends SolrResponseBase 
{
  // Direct pointers to known types
  private NamedList _header = null;
  private SolrDocumentList _results = null;
  private NamedList _sortvalues = null;
  private NamedList _facetInfo = null;
  private NamedList _debugInfo = null;
  private NamedList _highlightingInfo = null;
  private NamedList _spellInfo = null;
  private List> _clusterInfo = null;
  private Map> _suggestInfo = null;
  private NamedList _statsInfo = null;
  private NamedList> _termsInfo = null;
  private String _cursorMarkNext = null;

  // Grouping response
  private NamedList _groupedInfo = null;
  private GroupResponse _groupResponse = null;

  private NamedList _expandedInfo = null;
  private Map _expandedResults = null;

  // Facet stuff
  private Map _facetQuery = null;
  private List _facetFields = null;
  private List _limitingFacets = null;
  private List _facetDates = null;
  private List _facetRanges = null;
  private NamedList> _facetPivot = null;
  private List _intervalFacets = null;

  // Highlight Info
  private Map>> _highlighting = null;

  // SpellCheck Response
  private SpellCheckResponse _spellResponse = null;

  // Clustering Response
  private ClusteringResponse _clusterResponse = null;

  // Suggester Response
  private SuggesterResponse _suggestResponse = null;

  // Terms Response
  private TermsResponse _termsResponse = null;
  
  // Field stats Response
  private Map _fieldStatsInfo = null;
  
  // Debug Info
  private Map _debugMap = null;
  private Map _explainMap = null;

  // utility variable used for automatic binding -- it should not be serialized
  private transient final SolrClient solrClient;

  public QueryResponse() {
    solrClient = null;
  }
  
  /**
   * Utility constructor to set the solrServer and namedList
   */
  public QueryResponse( NamedList res , SolrClient solrClient){
    this.setResponse( res );
    this.solrClient = solrClient;
  }

  public QueryResponse(SolrClient solrClient) {
    this.solrClient = solrClient;
  }

  @Override
  public void setResponse( NamedList res )
  {
    super.setResponse( res );
    
    // Look for known things
    for( int i=0; i) res.getVal( i );
      }
      else if( "response".equals( n ) ) {
        _results = (SolrDocumentList) res.getVal( i );
      }
      else if( "sort_values".equals( n ) ) {
        _sortvalues = (NamedList) res.getVal( i );
      }
      else if( "facet_counts".equals( n ) ) {
        _facetInfo = (NamedList) res.getVal( i );
        // extractFacetInfo inspects _results, so defer calling it
        // in case it hasn't been populated yet.
      }
      else if( "debug".equals( n ) ) {
        _debugInfo = (NamedList) res.getVal( i );
        extractDebugInfo( _debugInfo );
      }
      else if( "grouped".equals( n ) ) {
        _groupedInfo = (NamedList) res.getVal( i );
        extractGroupedInfo( _groupedInfo );
      }
      else if("expanded".equals(n)) {
        NamedList map = (NamedList) res.getVal(i);
        _expandedResults = map.asMap(1);
      }
      else if( "highlighting".equals( n ) ) {
        _highlightingInfo = (NamedList) res.getVal( i );
        extractHighlightingInfo( _highlightingInfo );
      }
      else if ( "spellcheck".equals( n ) )  {
        _spellInfo = (NamedList) res.getVal( i );
        extractSpellCheckInfo( _spellInfo );
      }
      else if ("clusters".equals(n)) {
        _clusterInfo = (ArrayList>) res.getVal(i);
        extractClusteringInfo(_clusterInfo);
      }
      else if ( "suggest".equals( n ) )  {
        _suggestInfo = (Map>) res.getVal( i );
        extractSuggesterInfo(_suggestInfo);
      }
      else if ( "stats".equals( n ) )  {
        _statsInfo = (NamedList) res.getVal( i );
        extractStatsInfo( _statsInfo );
      }
      else if ( "terms".equals( n ) ) {
        _termsInfo = (NamedList>) res.getVal( i );
        extractTermsInfo( _termsInfo );
      }
      else if ( CursorMarkParams.CURSOR_MARK_NEXT.equals( n ) ) {
        _cursorMarkNext = (String) res.getVal( i );
      }
    }
    if(_facetInfo != null) extractFacetInfo( _facetInfo );
  }

  private void extractSpellCheckInfo(NamedList spellInfo) {
    _spellResponse = new SpellCheckResponse(spellInfo);
  }

  private void extractClusteringInfo(List> clusterInfo) {
    _clusterResponse = new ClusteringResponse(clusterInfo);
  }

  private void extractSuggesterInfo(Map> suggestInfo) {
    _suggestResponse = new SuggesterResponse(suggestInfo);
  }

  private void extractTermsInfo(NamedList> termsInfo) {
    _termsResponse = new TermsResponse(termsInfo);
  }
  
  private void extractStatsInfo(NamedList info) {
    _fieldStatsInfo = extractFieldStatsInfo(info);
  }

  private Map extractFieldStatsInfo(NamedList info) {
    if( info != null ) {
       Map fieldStatsInfoMap = new TreeMap<>();
      NamedList> ff = (NamedList>) info.get( "stats_fields" );
      if( ff != null ) {
        for( Map.Entry> entry : ff ) {
          NamedList v = entry.getValue();
          if( v != null ) {
             fieldStatsInfoMap.put( entry.getKey(),
                new FieldStatsInfo( v, entry.getKey() ) );
          }
        }
      }
       return fieldStatsInfoMap;
    }
    return null;
  }

  private void extractDebugInfo( NamedList debug )
  {
    _debugMap = new LinkedHashMap<>(); // keep the order
    for( Map.Entry info : debug ) {
      _debugMap.put( info.getKey(), info.getValue() );
    }

    // Parse out interesting bits from the debug info
    _explainMap = new HashMap<>();
    NamedList explain = (NamedList)_debugMap.get( "explain" );
    if( explain != null ) {
      for( Map.Entry info : explain ) {
        String key = info.getKey();
        _explainMap.put( key, info.getValue() );
      }
    }
  }

  private void extractGroupedInfo( NamedList info ) {
    if ( info != null ) {
      _groupResponse = new GroupResponse();
      int size = info.size();
      for (int i=0; i < size; i++) {
        String fieldName = info.getName(i);
        Object fieldGroups =  info.getVal(i);
        SimpleOrderedMap simpleOrderedMap = (SimpleOrderedMap) fieldGroups;

        Object oMatches = simpleOrderedMap.get("matches");
        Object oNGroups = simpleOrderedMap.get("ngroups");
        Object oGroups = simpleOrderedMap.get("groups");
        Object queryCommand = simpleOrderedMap.get("doclist");
        if (oMatches == null) {
          continue;
        }

        if (oGroups != null) {
          Integer iMatches = (Integer) oMatches;
          ArrayList groupsArr = (ArrayList) oGroups;
          GroupCommand groupedCommand;
          if (oNGroups != null) {
            Integer iNGroups = (Integer) oNGroups;
            groupedCommand = new GroupCommand(fieldName, iMatches, iNGroups);
          } else {
            groupedCommand = new GroupCommand(fieldName, iMatches);
          }

          for (Object oGrp : groupsArr) {
            SimpleOrderedMap grpMap = (SimpleOrderedMap) oGrp;
            Object sGroupValue = grpMap.get( "groupValue");
            SolrDocumentList doclist = (SolrDocumentList) grpMap.get( "doclist");
            Group group = new Group(sGroupValue != null ? sGroupValue.toString() : null, doclist) ;
            groupedCommand.add(group);
          }

          _groupResponse.add(groupedCommand);
        } else if (queryCommand != null) {
          Integer iMatches = (Integer) oMatches;
          GroupCommand groupCommand;
          if (oNGroups != null) {
            Integer iNGroups = (Integer) oNGroups;
            groupCommand = new GroupCommand(fieldName, iMatches, iNGroups);
          } else {
            groupCommand = new GroupCommand(fieldName, iMatches);
          }
          SolrDocumentList docList = (SolrDocumentList) queryCommand;
          groupCommand.add(new Group(fieldName, docList));
          _groupResponse.add(groupCommand);
        }
      }
    }
  }

  private void extractHighlightingInfo( NamedList info )
  {
    _highlighting = new HashMap<>();
    for( Map.Entry doc : info ) {
      Map> fieldMap = new HashMap<>();
      _highlighting.put( doc.getKey(), fieldMap );
      
      NamedList> fnl = (NamedList>)doc.getValue();
      for( Map.Entry> field : fnl ) {
        fieldMap.put( field.getKey(), field.getValue() );
      }
    }
  }

  private void extractFacetInfo( NamedList info )
  {
    // Parse the queries
    _facetQuery = new LinkedHashMap<>();
    NamedList fq = (NamedList) info.get( "facet_queries" );
    if (fq != null) {
      for( Map.Entry entry : fq ) {
        _facetQuery.put( entry.getKey(), entry.getValue() );
      }
    }
    
    // Parse the facet info into fields
    // TODO?? The list could be  or ?  If always  then we can switch to 
    NamedList> ff = (NamedList>) info.get( "facet_fields" );
    if( ff != null ) {
      _facetFields = new ArrayList<>( ff.size() );
      _limitingFacets = new ArrayList<>( ff.size() );
      
      long minsize = _results == null ? Long.MAX_VALUE :_results.getNumFound();
      for( Map.Entry> facet : ff ) {
        FacetField f = new FacetField( facet.getKey() );
        for( Map.Entry entry : facet.getValue() ) {
          f.add( entry.getKey(), entry.getValue().longValue() );
        }
        
        _facetFields.add( f );
        FacetField nl = f.getLimitingFields( minsize );
        if( nl.getValueCount() > 0 ) {
          _limitingFacets.add( nl );
        }
      }
    }
    
    //Parse range facets
    NamedList> rf = (NamedList>) info.get("facet_ranges");
    if (rf != null) {
      _facetRanges = extractRangeFacets(rf);
    }
    
    //Parse pivot facets
    NamedList pf = (NamedList) info.get("facet_pivot");
    if (pf != null) {
      _facetPivot = new NamedList<>();
      for( int i=0; i)pf.getVal(i) ) );
      }
    }
    
    //Parse interval facets
    NamedList> intervalsNL = (NamedList>) info.get("facet_intervals");
    if (intervalsNL != null) {
      _intervalFacets = new ArrayList<>(intervalsNL.size());
      for (Map.Entry> intervalField : intervalsNL) {
        String field = intervalField.getKey();
        List counts = new ArrayList(intervalField.getValue().size());
        for (Map.Entry interval : intervalField.getValue()) {
          counts.add(new IntervalFacet.Count(interval.getKey(), (Integer)interval.getValue()));
        }
        _intervalFacets.add(new IntervalFacet(field, counts));
      }
    }
  }

  private List extractRangeFacets(NamedList> rf) {
    List facetRanges = new ArrayList<>( rf.size() );

    for (Map.Entry> facet : rf) {
      NamedList values = facet.getValue();
      Object rawGap = values.get("gap");

      RangeFacet rangeFacet;
      if (rawGap instanceof Number) {
        Number gap = (Number) rawGap;
        Number start = (Number) values.get("start");
        Number end = (Number) values.get("end");

        Number before = (Number) values.get("before");
        Number after = (Number) values.get("after");
        Number between = (Number) values.get("between");

        rangeFacet = new RangeFacet.Numeric(facet.getKey(), start, end, gap, before, after, between);
      } else {
        String gap = (String) rawGap;
        Date start = (Date) values.get("start");
        Date end = (Date) values.get("end");

        Number before = (Number) values.get("before");
        Number after = (Number) values.get("after");
        Number between = (Number) values.get("between");

        rangeFacet = new RangeFacet.Date(facet.getKey(), start, end, gap, before, after, between);
      }

      NamedList counts = (NamedList) values.get("counts");
      for (Map.Entry entry : counts)   {
        rangeFacet.addCount(entry.getKey(), entry.getValue());
      }

      facetRanges.add(rangeFacet);
    }
    return facetRanges;
  }

  protected List readPivots( List list )
  {
    ArrayList values = new ArrayList<>( list.size() );
    for( NamedList nl : list ) {
      // NOTE, this is cheating, but we know the order they are written in, so no need to check
      assert "field".equals(nl.getName(0));
      String f = (String)nl.getVal( 0 );
      assert "value".equals(nl.getName(1));
      Object v = nl.getVal( 1 );
      assert "count".equals(nl.getName(2));
      int cnt = ((Integer)nl.getVal( 2 )).intValue();

      List subPivots = null;
      Map fieldStatsInfos = null;
      Map queryCounts = null;
      List ranges = null;

      if (4 <= nl.size()) {
        for(int index = 3; index < nl.size(); index++) {
          final String key = nl.getName(index);
          final Object val = nl.getVal(index);
          switch (key) {

          case "pivot": {
            assert null != val : "Server sent back 'null' for sub pivots?";
            assert val instanceof List : "Server sent non-List for sub pivots?";

            subPivots = readPivots( (List) val );
            break;
          }
          case "stats": {
            assert null != val : "Server sent back 'null' for stats?";
            assert val instanceof NamedList : "Server sent non-NamedList for stats?";

            fieldStatsInfos = extractFieldStatsInfo((NamedList) val);
            break;
          }
          case "queries": {
            // Parse the queries
            queryCounts = new LinkedHashMap<>();
            NamedList fq = (NamedList) val;
            if (fq != null) {
              for( Map.Entry entry : fq ) {
                queryCounts.put( entry.getKey(), entry.getValue() );
              }
            }
            break;
          }
          case "ranges": {
            ranges  = extractRangeFacets((NamedList>) val);
            break;
          }
          default: 
            throw new RuntimeException( "unknown key in pivot: "+ key+ " ["+val+"]");

          }
        }
      }

      values.add( new PivotField( f, v, cnt, subPivots, fieldStatsInfos, queryCounts, ranges ) );
    }
    return values;
  }

  //------------------------------------------------------
  //------------------------------------------------------

  /**
   * Remove the field facet info
   */
  public void removeFacets() {
    _facetFields = new ArrayList<>();
  }
  
  //------------------------------------------------------
  //------------------------------------------------------

  public NamedList getHeader() {
    return _header;
  }

  public SolrDocumentList getResults() {
    return _results;
  }
 
  public NamedList getSortValues(){
    return _sortvalues;
  }

  public Map getDebugMap() {
    return _debugMap;
  }

  public Map getExplainMap() {
    return _explainMap;
  }

  public Map getFacetQuery() {
    return _facetQuery;
  }

  /**
   *
   * @return map with each group value as key and the expanded documents that belong to the group as value.
   * There is no guarantee on the order of the keys obtained via an iterator.
   *
   */
  public Map getExpandedResults() {
    return this._expandedResults;
  }

  /**
   * Returns the {@link GroupResponse} containing the group commands.
   * A group command can be the result of one of the following parameters:
   * 
    
   *   
  • group.field
   *   
  • group.func
   *   
  • group.query
   * 

   *
   * @return the {@link GroupResponse} containing the group commands
   */
  public GroupResponse getGroupResponse() {
    return _groupResponse;
  }
  
  public Map>> getHighlighting() {
    return _highlighting;
  }

  public SpellCheckResponse getSpellCheckResponse() {
    return _spellResponse;
  }

  public ClusteringResponse getClusteringResponse() {
    return _clusterResponse;
  }

  public SuggesterResponse getSuggesterResponse() {
    return _suggestResponse;
  }

  public TermsResponse getTermsResponse() {
    return _termsResponse;
  }
  
  /**
   * See also: {@link #getLimitingFacets()}
   */
  public List getFacetFields() {
    return _facetFields;
  }
  
  public List getFacetDates()   {
    return _facetDates;
  }

  public List getFacetRanges() {
    return _facetRanges;
  }

  public NamedList> getFacetPivot()   {
    return _facetPivot;
  }
  
  public List getIntervalFacets() {
    return _intervalFacets;
  }
  
  /** get
   * 
   * @param name the name of the
   * @return the FacetField by name or null if it does not exist
   */
  public FacetField getFacetField(String name) {
    if (_facetFields==null) return null;
    for (FacetField f : _facetFields) {
      if (f.getName().equals(name)) return f;
    }
    return null;
  }
  
  public FacetField getFacetDate(String name)   {
    if (_facetDates == null)
      return null;
    for (FacetField f : _facetDates)
      if (f.getName().equals(name))
        return f;
    return null;
  }
  
  /**
   * @return a list of FacetFields where the count is less then
   * then #getResults() {@link SolrDocumentList#getNumFound()}
   * 
   * If you want all results exactly as returned by solr, use:
   * {@link #getFacetFields()}
   */
  public List getLimitingFacets() {
    return _limitingFacets;
  }
  
  public  List getBeans(Class type){
    return solrClient == null ?
      new DocumentObjectBinder().getBeans(type,_results):
      solrClient.getBinder().getBeans(type, _results);
  }

  public Map getFieldStatsInfo() {
    return _fieldStatsInfo;
  }

  public String getNextCursorMark() {
    return _cursorMarkNext;
  }
}



 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy