solr/core/src/java/org/apache/solr/search/facet/LegacyFacet.java - lucene-solr - Git at Google

 /*
  * 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.search.facet;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.solr.common.SolrException;
 import org.apache.solr.common.params.CommonParams;
 import org.apache.solr.common.params.FacetParams;
 import org.apache.solr.common.params.RequiredSolrParams;
 import org.apache.solr.common.params.SolrParams;
 import org.apache.solr.common.util.StrUtils;
 import org.apache.solr.search.QueryParsing;
 import org.apache.solr.search.SolrReturnFields;
 import org.apache.solr.search.StrParser;
 import org.apache.solr.search.SyntaxError;

 import static org.apache.solr.common.params.CommonParams.SORT;

 public class LegacyFacet {
   private SolrParams params;
   private Map<String,Object> json;
   private Map<String,Object> currentCommand = null;  // always points to the current facet command
   private Map<String,Object> currentSubs; // always points to the current facet:{} block

   String facetValue;
   String key;
   SolrParams localParams;
   SolrParams orig;
   SolrParams required;

   Map<String, List<Subfacet>> subFacets;  // only parsed once

   public LegacyFacet(SolrParams params) {
     this.params = params;
     this.orig = params;
     this.json = new LinkedHashMap<>();
     this.currentSubs = json;
   }


   Map<String,Object> getLegacy() {
     subFacets = parseSubFacets(params);
     String[] queries = params.getParams(FacetParams.FACET_QUERY);
     if (queries != null) {
       for (String q : queries) {
         addQueryFacet(q);
       }
     }
     String[] fields = params.getParams(FacetParams.FACET_FIELD);
     if (fields != null) {
       for (String field : fields) {
         addFieldFacet(field);
       }
     }
     String[] ranges = params.getParams(FacetParams.FACET_RANGE);
     if (ranges != null) {
       for (String range : ranges) {
         addRangeFacet(range);
       }
     }
     // SolrCore.log.error("###################### JSON FACET:" + json);
     return json;
   }


   protected static class Subfacet {
     public String parentKey;
     public String type; // query, range, field
     public String value;  // the actual field or the query, including possible local params
   }


   protected static Map<String, List<Subfacet>> parseSubFacets(SolrParams params) {
     Map<String,List<Subfacet>> map = new HashMap<>();
     Iterator<String> iter = params.getParameterNamesIterator();

     String SUBFACET="subfacet.";
     while (iter.hasNext()) {
       String key = iter.next();

       if (key.startsWith(SUBFACET)) {
         List<String> parts = StrUtils.splitSmart(key, '.');
         if (parts.size() != 3) {
           throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "expected subfacet parameter name of the form subfacet.mykey.field, got:" + key);
         }
         Subfacet sub = new Subfacet();
         sub.parentKey = parts.get(1);
         sub.type = parts.get(2);
         sub.value = params.get(key);

         List<Subfacet> subs = map.get(sub.parentKey);
         if (subs == null) {
           subs = new ArrayList<>(1);
         }
         subs.add(sub);
         map.put(sub.parentKey, subs);
       }
     }

     return map;
   }


   protected void addQueryFacet(String q) {
     parseParams(FacetParams.FACET_QUERY, q);
     Map<String,Object> cmd = new HashMap<String,Object>(2);
     Map<String,Object> type = new HashMap<String,Object>(1);
     type.put("query", cmd);
     cmd.put("q", q);
     addSub(key, type);
     handleSubs(cmd);
   }

   protected void addRangeFacet(String field)  {
     parseParams(FacetParams.FACET_RANGE, field);
     Map<String,Object> cmd = new HashMap<String,Object>(5);
     Map<String,Object> type = new HashMap<String,Object>(1);
     type.put("range", cmd);

     String f = key;
     cmd.put("field", facetValue);
     cmd.put("start", required.getFieldParam(f,FacetParams.FACET_RANGE_START));
     cmd.put("end", required.getFieldParam(f,FacetParams.FACET_RANGE_END));
     cmd.put("gap", required.getFieldParam(f, FacetParams.FACET_RANGE_GAP));
     String[] p = params.getFieldParams(f, FacetParams.FACET_RANGE_OTHER);
     if (p != null) cmd.put("other", p.length==1 ? p[0] : Arrays.asList(p));
     p = params.getFieldParams(f, FacetParams.FACET_RANGE_INCLUDE);
     if (p != null) cmd.put("include", p.length==1 ? p[0] : Arrays.asList(p));

     final int mincount = params.getFieldInt(f,FacetParams.FACET_MINCOUNT, 0);
     cmd.put("mincount", mincount);

     boolean hardend = params.getFieldBool(f,FacetParams.FACET_RANGE_HARD_END,false);
     if (hardend) cmd.put("hardend", hardend);

     addSub(key, type);
     handleSubs(cmd);
   }

   protected void addFieldFacet(String field) {
     parseParams(FacetParams.FACET_FIELD, field);

     String f = key;  // the parameter to use for per-field parameters... f.key.facet.limit=10

     int offset = params.getFieldInt(f, FacetParams.FACET_OFFSET, 0);
     int limit = params.getFieldInt(f, FacetParams.FACET_LIMIT, 10);

     int mincount = params.getFieldInt(f, FacetParams.FACET_MINCOUNT, 1);

     boolean missing = params.getFieldBool(f, FacetParams.FACET_MISSING, false);

     // default to sorting if there is a limit.
     String sort = params.getFieldParam(f, FacetParams.FACET_SORT, limit>0 ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX);
     String prefix = params.getFieldParam(f, FacetParams.FACET_PREFIX);

     Map<String,Object> cmd = new HashMap<>();
     cmd.put("field", facetValue);
     if (offset != 0) cmd.put("offset", offset);
     if (limit != 10) cmd.put("limit", limit);
     if (mincount != 1) cmd.put("mincount", mincount);
     if (missing) cmd.put("missing", missing);
     if (prefix != null) cmd.put("prefix", prefix);
     if (sort.equals("count")) {
       // our default
     } else if (sort.equals("index")) {
       cmd.put(SORT, "index asc");
     } else {
       cmd.put(SORT, sort);  // can be sort by one of our stats
     }

     Map<String,Object> type = new HashMap<>(1);
     type.put("terms", cmd);

     addSub(key, type);
     handleSubs(cmd);
   }

   private void handleSubs(Map<String,Object> cmd) {
     Map<String,Object> savedCmd = currentCommand;
     Map<String,Object> savedSubs = currentSubs;
    try {
      currentCommand = cmd;
      currentSubs = null;

      // parse stats for this facet
      String[] stats = params.getFieldParams(key, "facet.stat");
      if (stats != null) {
        for (String stat : stats) {
          addStat(stat);
        }
      }

      List<Subfacet> subs = subFacets.get(key);
      if (subs != null) {
        for (Subfacet subfacet : subs) {
          if ("field".equals(subfacet.type)) {
            addFieldFacet(subfacet.value);
          } else if ("query".equals(subfacet.type)) {
            addQueryFacet(subfacet.value);
          } else if ("range".equals(subfacet.type)) {
            addQueryFacet(subfacet.value);
          }
        }
      }


    } finally {
      currentCommand = savedCmd;
      currentSubs = savedSubs;
    }
   }


   private void addStat(String val) {
     StrParser sp = new StrParser(val);
     int start = 0;
     sp.eatws();
     if (sp.pos >= sp.end) addStat(val, val);

     // try key:func() format
     String key = null;
     String funcStr = val;

     if (key == null) {
       key = SolrReturnFields.getFieldName(sp);
       if (key != null && sp.opt(':')) {
         // OK, we got the key
         funcStr = val.substring(sp.pos);
       } else {
         // an invalid key... it must not be present.
         sp.pos = start;
         key = null;
       }
     }

     if (key == null) {
       key = funcStr;  // not really ideal
     }

     addStat(key, funcStr);
   }

   private void addStat(String key, String val) {
     if ("count".equals(val) || "count()".equals(val)) return;  // we no longer have a count function, we always return the count
     getCurrentSubs().put(key, val);
   }

   private void addSub(String key, Map<String,Object> sub) {
     getCurrentSubs().put(key, sub);
   }

   @SuppressWarnings({"unchecked", "rawtypes"})
   private Map<String,Object> getCurrentSubs() {
     if (currentSubs == null) {
       currentSubs = new LinkedHashMap();
       currentCommand.put("facet", currentSubs);
     }
     return currentSubs;
   }


   protected void parseParams(String type, String param)  {
     facetValue = param;
     key = param;

     try {
       localParams = QueryParsing.getLocalParams(param, orig);

       if (localParams == null) {
         params = orig;
         required = new RequiredSolrParams(params);
         // setupStats();
         return;
       }

       params = SolrParams.wrapDefaults(localParams, orig);
       required = new RequiredSolrParams(params);

       // remove local params unless it's a query
       if (type != FacetParams.FACET_QUERY) {
         facetValue = localParams.get(CommonParams.VALUE);
       }

       // reset set the default key now that localParams have been removed
       key = facetValue;

       // allow explicit set of the key
       key = localParams.get(CommonParams.OUTPUT_KEY, key);

       // setupStats();
     } catch (SyntaxError e) {
       throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e);
     }
   }


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

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map;

	import org.apache.solr.common.SolrException;
	import org.apache.solr.common.params.CommonParams;
	import org.apache.solr.common.params.FacetParams;
	import org.apache.solr.common.params.RequiredSolrParams;
	import org.apache.solr.common.params.SolrParams;
	import org.apache.solr.common.util.StrUtils;
	import org.apache.solr.search.QueryParsing;
	import org.apache.solr.search.SolrReturnFields;
	import org.apache.solr.search.StrParser;
	import org.apache.solr.search.SyntaxError;

	import static org.apache.solr.common.params.CommonParams.SORT;

	public class LegacyFacet {
	private SolrParams params;
	private Map<String,Object> json;
	private Map<String,Object> currentCommand = null; // always points to the current facet command
	private Map<String,Object> currentSubs; // always points to the current facet:{} block

	String facetValue;
	String key;
	SolrParams localParams;
	SolrParams orig;
	SolrParams required;

	Map<String, List<Subfacet>> subFacets; // only parsed once

	public LegacyFacet(SolrParams params) {
	this.params = params;
	this.orig = params;
	this.json = new LinkedHashMap<>();
	this.currentSubs = json;
	}


	Map<String,Object> getLegacy() {
	subFacets = parseSubFacets(params);
	String[] queries = params.getParams(FacetParams.FACET_QUERY);
	if (queries != null) {
	for (String q : queries) {
	addQueryFacet(q);
	}
	}
	String[] fields = params.getParams(FacetParams.FACET_FIELD);
	if (fields != null) {
	for (String field : fields) {
	addFieldFacet(field);
	}
	}
	String[] ranges = params.getParams(FacetParams.FACET_RANGE);
	if (ranges != null) {
	for (String range : ranges) {
	addRangeFacet(range);
	}
	}
	// SolrCore.log.error("###################### JSON FACET:" + json);
	return json;
	}


	protected static class Subfacet {
	public String parentKey;
	public String type; // query, range, field
	public String value; // the actual field or the query, including possible local params
	}


	protected static Map<String, List<Subfacet>> parseSubFacets(SolrParams params) {
	Map<String,List<Subfacet>> map = new HashMap<>();
	Iterator<String> iter = params.getParameterNamesIterator();

	String SUBFACET="subfacet.";
	while (iter.hasNext()) {
	String key = iter.next();

	if (key.startsWith(SUBFACET)) {
	List<String> parts = StrUtils.splitSmart(key, '.');
	if (parts.size() != 3) {
	throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "expected subfacet parameter name of the form subfacet.mykey.field, got:" + key);
	}
	Subfacet sub = new Subfacet();
	sub.parentKey = parts.get(1);
	sub.type = parts.get(2);
	sub.value = params.get(key);

	List<Subfacet> subs = map.get(sub.parentKey);
	if (subs == null) {
	subs = new ArrayList<>(1);
	}
	subs.add(sub);
	map.put(sub.parentKey, subs);
	}
	}

	return map;
	}


	protected void addQueryFacet(String q) {
	parseParams(FacetParams.FACET_QUERY, q);
	Map<String,Object> cmd = new HashMap<String,Object>(2);
	Map<String,Object> type = new HashMap<String,Object>(1);
	type.put("query", cmd);
	cmd.put("q", q);
	addSub(key, type);
	handleSubs(cmd);
	}

	protected void addRangeFacet(String field) {
	parseParams(FacetParams.FACET_RANGE, field);
	Map<String,Object> cmd = new HashMap<String,Object>(5);
	Map<String,Object> type = new HashMap<String,Object>(1);
	type.put("range", cmd);

	String f = key;
	cmd.put("field", facetValue);
	cmd.put("start", required.getFieldParam(f,FacetParams.FACET_RANGE_START));
	cmd.put("end", required.getFieldParam(f,FacetParams.FACET_RANGE_END));
	cmd.put("gap", required.getFieldParam(f, FacetParams.FACET_RANGE_GAP));
	String[] p = params.getFieldParams(f, FacetParams.FACET_RANGE_OTHER);
	if (p != null) cmd.put("other", p.length==1 ? p[0] : Arrays.asList(p));
	p = params.getFieldParams(f, FacetParams.FACET_RANGE_INCLUDE);
	if (p != null) cmd.put("include", p.length==1 ? p[0] : Arrays.asList(p));

	final int mincount = params.getFieldInt(f,FacetParams.FACET_MINCOUNT, 0);
	cmd.put("mincount", mincount);

	boolean hardend = params.getFieldBool(f,FacetParams.FACET_RANGE_HARD_END,false);
	if (hardend) cmd.put("hardend", hardend);

	addSub(key, type);
	handleSubs(cmd);
	}

	protected void addFieldFacet(String field) {
	parseParams(FacetParams.FACET_FIELD, field);

	String f = key; // the parameter to use for per-field parameters... f.key.facet.limit=10

	int offset = params.getFieldInt(f, FacetParams.FACET_OFFSET, 0);
	int limit = params.getFieldInt(f, FacetParams.FACET_LIMIT, 10);

	int mincount = params.getFieldInt(f, FacetParams.FACET_MINCOUNT, 1);

	boolean missing = params.getFieldBool(f, FacetParams.FACET_MISSING, false);

	// default to sorting if there is a limit.
	String sort = params.getFieldParam(f, FacetParams.FACET_SORT, limit>0 ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX);
	String prefix = params.getFieldParam(f, FacetParams.FACET_PREFIX);

	Map<String,Object> cmd = new HashMap<>();
	cmd.put("field", facetValue);
	if (offset != 0) cmd.put("offset", offset);
	if (limit != 10) cmd.put("limit", limit);
	if (mincount != 1) cmd.put("mincount", mincount);
	if (missing) cmd.put("missing", missing);
	if (prefix != null) cmd.put("prefix", prefix);
	if (sort.equals("count")) {
	// our default
	} else if (sort.equals("index")) {
	cmd.put(SORT, "index asc");
	} else {
	cmd.put(SORT, sort); // can be sort by one of our stats
	}

	Map<String,Object> type = new HashMap<>(1);
	type.put("terms", cmd);

	addSub(key, type);
	handleSubs(cmd);
	}

	private void handleSubs(Map<String,Object> cmd) {
	Map<String,Object> savedCmd = currentCommand;
	Map<String,Object> savedSubs = currentSubs;
	try {
	currentCommand = cmd;
	currentSubs = null;

	// parse stats for this facet
	String[] stats = params.getFieldParams(key, "facet.stat");
	if (stats != null) {
	for (String stat : stats) {
	addStat(stat);
	}
	}

	List<Subfacet> subs = subFacets.get(key);
	if (subs != null) {
	for (Subfacet subfacet : subs) {
	if ("field".equals(subfacet.type)) {
	addFieldFacet(subfacet.value);
	} else if ("query".equals(subfacet.type)) {
	addQueryFacet(subfacet.value);
	} else if ("range".equals(subfacet.type)) {
	addQueryFacet(subfacet.value);
	}
	}
	}


	} finally {
	currentCommand = savedCmd;
	currentSubs = savedSubs;
	}
	}


	private void addStat(String val) {
	StrParser sp = new StrParser(val);
	int start = 0;
	sp.eatws();
	if (sp.pos >= sp.end) addStat(val, val);

	// try key:func() format
	String key = null;
	String funcStr = val;

	if (key == null) {
	key = SolrReturnFields.getFieldName(sp);
	if (key != null && sp.opt(':')) {
	// OK, we got the key
	funcStr = val.substring(sp.pos);
	} else {
	// an invalid key... it must not be present.
	sp.pos = start;
	key = null;
	}
	}

	if (key == null) {
	key = funcStr; // not really ideal
	}

	addStat(key, funcStr);
	}

	private void addStat(String key, String val) {
	if ("count".equals(val) \|\| "count()".equals(val)) return; // we no longer have a count function, we always return the count
	getCurrentSubs().put(key, val);
	}

	private void addSub(String key, Map<String,Object> sub) {
	getCurrentSubs().put(key, sub);
	}

	@SuppressWarnings({"unchecked", "rawtypes"})
	private Map<String,Object> getCurrentSubs() {
	if (currentSubs == null) {
	currentSubs = new LinkedHashMap();
	currentCommand.put("facet", currentSubs);
	}
	return currentSubs;
	}



	protected void parseParams(String type, String param) {
	facetValue = param;
	key = param;

	try {
	localParams = QueryParsing.getLocalParams(param, orig);

	if (localParams == null) {
	params = orig;
	required = new RequiredSolrParams(params);
	// setupStats();
	return;
	}

	params = SolrParams.wrapDefaults(localParams, orig);
	required = new RequiredSolrParams(params);

	// remove local params unless it's a query
	if (type != FacetParams.FACET_QUERY) {
	facetValue = localParams.get(CommonParams.VALUE);
	}

	// reset set the default key now that localParams have been removed
	key = facetValue;

	// allow explicit set of the key
	key = localParams.get(CommonParams.OUTPUT_KEY, key);

	// setupStats();
	} catch (SyntaxError e) {
	throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e);
	}
	}


	}