* 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.

*/

* FunctionRegistry.

*/

  private static Log LOG = LogFactory.getLog(FunctionRegistry.class);

  /**

   * The mapping from expression function names to expression classes.

   */

  static Map<String, FunctionInfo> mFunctions = Collections.synchronizedMap(new LinkedHashMap<String, FunctionInfo>());

  /*

   * PTF variables

   * */

  public static final String LEAD_FUNC_NAME = "lead";

  public static final String LAG_FUNC_NAME = "lag";

  public static final String LAST_VALUE_FUNC_NAME = "last_value";

  public static final String WINDOWING_TABLE_FUNCTION = "windowingtablefunction";

  public static final String NOOP_TABLE_FUNCTION = "noop";

  public static final String NOOP_MAP_TABLE_FUNCTION = "noopwithmap";

  static Map<String, WindowFunctionInfo> windowFunctions = Collections.synchronizedMap(new LinkedHashMap<String, WindowFunctionInfo>());

  static {

    registerGenericUDF("concat", GenericUDFConcat.class);

    registerUDF("substr", UDFSubstr.class, false);

    registerUDF("substring", UDFSubstr.class, false);

    registerUDF("space", UDFSpace.class, false);

    registerUDF("repeat", UDFRepeat.class, false);

    registerUDF("ascii", UDFAscii.class, false);

    registerUDF("lpad", UDFLpad.class, false);

    registerUDF("rpad", UDFRpad.class, false);

    registerGenericUDF("size", GenericUDFSize.class);

    registerUDF("round", UDFRound.class, false);

    registerUDF("floor", UDFFloor.class, false);

    registerUDF("sqrt", UDFSqrt.class, false);

    registerUDF("ceil", UDFCeil.class, false);

    registerUDF("ceiling", UDFCeil.class, false);

    registerUDF("rand", UDFRand.class, false);

    registerUDF("abs", UDFAbs.class, false);

    registerUDF("pmod", UDFPosMod.class, false);

    registerUDF("ln", UDFLn.class, false);

    registerUDF("log2", UDFLog2.class, false);

    registerUDF("sin", UDFSin.class, false);

    registerUDF("asin", UDFAsin.class, false);

    registerUDF("cos", UDFCos.class, false);

    registerUDF("acos", UDFAcos.class, false);

    registerUDF("log10", UDFLog10.class, false);

    registerUDF("log", UDFLog.class, false);

    registerUDF("exp", UDFExp.class, false);

    registerUDF("power", UDFPower.class, false);

    registerUDF("pow", UDFPower.class, false);

    registerUDF("sign", UDFSign.class, false);

    registerUDF("pi", UDFPI.class, false);

    registerUDF("degrees", UDFDegrees.class, false);

    registerUDF("radians", UDFRadians.class, false);

    registerUDF("atan", UDFAtan.class, false);

    registerUDF("tan", UDFTan.class, false);

    registerUDF("e", UDFE.class, false);

    registerUDF("conv", UDFConv.class, false);

    registerUDF("bin", UDFBin.class, false);

    registerUDF("hex", UDFHex.class, false);

    registerUDF("unhex", UDFUnhex.class, false);

    registerUDF("base64", UDFBase64.class, false);

    registerUDF("unbase64", UDFUnbase64.class, false);

    registerGenericUDF("encode", GenericUDFEncode.class);

    registerGenericUDF("decode", GenericUDFDecode.class);

    registerGenericUDF("upper", GenericUDFUpper.class);

    registerGenericUDF("lower", GenericUDFLower.class);

    registerGenericUDF("ucase", GenericUDFUpper.class);

    registerGenericUDF("lcase", GenericUDFLower.class);

    registerUDF("trim", UDFTrim.class, false);

    registerUDF("ltrim", UDFLTrim.class, false);

    registerUDF("rtrim", UDFRTrim.class, false);

    registerUDF("length", UDFLength.class, false);

    registerUDF("reverse", UDFReverse.class, false);

    registerGenericUDF("field", GenericUDFField.class);

    registerUDF("find_in_set", UDFFindInSet.class, false);

    registerUDF("like", UDFLike.class, true);

    registerUDF("rlike", UDFRegExp.class, true);

    registerUDF("regexp", UDFRegExp.class, true);

    registerUDF("regexp_replace", UDFRegExpReplace.class, false);

    registerUDF("regexp_extract", UDFRegExpExtract.class, false);

    registerUDF("parse_url", UDFParseUrl.class, false);

    registerGenericUDF("nvl", GenericUDFNvl.class);

    registerGenericUDF("split", GenericUDFSplit.class);

    registerGenericUDF("str_to_map", GenericUDFStringToMap.class);

    registerGenericUDF("translate", GenericUDFTranslate.class);

    registerUDF("positive", UDFOPPositive.class, true, "+");

    registerUDF("negative", UDFOPNegative.class, true, "-");

    registerUDF("day", UDFDayOfMonth.class, false);

    registerUDF("dayofmonth", UDFDayOfMonth.class, false);

    registerUDF("month", UDFMonth.class, false);

    registerUDF("year", UDFYear.class, false);

    registerUDF("hour", UDFHour.class, false);

    registerUDF("minute", UDFMinute.class, false);

    registerUDF("second", UDFSecond.class, false);

    registerUDF("from_unixtime", UDFFromUnixTime.class, false);

    registerUDF("to_date", UDFDate.class, false);

    registerUDF("weekofyear", UDFWeekOfYear.class, false);

    registerUDF("date_add", UDFDateAdd.class, false);

    registerUDF("date_sub", UDFDateSub.class, false);

    registerUDF("datediff", UDFDateDiff.class, false);

    registerUDF("get_json_object", UDFJson.class, false);

    registerUDF("xpath_string", UDFXPathString.class, false);

    registerUDF("xpath_boolean", UDFXPathBoolean.class, false);

    registerUDF("xpath_number", UDFXPathDouble.class, false);

    registerUDF("xpath_double", UDFXPathDouble.class, false);

    registerUDF("xpath_float", UDFXPathFloat.class, false);

    registerUDF("xpath_long", UDFXPathLong.class, false);

    registerUDF("xpath_int", UDFXPathInteger.class, false);

    registerUDF("xpath_short", UDFXPathShort.class, false);

    registerGenericUDF("xpath", GenericUDFXPath.class);

    registerUDF("+", UDFOPPlus.class, true);

    registerUDF("-", UDFOPMinus.class, true);

    registerUDF("*", UDFOPMultiply.class, true);

    registerUDF("/", UDFOPDivide.class, true);

    registerUDF("%", UDFOPMod.class, true);

    registerUDF("div", UDFOPLongDivide.class, true);

    registerUDF("&", UDFOPBitAnd.class, true);

    registerUDF("|", UDFOPBitOr.class, true);

    registerUDF("^", UDFOPBitXor.class, true);

    registerUDF("~", UDFOPBitNot.class, true);

    registerGenericUDF("isnull", GenericUDFOPNull.class);

    registerGenericUDF("isnotnull", GenericUDFOPNotNull.class);

    registerGenericUDF("if", GenericUDFIf.class);

    registerGenericUDF("in", GenericUDFIn.class);

    registerGenericUDF("and", GenericUDFOPAnd.class);

    registerGenericUDF("or", GenericUDFOPOr.class);

    registerGenericUDF("=", GenericUDFOPEqual.class);

    registerGenericUDF("==", GenericUDFOPEqual.class);

    registerGenericUDF("<=>", GenericUDFOPEqualNS.class);

    registerGenericUDF("!=", GenericUDFOPNotEqual.class);

    registerGenericUDF("<>", GenericUDFOPNotEqual.class);

    registerGenericUDF("<", GenericUDFOPLessThan.class);

    registerGenericUDF("<=", GenericUDFOPEqualOrLessThan.class);

    registerGenericUDF(">", GenericUDFOPGreaterThan.class);

    registerGenericUDF(">=", GenericUDFOPEqualOrGreaterThan.class);

    registerGenericUDF("not", GenericUDFOPNot.class);

    registerGenericUDF("!", GenericUDFOPNot.class);

    registerGenericUDF("between", GenericUDFBetween.class);

    registerGenericUDF("ewah_bitmap_and", GenericUDFEWAHBitmapAnd.class);

    registerGenericUDF("ewah_bitmap_or", GenericUDFEWAHBitmapOr.class);

    registerGenericUDF("ewah_bitmap_empty", GenericUDFEWAHBitmapEmpty.class);

    // Aliases for Java Class Names

    // These are used in getImplicitConvertUDFMethod

    registerUDF(serdeConstants.BOOLEAN_TYPE_NAME, UDFToBoolean.class, false,

        UDFToBoolean.class.getSimpleName());

    registerUDF(serdeConstants.TINYINT_TYPE_NAME, UDFToByte.class, false,

        UDFToByte.class.getSimpleName());

    registerUDF(serdeConstants.SMALLINT_TYPE_NAME, UDFToShort.class, false,

        UDFToShort.class.getSimpleName());

    registerUDF(serdeConstants.INT_TYPE_NAME, UDFToInteger.class, false,

        UDFToInteger.class.getSimpleName());

    registerUDF(serdeConstants.BIGINT_TYPE_NAME, UDFToLong.class, false,

        UDFToLong.class.getSimpleName());

    registerUDF(serdeConstants.FLOAT_TYPE_NAME, UDFToFloat.class, false,

        UDFToFloat.class.getSimpleName());

    registerUDF(serdeConstants.DOUBLE_TYPE_NAME, UDFToDouble.class, false,

        UDFToDouble.class.getSimpleName());

    registerUDF(serdeConstants.STRING_TYPE_NAME, UDFToString.class, false,

        UDFToString.class.getSimpleName());

    registerGenericUDF(serdeConstants.DATE_TYPE_NAME,

        GenericUDFToDate.class);

    registerGenericUDF(serdeConstants.TIMESTAMP_TYPE_NAME,

        GenericUDFTimestamp.class);

    registerGenericUDF(serdeConstants.BINARY_TYPE_NAME,

        GenericUDFToBinary.class);

    registerGenericUDF(serdeConstants.DECIMAL_TYPE_NAME,

        GenericUDFToDecimal.class);

    registerGenericUDF(serdeConstants.VARCHAR_TYPE_NAME,

        GenericUDFToVarchar.class);

    // Aggregate functions

    registerGenericUDAF("max", new GenericUDAFMax());

    registerGenericUDAF("min", new GenericUDAFMin());

    registerGenericUDAF("sum", new GenericUDAFSum());

    registerGenericUDAF("count", new GenericUDAFCount());

    registerGenericUDAF("avg", new GenericUDAFAverage());

    registerGenericUDAF("std", new GenericUDAFStd());

    registerGenericUDAF("stddev", new GenericUDAFStd());

    registerGenericUDAF("stddev_pop", new GenericUDAFStd());

    registerGenericUDAF("stddev_samp", new GenericUDAFStdSample());

    registerGenericUDAF("variance", new GenericUDAFVariance());

    registerGenericUDAF("var_pop", new GenericUDAFVariance());

    registerGenericUDAF("var_samp", new GenericUDAFVarianceSample());

    registerGenericUDAF("covar_pop", new GenericUDAFCovariance());

    registerGenericUDAF("covar_samp", new GenericUDAFCovarianceSample());

    registerGenericUDAF("corr", new GenericUDAFCorrelation());

    registerGenericUDAF("histogram_numeric", new GenericUDAFHistogramNumeric());

    registerGenericUDAF("percentile_approx", new GenericUDAFPercentileApprox());

    registerGenericUDAF("collect_set", new GenericUDAFCollectSet());

    registerGenericUDAF("ngrams", new GenericUDAFnGrams());

    registerGenericUDAF("context_ngrams", new GenericUDAFContextNGrams());

    registerGenericUDAF("ewah_bitmap", new GenericUDAFEWAHBitmap());

    registerGenericUDAF("compute_stats" , new GenericUDAFComputeStats());

    registerUDAF("percentile", UDAFPercentile.class);

    // Generic UDFs

    registerGenericUDF("reflect", GenericUDFReflect.class);

    registerGenericUDF("reflect2", GenericUDFReflect2.class);

    registerGenericUDF("java_method", GenericUDFReflect.class);

    registerGenericUDF("array", GenericUDFArray.class);

    registerGenericUDF("assert_true", GenericUDFAssertTrue.class);

    registerGenericUDF("map", GenericUDFMap.class);

    registerGenericUDF("struct", GenericUDFStruct.class);

    registerGenericUDF("named_struct", GenericUDFNamedStruct.class);

    registerGenericUDF("create_union", GenericUDFUnion.class);

    registerGenericUDF("case", GenericUDFCase.class);

    registerGenericUDF("when", GenericUDFWhen.class);

    registerGenericUDF("hash", GenericUDFHash.class);

    registerGenericUDF("coalesce", GenericUDFCoalesce.class);

    registerGenericUDF("index", GenericUDFIndex.class);

    registerGenericUDF("in_file", GenericUDFInFile.class);

    registerGenericUDF("instr", GenericUDFInstr.class);

    registerGenericUDF("locate", GenericUDFLocate.class);

    registerGenericUDF("elt", GenericUDFElt.class);

    registerGenericUDF("concat_ws", GenericUDFConcatWS.class);

    registerGenericUDF("sort_array", GenericUDFSortArray.class);

    registerGenericUDF("array_contains", GenericUDFArrayContains.class);

    registerGenericUDF("sentences", GenericUDFSentences.class);

    registerGenericUDF("map_keys", GenericUDFMapKeys.class);

    registerGenericUDF("map_values", GenericUDFMapValues.class);

    registerGenericUDF("format_number", GenericUDFFormatNumber.class);

    registerGenericUDF("printf", GenericUDFPrintf.class);

    registerGenericUDF("from_utc_timestamp", GenericUDFFromUtcTimestamp.class);

    registerGenericUDF("to_utc_timestamp", GenericUDFToUtcTimestamp.class);

    registerGenericUDF("unix_timestamp", GenericUDFUnixTimeStamp.class);

    registerGenericUDF("to_unix_timestamp", GenericUDFToUnixTimeStamp.class);

    // Generic UDTF's

    registerGenericUDTF("explode", GenericUDTFExplode.class);

    registerGenericUDTF("inline", GenericUDTFInline.class);

    registerGenericUDTF("json_tuple", GenericUDTFJSONTuple.class);

    registerGenericUDTF("parse_url_tuple", GenericUDTFParseUrlTuple.class);

    registerGenericUDTF("stack", GenericUDTFStack.class);

    //PTF declarations

    registerGenericUDF(true, LEAD_FUNC_NAME, GenericUDFLead.class);

    registerGenericUDF(true, LAG_FUNC_NAME, GenericUDFLag.class);

    registerHiveUDAFsAsWindowFunctions();

    registerWindowFunction("row_number", new GenericUDAFRowNumber());

    registerWindowFunction("rank", new GenericUDAFRank());

    registerWindowFunction("dense_rank", new GenericUDAFDenseRank());

    registerWindowFunction("percent_rank", new GenericUDAFPercentRank());

    registerWindowFunction("cume_dist", new GenericUDAFCumeDist());

    registerWindowFunction("ntile", new GenericUDAFNTile());

    registerWindowFunction("first_value", new GenericUDAFFirstValue());

    registerWindowFunction("last_value", new GenericUDAFLastValue());

    registerWindowFunction(LEAD_FUNC_NAME, new GenericUDAFLead(), false);

    registerWindowFunction(LAG_FUNC_NAME, new GenericUDAFLag(), false);

    registerTableFunction(NOOP_TABLE_FUNCTION, NoopResolver.class);

    registerTableFunction(NOOP_MAP_TABLE_FUNCTION, NoopWithMapResolver.class);

    registerTableFunction(WINDOWING_TABLE_FUNCTION,  WindowingTableFunctionResolver.class);

    registerTableFunction("matchpath", MatchPathResolver.class);

  }

  public static void registerTemporaryUDF(String functionName,

      Class<? extends UDF> UDFClass, boolean isOperator) {

    registerUDF(false, functionName, UDFClass, isOperator);

  }

  static void registerUDF(String functionName, Class<? extends UDF> UDFClass,

      boolean isOperator) {

    registerUDF(true, functionName, UDFClass, isOperator);

  }

  public static void registerUDF(boolean isNative, String functionName,

      Class<? extends UDF> UDFClass, boolean isOperator) {

    registerUDF(isNative, functionName, UDFClass, isOperator, functionName

        .toLowerCase());

  }

  public static void registerUDF(String functionName,

      Class<? extends UDF> UDFClass, boolean isOperator, String displayName) {

    registerUDF(true, functionName, UDFClass, isOperator, displayName);

  }

  public static void registerUDF(boolean isNative, String functionName,

      Class<? extends UDF> UDFClass, boolean isOperator, String displayName) {

    if (UDF.class.isAssignableFrom(UDFClass)) {

      FunctionInfo fI = new FunctionInfo(isNative, displayName,

          new GenericUDFBridge(displayName, isOperator, UDFClass));

      mFunctions.put(functionName.toLowerCase(), fI);

    } else {

      throw new RuntimeException("Registering UDF Class " + UDFClass

          + " which does not extend " + UDF.class);

    }

  }

  public static void registerTemporaryGenericUDF(String functionName,

      Class<? extends GenericUDF> genericUDFClass) {

    registerGenericUDF(false, functionName, genericUDFClass);

  }

  static void registerGenericUDF(String functionName,

      Class<? extends GenericUDF> genericUDFClass) {

    registerGenericUDF(true, functionName, genericUDFClass);

  }

  public static void registerGenericUDF(boolean isNative, String functionName,

      Class<? extends GenericUDF> genericUDFClass) {

    if (GenericUDF.class.isAssignableFrom(genericUDFClass)) {

      FunctionInfo fI = new FunctionInfo(isNative, functionName,

          (GenericUDF) ReflectionUtils.newInstance(genericUDFClass, null));

      mFunctions.put(functionName.toLowerCase(), fI);

    } else {

      throw new RuntimeException("Registering GenericUDF Class "

          + genericUDFClass + " which does not extend " + GenericUDF.class);

    }

  }

  public static void registerTemporaryGenericUDTF(String functionName,

      Class<? extends GenericUDTF> genericUDTFClass) {

    registerGenericUDTF(false, functionName, genericUDTFClass);

  }

  static void registerGenericUDTF(String functionName,

      Class<? extends GenericUDTF> genericUDTFClass) {

    registerGenericUDTF(true, functionName, genericUDTFClass);

  }

  public static void registerGenericUDTF(boolean isNative, String functionName,

      Class<? extends GenericUDTF> genericUDTFClass) {

    if (GenericUDTF.class.isAssignableFrom(genericUDTFClass)) {

      FunctionInfo fI = new FunctionInfo(isNative, functionName,

          (GenericUDTF) ReflectionUtils.newInstance(genericUDTFClass, null));

      mFunctions.put(functionName.toLowerCase(), fI);

    } else {

      throw new RuntimeException("Registering GenericUDTF Class "

          + genericUDTFClass + " which does not extend " + GenericUDTF.class);

    }

  }

  public static FunctionInfo getFunctionInfo(String functionName) {

    return mFunctions.get(functionName.toLowerCase());

  }

  /**

   * Returns a set of registered function names. This is used for the CLI

   * command "SHOW FUNCTIONS;"

   *

   * @return set of strings contains function names

   */

  public static Set<String> getFunctionNames() {

    return mFunctions.keySet();

  }

  /**

   * Returns a set of registered function names. This is used for the CLI

   * command "SHOW FUNCTIONS 'regular expression';" Returns an empty set when

   * the regular expression is not valid.

   *

   * @param funcPatternStr

   *          regular expression of the interested function names

   * @return set of strings contains function names

   */

  public static Set<String> getFunctionNames(String funcPatternStr) {

    Set<String> funcNames = new TreeSet<String>();

    Pattern funcPattern = null;

    try {

      funcPattern = Pattern.compile(funcPatternStr);

    } catch (PatternSyntaxException e) {

      return funcNames;

    }

    for (String funcName : mFunctions.keySet()) {

      if (funcPattern.matcher(funcName).matches()) {

        funcNames.add(funcName);

      }

    }

    return funcNames;

  }

  /**

   * Returns the set of synonyms of the supplied function.

   *

   * @param funcName

   *          the name of the function

   * @return Set of synonyms for funcName

   */

  public static Set<String> getFunctionSynonyms(String funcName) {

    Set<String> synonyms = new HashSet<String>();

    FunctionInfo funcInfo = getFunctionInfo(funcName);

    if (null == funcInfo) {

      return synonyms;

    }

    Class<?> funcClass = funcInfo.getFunctionClass();

    for (String name : mFunctions.keySet()) {

      if (name.equals(funcName)) {

        continue;

      }

      if (mFunctions.get(name).getFunctionClass().equals(funcClass)) {

        synonyms.add(name);

      }

    }

    return synonyms;

  }

  // The ordering of types here is used to determine which numeric types

  // are common/convertible to one another. Probably better to rely on the

  // ordering explicitly defined here than to assume that the enum values

  // that were arbitrarily assigned in PrimitiveCategory work for our purposes.

  static EnumMap<PrimitiveCategory, Integer> numericTypes =

      new EnumMap<PrimitiveCategory, Integer>(PrimitiveCategory.class);

  static List<PrimitiveCategory> numericTypeList = new ArrayList<PrimitiveCategory>();

  static void registerNumericType(PrimitiveCategory primitiveCategory, int level) {

    numericTypeList.add(primitiveCategory);

    numericTypes.put(primitiveCategory, level);

  }

  static {

    registerNumericType(PrimitiveCategory.BYTE, 1);

    registerNumericType(PrimitiveCategory.SHORT, 2);

    registerNumericType(PrimitiveCategory.INT, 3);

    registerNumericType(PrimitiveCategory.LONG, 4);

    registerNumericType(PrimitiveCategory.FLOAT, 5);

    registerNumericType(PrimitiveCategory.DOUBLE, 6);

    registerNumericType(PrimitiveCategory.DECIMAL, 7);

    registerNumericType(PrimitiveCategory.STRING, 8);

  }

  static int getCommonLength(int aLen, int bLen) {

    int maxLength;

    if (aLen < 0 || bLen < 0) {

      // negative length should take precedence over positive value?

      maxLength = -1;

    } else {

      maxLength = Math.max(aLen, bLen);

    }

    return maxLength;

  }

  /**

   * Given 2 TypeInfo types and the PrimitiveCategory selected as the common class between the two,

   * return a TypeInfo corresponding to the common PrimitiveCategory, and with type qualifiers

   * (if applicable) that match the 2 TypeInfo types.

   * Examples:

   *   varchar(10), varchar(20), primitive category varchar => varchar(20)

   *   date, string, primitive category string => string

   * @param a  TypeInfo of the first type

   * @param b  TypeInfo of the second type

   * @param typeCategory PrimitiveCategory of the designated common type between a and b

   * @return TypeInfo represented by the primitive category, with any applicable type qualifiers.

   */

  public static TypeInfo getTypeInfoForPrimitiveCategory(

      PrimitiveTypeInfo a, PrimitiveTypeInfo b, PrimitiveCategory typeCategory) {

    // For types with parameters (like varchar), we need to determine the type parameters

    // that should be added to this type, based on the original 2 TypeInfos.

    switch (typeCategory) {

      case VARCHAR:

        int maxLength = getCommonLength(

            TypeInfoUtils.getCharacterLengthForType(a),

            TypeInfoUtils.getCharacterLengthForType(b));

        VarcharTypeParams varcharParams = new VarcharTypeParams();

        varcharParams.setLength(maxLength);

        // Generate type name so that we can retrieve the TypeInfo for that type.

        String typeName = PrimitiveObjectInspectorUtils

            .getTypeEntryFromTypeSpecs(typeCategory, varcharParams).toString();

        return TypeInfoFactory.getPrimitiveTypeInfo(typeName);

      default:

        // Type doesn't require any qualifiers.

        return TypeInfoFactory.getPrimitiveTypeInfo(

          PrimitiveObjectInspectorUtils.getTypeEntryFromPrimitiveCategory(typeCategory).typeName);

    }

  }

  /**

   * Find a common class for union-all operator

   */

  public static TypeInfo getCommonClassForUnionAll(TypeInfo a, TypeInfo b) {

    if (a.equals(b)) {

      return a;

    }

    if (a.getCategory() != Category.PRIMITIVE || b.getCategory() != Category.PRIMITIVE) {

      return null;

    }

    PrimitiveCategory pcA = ((PrimitiveTypeInfo)a).getPrimitiveCategory();

    PrimitiveCategory pcB = ((PrimitiveTypeInfo)b).getPrimitiveCategory();

    if (pcA == pcB) {

      // Same primitive category but different qualifiers.

      return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, pcA);

    }

    PrimitiveGrouping pgA = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcA);

    PrimitiveGrouping pgB = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcB);

    // handle string types properly

    if (pgA == PrimitiveGrouping.STRING_GROUP && pgB == PrimitiveGrouping.STRING_GROUP) {

      return getTypeInfoForPrimitiveCategory(

          (PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b,PrimitiveCategory.STRING);

    }

    if (FunctionRegistry.implicitConvertable(a, b)) {

      return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, pcB);

    }

    if (FunctionRegistry.implicitConvertable(b, a)) {

      return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, pcA);

    }

    for (PrimitiveCategory t : numericTypeList) {

      if (FunctionRegistry.implicitConvertable(pcA, t)

          && FunctionRegistry.implicitConvertable(pcB, t)) {

        return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, t);

      }

    }

    return null;

  }

  /**

   * Find a common class that objects of both TypeInfo a and TypeInfo b can

   * convert to. This is used for comparing objects of type a and type b.

   *

   * When we are comparing string and double, we will always convert both of

   * them to double and then compare.

   *

   * @return null if no common class could be found.

   */

  public static TypeInfo getCommonClassForComparison(TypeInfo a, TypeInfo b) {

    // If same return one of them

    if (a.equals(b)) {

      return a;

    }

    if (a.getCategory() != Category.PRIMITIVE || b.getCategory() != Category.PRIMITIVE) {

      return null;

    }

    PrimitiveCategory pcA = ((PrimitiveTypeInfo)a).getPrimitiveCategory();

    PrimitiveCategory pcB = ((PrimitiveTypeInfo)b).getPrimitiveCategory();

    if (pcA == pcB) {

      // Same primitive category but different qualifiers.

      // Rely on getTypeInfoForPrimitiveCategory() to sort out the type params.

      return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, pcA);

    }

    PrimitiveGrouping pgA = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcA);

    PrimitiveGrouping pgB = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcB);

    // handle string types properly

    if (pgA == PrimitiveGrouping.STRING_GROUP && pgB == PrimitiveGrouping.STRING_GROUP) {

      // Compare as strings. Char comparison semantics may be different if/when implemented.

      return getTypeInfoForPrimitiveCategory(

          (PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b,PrimitiveCategory.STRING);

    }

    for (PrimitiveCategory t : numericTypeList) {

      if (FunctionRegistry.implicitConvertable(pcA, t)

          && FunctionRegistry.implicitConvertable(pcB, t)) {

        return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, t);

      }

    }

    return null;

  }

  /**

   * Find a common class that objects of both TypeInfo a and TypeInfo b can

   * convert to. This is used for places other than comparison.

   *

   * The common class of string and double is string.

   *

   * @return null if no common class could be found.

   */

  public static TypeInfo getCommonClass(TypeInfo a, TypeInfo b) {

    if (a.equals(b)) {

      return a;

    }

    if (a.getCategory() != Category.PRIMITIVE || b.getCategory() != Category.PRIMITIVE) {

      return null;

    }

    PrimitiveCategory pcA = ((PrimitiveTypeInfo)a).getPrimitiveCategory();

    PrimitiveCategory pcB = ((PrimitiveTypeInfo)b).getPrimitiveCategory();

    PrimitiveGrouping pgA = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcA);

    PrimitiveGrouping pgB = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pcB);

    // handle string types properly

    if (pgA == PrimitiveGrouping.STRING_GROUP && pgB == PrimitiveGrouping.STRING_GROUP) {

      return getTypeInfoForPrimitiveCategory(

          (PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b,PrimitiveCategory.STRING);

    }

    Integer ai = numericTypes.get(pcA);

    Integer bi = numericTypes.get(pcB);

    if (ai == null || bi == null) {

      // If either is not a numeric type, return null.

      return null;

    }

    PrimitiveCategory pcCommon = (ai > bi) ? pcA : pcB;

    return getTypeInfoForPrimitiveCategory((PrimitiveTypeInfo)a, (PrimitiveTypeInfo)b, pcCommon);

  }

  public static boolean implicitConvertable(PrimitiveCategory from, PrimitiveCategory to) {

    if (from == to) {

      return true;

    }

    PrimitiveGrouping fromPg = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(from);

    PrimitiveGrouping toPg = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(to);

    // Allow implicit String to Double conversion

    if (fromPg == PrimitiveGrouping.STRING_GROUP && to == PrimitiveCategory.DOUBLE) {

      return true;

    }

    // Allow implicit String to Decimal conversion

    if (fromPg == PrimitiveGrouping.STRING_GROUP && to == PrimitiveCategory.DECIMAL) {

      return true;

    }

    // Void can be converted to any type

    if (from == PrimitiveCategory.VOID) {

      return true;

    }

    // Allow implicit String to Date conversion

    if (fromPg == PrimitiveGrouping.DATE_GROUP && toPg == PrimitiveGrouping.STRING_GROUP) {

      return true;

    }

    // Allow implicit Numeric to String conversion

    if (fromPg == PrimitiveGrouping.NUMERIC_GROUP && toPg == PrimitiveGrouping.STRING_GROUP) {

      return true;

    }

    // Allow implicit String to varchar conversion, and vice versa

    if (fromPg == PrimitiveGrouping.STRING_GROUP && toPg == PrimitiveGrouping.STRING_GROUP) {

      return true;

    }

    // Allow implicit conversion from Byte -> Integer -> Long -> Float -> Double

    // Decimal -> String

    Integer f = numericTypes.get(from);

    Integer t = numericTypes.get(to);

    if (f == null || t == null) {

      return false;

    }

    if (f.intValue() > t.intValue()) {

      return false;

    }

    return true;

  }

  /**

   * Returns whether it is possible to implicitly convert an object of Class

   * from to Class to.

   */

  public static boolean implicitConvertable(TypeInfo from, TypeInfo to) {

    if (from.equals(to)) {

      return true;

    }

    // Reimplemented to use PrimitiveCategory rather than TypeInfo, because

    // 2 TypeInfos from the same qualified type (varchar, decimal) should still be

    // seen as equivalent.

    if (from.getCategory() == Category.PRIMITIVE && to.getCategory() == Category.PRIMITIVE) {

      return implicitConvertable(

          ((PrimitiveTypeInfo)from).getPrimitiveCategory(),

          ((PrimitiveTypeInfo)to).getPrimitiveCategory());

    }

    return false;

  }

  /**

   * Get the GenericUDAF evaluator for the name and argumentClasses.

   *

   * @param name

   *          the name of the UDAF

   * @param argumentOIs

   * @param isDistinct

   * @param isAllColumns

   * @return The UDAF evaluator

   */

  @SuppressWarnings("deprecation")

  public static GenericUDAFEvaluator getGenericUDAFEvaluator(String name,

      List<ObjectInspector> argumentOIs, boolean isDistinct,

      boolean isAllColumns) throws SemanticException {

    GenericUDAFResolver udafResolver = getGenericUDAFResolver(name);

    if (udafResolver == null) {

      return null;

    }

    GenericUDAFEvaluator udafEvaluator = null;

    ObjectInspector args[] = new ObjectInspector[argumentOIs.size()];

    // Can't use toArray here because Java is dumb when it comes to

    // generics + arrays.

    for (int ii = 0; ii < argumentOIs.size(); ++ii) {

      args[ii] = argumentOIs.get(ii);

    }

    GenericUDAFParameterInfo paramInfo =

        new SimpleGenericUDAFParameterInfo(

            args, isDistinct, isAllColumns);

    if (udafResolver instanceof GenericUDAFResolver2) {

      udafEvaluator =

          ((GenericUDAFResolver2) udafResolver).getEvaluator(paramInfo);

    } else {

      udafEvaluator = udafResolver.getEvaluator(paramInfo.getParameters());

    }

    return udafEvaluator;

  }

  @SuppressWarnings("deprecation")

  public static GenericUDAFEvaluator getGenericWindowingEvaluator(String name,

      List<ObjectInspector> argumentOIs, boolean isDistinct,

      boolean isAllColumns) throws SemanticException {

    WindowFunctionInfo finfo = windowFunctions.get(name.toLowerCase());

    if (finfo == null) { return null;}

    if ( !name.toLowerCase().equals(LEAD_FUNC_NAME) &&

    !name.toLowerCase().equals(LAG_FUNC_NAME) ) {

    return getGenericUDAFEvaluator(name, argumentOIs, isDistinct, isAllColumns);

    }

    // this must be lead/lag UDAF

    ObjectInspector args[] = new ObjectInspector[argumentOIs.size()];

    GenericUDAFResolver udafResolver = finfo.getfInfo().getGenericUDAFResolver();

    GenericUDAFParameterInfo paramInfo = new SimpleGenericUDAFParameterInfo(

    argumentOIs.toArray(args), isDistinct, isAllColumns);

    return ((GenericUDAFResolver2) udafResolver).getEvaluator(paramInfo);

  }

  /**

   * This method is shared between UDFRegistry and UDAFRegistry. methodName will

   * be "evaluate" for UDFRegistry, and "aggregate"/"evaluate"/"evaluatePartial"

   * for UDAFRegistry.

   * @throws UDFArgumentException

   */

  public static <T> Method getMethodInternal(Class<? extends T> udfClass,

      String methodName, boolean exact, List<TypeInfo> argumentClasses)

      throws UDFArgumentException {

    List<Method> mlist = new ArrayList<Method>();

    for (Method m : udfClass.getMethods()) {

      if (m.getName().equals(methodName)) {

        mlist.add(m);

      }

    }

    return getMethodInternal(udfClass, mlist, exact, argumentClasses);

  }

  public static void registerTemporaryGenericUDAF(String functionName,

      GenericUDAFResolver genericUDAFResolver) {

    registerGenericUDAF(false, functionName, genericUDAFResolver);

  }

  static void registerGenericUDAF(String functionName,

      GenericUDAFResolver genericUDAFResolver) {

    registerGenericUDAF(true, functionName, genericUDAFResolver);

  }

  public static void registerGenericUDAF(boolean isNative, String functionName,

      GenericUDAFResolver genericUDAFResolver) {

    mFunctions.put(functionName.toLowerCase(), new FunctionInfo(isNative,

        functionName.toLowerCase(), genericUDAFResolver));

  }

  public static void registerTemporaryUDAF(String functionName,

      Class<? extends UDAF> udafClass) {

    registerUDAF(false, functionName, udafClass);

  }

  static void registerUDAF(String functionName, Class<? extends UDAF> udafClass) {

    registerUDAF(true, functionName, udafClass);

  }

  public static void registerUDAF(boolean isNative, String functionName,

      Class<? extends UDAF> udafClass) {

    mFunctions.put(functionName.toLowerCase(), new FunctionInfo(isNative,

        functionName.toLowerCase(), new GenericUDAFBridge(

        (UDAF) ReflectionUtils.newInstance(udafClass, null))));

  }

  public static void unregisterTemporaryUDF(String functionName) throws HiveException {

    FunctionInfo fi = mFunctions.get(functionName.toLowerCase());

    if (fi != null) {

      if (!fi.isNative()) {

        mFunctions.remove(functionName.toLowerCase());

      } else {

        throw new HiveException("Function " + functionName

            + " is hive native, it can't be dropped");

      }

    }

  }

  public static GenericUDAFResolver getGenericUDAFResolver(String functionName) {

    if (LOG.isDebugEnabled()) {

      LOG.debug("Looking up GenericUDAF: " + functionName);

    }

    FunctionInfo finfo = mFunctions.get(functionName.toLowerCase());

    if (finfo == null) {

      return null;

    }

    GenericUDAFResolver result = finfo.getGenericUDAFResolver();

    return result;

  }

  public static Object invoke(Method m, Object thisObject, Object... arguments)

      throws HiveException {

    Object o;

    try {

      o = m.invoke(thisObject, arguments);

    } catch (Exception e) {

      String thisObjectString = "" + thisObject + " of class "

          + (thisObject == null ? "null" : thisObject.getClass().getName());

      StringBuilder argumentString = new StringBuilder();

      if (arguments == null) {

        argumentString.append("null");

      } else {

        argumentString.append("{");

        for (int i = 0; i < arguments.length; i++) {

          if (i > 0) {

            argumentString.append(", ");

          }

          if (arguments[i] == null) {

            argumentString.append("null");

          } else {

            argumentString.append("" + arguments[i] + ":"

                + arguments[i].getClass().getName());

          }

        }

        argumentString.append("} of size " + arguments.length);

      }

      throw new HiveException("Unable to execute method " + m + " "

          + " on object " + thisObjectString + " with arguments "

          + argumentString.toString(), e);

    }

    return o;

  }

  /**

   * Returns -1 if passed does not match accepted. Otherwise return the cost

   * (usually 0 for no conversion and 1 for conversion).

   */

  public static int matchCost(TypeInfo argumentPassed,

      TypeInfo argumentAccepted, boolean exact) {

    if (argumentAccepted.equals(argumentPassed)