All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

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

    The 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 org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.beans.DocumentObjectBinder;

/**
 * 
 * @version $Id: QueryResponse.java 816372 2009-09-17 20:28:53Z yonik $
 * @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 NamedList _statsInfo = null;

  // Facet stuff
  private Map _facetQuery = null;
  private List _facetFields = null;
  private List _limitingFacets = null;
  private List _facetDates = null;

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

  // SpellCheck Response
  private SpellCheckResponse _spellResponse = 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 SolrServer solrServer;
  
  public QueryResponse(){
    solrServer = null;
  }
  
  /**
   * Utility constructor to set the solrServer and namedList
   */
  public QueryResponse( NamedList res , SolrServer solrServer){
    this.setResponse( res );
    this.solrServer = solrServer;
  }

  @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( _facetInfo );
      }
      else if( "debug".equals( n ) ) {
        _debugInfo = (NamedList) res.getVal( i );
        extractDebugInfo( _debugInfo );
      }
      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 ( "stats".equals( n ) )  {
        _statsInfo = (NamedList) res.getVal( i );
        extractStatsInfo( _statsInfo );
      }
    }
  }

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

  private void extractStatsInfo(NamedList info) {
    if( info != null ) {
      _fieldStatsInfo = new HashMap();
      NamedList> ff = (NamedList>) info.get( "stats_fields" );
      if( ff != null ) {
        for( Map.Entry> entry : ff ) {
          NamedList v = entry.getValue();
          if( v != null ) {
            _fieldStatsInfo.put( entry.getKey(), 
                new FieldStatsInfo( v, entry.getKey() ) );
          }
        }
      }
    }
  }

  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 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 HashMap();
    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.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 date facets
    NamedList> df = (NamedList>) info.get("facet_dates");
    if (df != null) {
      // System.out.println(df);
      _facetDates = new ArrayList( df.size() );
      for (Map.Entry> facet : df) {
        // System.out.println("Key: " + facet.getKey() + " Value: " + facet.getValue());
        NamedList values = facet.getValue();
        String gap = (String) values.get("gap");
        Date end = (Date) values.get("end");
        FacetField f = new FacetField(facet.getKey(), gap, end);
        
        for (Map.Entry entry : values)   {
          try {
            f.add(entry.getKey(), Long.parseLong(entry.getValue().toString()));
          } catch (NumberFormatException e) {
            //Ignore for non-number responses which are already handled above
          }
        }
        
        _facetDates.add(f);
      }
    }
  }

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

  /**
   * 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;
  }

  public Map>> getHighlighting() {
    return _highlighting;
  }

  public SpellCheckResponse getSpellCheckResponse() {
    return _spellResponse;
  }

  /**
   * See also: {@link #getLimitingFacets()}
   */
  public List getFacetFields() {
    return _facetFields;
  }
  
  public List getFacetDates()   {
    return _facetDates;
  }
  
  /** 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 solrServer == null ? 
      new DocumentObjectBinder().getBeans(type,_results):
      solrServer.getBinder().getBeans(type, _results);
  }

  public Map getFieldStatsInfo() {
    return _fieldStatsInfo;
  }
}



    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy