UniqTypeNum.java

package org.apache.solr.request.compare;

import java.util.Arrays;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
import org.apache.solr.request.join.HigoJoinSort;

import com.alimama.mdrill.utils.EncodeUtils;

public class UniqTypeNum {
    private static Logger LOG = Logger.getLogger(UniqTypeNum.class);

	static HashMap<String,SortType> typeMap=new HashMap<String, SortType>();
	static{
		typeMap.put("index",  new SortType(0,SortTypeEnum.index));
		typeMap.put("countall", new SortType(1,SortTypeEnum.countall));
		typeMap.put("count", new SortType(2,SortTypeEnum.count));
		typeMap.put("dist", new SortType(3,SortTypeEnum.dist));
		typeMap.put("sum", new SortType(4,SortTypeEnum.sum));
		typeMap.put("max", new SortType(5,SortTypeEnum.max));
		typeMap.put("min", new SortType(6,SortTypeEnum.min));
		typeMap.put("avg", new SortType(7,SortTypeEnum.avg));
		typeMap.put("column",new SortType(8,SortTypeEnum.column));
		typeMap.put("joincolumn",new SortType(9,SortTypeEnum.joincolumn));
	}
	
	
	
	public static enum SortTypeEnum{
		none,index,countall,count,dist,sum,max,min,avg,column,joincolumn
	}
	public static SortType parseType(String type,String fl,String[] groupby,HigoJoinSort[] joinSort)
	{
		int start=groupby.length;
		for(HigoJoinSort s:joinSort)
		{
			if(s.getIndex()>=0)
			{
				start+=s.getIndex();
				SortType rtn=typeMap.get("joincolumn");	
				rtn.sortFieldNum=start;
				return rtn;
			}
			start+=s.getoffset();
		}
		SortType rtn=typeMap.get(type);	
		if(rtn==null)
		{
			return typeMap.get("index");
		}
		
		if(rtn.typeEnum.equals(SortTypeEnum.count)&&fl.indexOf("higoempty_")>=0)
		{
			return typeMap.get("countall");
		}
		
		
		return rtn;
	}
	
	public static class SelectDetailSort{
		public int sortIndex;
		public int offset;
		public int selfOffset;
		public String field;
		public SelectDetailSort(int sortIndex, int offset, int selfOffset,
				String field) {
			this.sortIndex = sortIndex;
			this.offset = offset;
			this.selfOffset = selfOffset;
			this.field = field;
		}
	}
	public static SelectDetailSort parseSelectDetailType(String[] groupby,HigoJoinSort[] joinSort)
	{
		int start=groupby.length;
		for(int i=0;i<joinSort.length;i++)
		{
			HigoJoinSort s=joinSort[i];
			if(s.getIndex()>=0)
			{
				start+=s.getIndex();
				return new SelectDetailSort(i,start, s.getIndex(), s.getSortField());
			}
			start+=s.getoffset();
		}
		
		return null;
	}
	
	public static Integer foundIndex(String[] list,String fl)
	{
		int rtn= foundIndex(list, fl, 0);
//		LOG.info("####"+Arrays.toString(list)+"@"+fl+"@"+rtn);
		return rtn;
	}
	
	public static Integer foundIndex(String[] list,String fl,int def)
	{
		if(fl==null)
		{
			return def;
		}
		if(list!=null)
		{
			for(int i=0;i<list.length;i++)
			{
				if(fl.equals(list[i])){
					return i;
				}
			}
		}
		return def;
	}
	
	public static class SortType{
		public int sortFieldNum=-1;
		@Override
		public String toString() {
			return "SortType [sortFieldNum=" + sortFieldNum + ", typeNum="
					+ typeNum + ", typeEnum=" + typeEnum + "]";
		}
		public int typeNum;
		public SortTypeEnum typeEnum;
		public SortType(int typeNum, SortTypeEnum typeEnum) {
			this.typeNum = typeNum;
			this.typeEnum = typeEnum;
		}
	}
	
	public static int compare(double value1, double value2) {
		return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
    }
	 public static int compare(long value1, long value2) {
			return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
	    }
	 public static int compare(int value1, int value2) {
			return value1 > value2 ? -1 : value1 < value2 ? 1 : 0;
	    }

	public static int compare(int[] a, int[] a2) {
		int len = a.length;
		int cmp = compare(len, a2.length);
		if (cmp != 0) {
			return cmp;
		}

		for (int i = 0; i < len; i++) {
			cmp = compare(a[i], a2[i]);
			if (cmp != 0) {
				return cmp;
			}
		}

		return cmp;
	}
	 public static int compare(String value1, String value2) {
		 return value2.compareTo(value1);
	 }
	 
	 public static int compareStrNum(String value1, String value2) {
		 return compare(filterUnNumber(value1), filterUnNumber(value2));
	 }
	 
	private static Pattern p = Pattern.compile("[^0-9]");

	public static double filterUnNumber(String str) {
		if (str == null || str.isEmpty() || str.indexOf("null") >= 0|| str.indexOf("_") >= 0) {
			return 0d;
		}

		try {
			return Double.parseDouble(str);
		} catch (Throwable e) {
			Matcher m = p.matcher(str);
			String rtn = m.replaceAll("").trim();
			if (rtn.isEmpty()) {
				return 0d;
			}
			return Double.parseDouble(rtn);
		}

	}

	
	 public static int compareDecode(String value1, String value2) {
			return compare(EncodeUtils.decode(value1),EncodeUtils.decode(value2));
	    }
	 
	 public static int compareDecodeNum(String value1, String value2) {
			return compareStrNum(EncodeUtils.decode(value1),EncodeUtils.decode(value2));
	    }
	 
	 

	
	public static int compareDecode(String[] a, String[] a2) {
		int len = a.length;
		int cmp = compare(len, a2.length);
		if (cmp != 0) {
			return cmp;
		}

		for (int i = 0; i < len; i++) {
			cmp = compareDecode(a[i], a2[i]);
			if (cmp != 0) {
				return cmp;
			}
		}

		return cmp;
	}
}