private boolean isValidInputCategory(PrimitiveCategory cat) throws UDFArgumentTypeException { PrimitiveGrouping inputOIGroup = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(cat); if (inputOIGroup == PrimitiveGrouping.STRING_GROUP) { return true; } if (inputOIGroup == PrimitiveGrouping.NUMERIC_GROUP) { switch (cat) { case DOUBLE: case FLOAT: return false; default: return true; } } return false; }
private boolean isValidInputCategory(PrimitiveCategory cat) throws UDFArgumentTypeException { PrimitiveGrouping inputOIGroup = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(cat); if (inputOIGroup == PrimitiveGrouping.STRING_GROUP) { return true; } if (inputOIGroup == PrimitiveGrouping.NUMERIC_GROUP) { switch (cat) { case DOUBLE: case FLOAT: return false; default: return true; } } return false; }
protected void checkIfStringGroup(ObjectInspector[] arguments, int i, String argOrder) throws UDFArgumentTypeException { inputTypes[i] = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputTypes[i]) != PrimitiveGrouping.STRING_GROUP && PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputTypes[i]) != PrimitiveGrouping.VOID_GROUP) { throw new UDFArgumentTypeException(i, getFuncName() + " only takes STRING_GROUP types as " + argOrder + " argument, got " + inputTypes[i]); } }
protected void checkIfStringGroup(ObjectInspector[] arguments, int i, String argOrder) throws UDFArgumentTypeException { inputTypes[i] = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputTypes[i]) != PrimitiveGrouping.STRING_GROUP && PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputTypes[i]) != PrimitiveGrouping.VOID_GROUP) { throw new UDFArgumentTypeException(i, getFuncName() + " only takes STRING_GROUP types as " + argOrder + " argument, got " + inputTypes[i]); } }
protected void checkArgGroups(ObjectInspector[] arguments, int i, PrimitiveCategory[] inputTypes, PrimitiveGrouping... grps) throws UDFArgumentTypeException { PrimitiveCategory inputType = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); for (PrimitiveGrouping grp : grps) { if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputType) == grp) { inputTypes[i] = inputType; return; } } // build error message StringBuilder sb = new StringBuilder(); sb.append(getFuncName()); sb.append(" only takes "); sb.append(grps[0]); for (int j = 1; j < grps.length; j++) { sb.append(", "); sb.append(grps[j]); } sb.append(" types as "); sb.append(getArgOrder(i)); sb.append(" argument, got "); sb.append(inputType); throw new UDFArgumentTypeException(i, sb.toString()); }
protected void checkArgGroups(ObjectInspector[] arguments, int i, PrimitiveCategory[] inputTypes, PrimitiveGrouping... grps) throws UDFArgumentTypeException { PrimitiveCategory inputType = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); for (PrimitiveGrouping grp : grps) { if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputType) == grp) { inputTypes[i] = inputType; return; } } // build error message StringBuilder sb = new StringBuilder(); sb.append(getFuncName()); sb.append(" only takes "); sb.append(grps[0]); for (int j = 1; j < grps.length; j++) { sb.append(", "); sb.append(grps[j]); } sb.append(" types as "); sb.append(getArgOrder(i)); sb.append(" argument, got "); sb.append(inputType); throw new UDFArgumentTypeException(i, sb.toString()); }
public static boolean isStringType(ExprNodeDesc expr) { TypeInfo typeInfo = expr.getTypeInfo(); if (typeInfo.getCategory() == ObjectInspector.Category.PRIMITIVE) { PrimitiveObjectInspector.PrimitiveCategory primitiveCategory = ((PrimitiveTypeInfo) typeInfo).getPrimitiveCategory(); if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(primitiveCategory) == PrimitiveObjectInspectorUtils.PrimitiveGrouping.STRING_GROUP) { return true; } } return false; } // Given an expression this method figures out if the type for the expression is integer
protected boolean isStringOrVoidType(ObjectInspector oi) { if (oi.getCategory() == Category.PRIMITIVE) { if (PrimitiveGrouping.STRING_GROUP == PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector) oi).getPrimitiveCategory()) || ((PrimitiveObjectInspector) oi).getPrimitiveCategory() == PrimitiveCategory.VOID) { return true; } } return false; }
public static PrimitiveCategory getPrimitiveCommonCategory(TypeInfo a, TypeInfo b) { 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 PrimitiveCategory.STRING; } if (pgA == PrimitiveGrouping.DATE_GROUP && pgB == PrimitiveGrouping.STRING_GROUP) { return PrimitiveCategory.STRING; } if (pgB == PrimitiveGrouping.DATE_GROUP && pgA == PrimitiveGrouping.STRING_GROUP) { return PrimitiveCategory.STRING; } Integer ai = TypeInfoUtils.numericTypes.get(pcA); Integer bi = TypeInfoUtils.numericTypes.get(pcB); if (ai == null || bi == null) { // If either is not a numeric type, return null. return null; } return (ai > bi) ? pcA : pcB; }
protected boolean isStringOrVoidType(ObjectInspector oi) { if (oi.getCategory() == Category.PRIMITIVE) { if (PrimitiveGrouping.STRING_GROUP == PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector) oi).getPrimitiveCategory()) || ((PrimitiveObjectInspector) oi).getPrimitiveCategory() == PrimitiveCategory.VOID) { return true; } } return false; }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length != 2) { throw new UDFArgumentLengthException("Encode() requires exactly two arguments"); } if (arguments[0].getCategory() != Category.PRIMITIVE || PrimitiveGrouping.STRING_GROUP != PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector)arguments[0]).getPrimitiveCategory())){ throw new UDFArgumentTypeException( 0, "The first argument to Encode() must be a string/varchar"); } stringOI = (PrimitiveObjectInspector) arguments[0]; if (arguments[1].getCategory() != Category.PRIMITIVE || PrimitiveGrouping.STRING_GROUP != PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector)arguments[1]).getPrimitiveCategory())){ throw new UDFArgumentTypeException( 1, "The second argument to Encode() must be a string/varchar"); } charsetOI = (PrimitiveObjectInspector) arguments[1]; // If the character set for encoding is constant, we can optimize that if (charsetOI instanceof ConstantObjectInspector){ String charSetName = ((ConstantObjectInspector) arguments[1]).getWritableConstantValue().toString(); encoder = Charset.forName(charSetName).newEncoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT); } result = new BytesWritable(); return (ObjectInspector) PrimitiveObjectInspectorFactory.writableBinaryObjectInspector; }
inputType2 = ((PrimitiveObjectInspector) arguments[1]).getPrimitiveCategory(); if ((PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType1) == PrimitiveGrouping.DATE_GROUP || PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType1) == PrimitiveGrouping.STRING_GROUP) && PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType2) == PrimitiveGrouping.STRING_GROUP) { dateTypeArg = true; return initializeDate(arguments); } else if (PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType1) == PrimitiveGrouping.NUMERIC_GROUP && PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType2) == PrimitiveGrouping.NUMERIC_GROUP) { dateTypeArg = false; return initializeNumber(arguments); inputType1 = ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory(); if (PrimitiveObjectInspectorUtils .getPrimitiveGrouping(inputType1) == PrimitiveGrouping.NUMERIC_GROUP) { dateTypeArg = false; return initializeNumber(arguments);
/** * Default implementation for getting the approximate type info for the operator result. * Divide operator overrides this. * @return */ protected PrimitiveTypeInfo deriveResultApproxTypeInfo() { PrimitiveTypeInfo left = (PrimitiveTypeInfo) TypeInfoUtils.getTypeInfoFromObjectInspector(leftOI); PrimitiveTypeInfo right = (PrimitiveTypeInfo) TypeInfoUtils.getTypeInfoFromObjectInspector(rightOI); // string types get converted to double if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(left.getPrimitiveCategory()) == PrimitiveGrouping.STRING_GROUP) { left = TypeInfoFactory.doubleTypeInfo; } if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(right.getPrimitiveCategory()) == PrimitiveGrouping.STRING_GROUP) { right = TypeInfoFactory.doubleTypeInfo; } // Use type promotion PrimitiveCategory commonCat = FunctionRegistry.getPrimitiveCommonCategory(left, right); if (commonCat == PrimitiveCategory.DECIMAL) { // Hive 0.12 behavior where double * decimal -> decimal is gone. return TypeInfoFactory.doubleTypeInfo; } else if (commonCat == null) { return TypeInfoFactory.doubleTypeInfo; } else { return left.getPrimitiveCategory() == commonCat ? left : right; } }
.getPrimitiveGrouping(charsetOI.getPrimitiveCategory())) { throw new UDFArgumentTypeException(1, "The second argument to Decode() must be from string group");
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { for (int idx = 0; idx < Math.min(arguments.length, 3); ++idx) { if (arguments[idx].getCategory() != Category.PRIMITIVE || PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector) arguments[idx]).getPrimitiveCategory()) != PrimitiveGrouping.STRING_GROUP) { throw new UDFArgumentException("All argument should be string/character type"); } } soi_text = ObjectInspectorConverters.getConverter(arguments[0], PrimitiveObjectInspectorFactory.javaStringObjectInspector); if (arguments.length > 1) { soi_de1 = ObjectInspectorConverters.getConverter(arguments[1], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } if (arguments.length > 2) { soi_de2 = ObjectInspectorConverters.getConverter(arguments[2], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } return ObjectInspectorFactory.getStandardMapObjectInspector( PrimitiveObjectInspectorFactory.javaStringObjectInspector, PrimitiveObjectInspectorFactory.javaStringObjectInspector); }
PrimitiveObjectInspector primitive1 = (PrimitiveObjectInspector) arguments[1]; PrimitiveGrouping pcat0 = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(primitive0.getPrimitiveCategory()); PrimitiveGrouping pcat1 = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(primitive1.getPrimitiveCategory());
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length < 1) { throw new UDFArgumentLengthException( "The function CAST as DATE requires at least one argument, got " + arguments.length); } try { argumentOI = (PrimitiveObjectInspector) arguments[0]; PrimitiveCategory pc = argumentOI.getPrimitiveCategory(); PrimitiveGrouping pg = PrimitiveObjectInspectorUtils.getPrimitiveGrouping(pc); switch (pg) { case DATE_GROUP: case STRING_GROUP: case VOID_GROUP: break; default: throw new UDFArgumentException( "CAST as DATE only allows date,string, or timestamp types"); } } catch (ClassCastException e) { throw new UDFArgumentException( "The function CAST as DATE takes only primitive types"); } dc = new DateConverter(argumentOI, PrimitiveObjectInspectorFactory.writableDateObjectInspector); return PrimitiveObjectInspectorFactory.writableDateObjectInspector; }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { for (int idx = 0; idx < Math.min(arguments.length, 3); ++idx) { if (arguments[idx].getCategory() != Category.PRIMITIVE || PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector) arguments[idx]).getPrimitiveCategory()) != PrimitiveGrouping.STRING_GROUP) { throw new UDFArgumentException("All argument should be string/character type"); } } soi_text = ObjectInspectorConverters.getConverter(arguments[0], PrimitiveObjectInspectorFactory.javaStringObjectInspector); if (arguments.length > 1) { soi_de1 = ObjectInspectorConverters.getConverter(arguments[1], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } if (arguments.length > 2) { soi_de2 = ObjectInspectorConverters.getConverter(arguments[2], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } return ObjectInspectorFactory.getStandardMapObjectInspector( PrimitiveObjectInspectorFactory.javaStringObjectInspector, PrimitiveObjectInspectorFactory.javaStringObjectInspector); }
checkArgGroups(arguments, 1, inputTypes, NUMERIC_GROUP); if (PrimitiveObjectInspectorUtils.getPrimitiveGrouping(inputTypes[0]) == STRING_GROUP) { obtainStringConverter(arguments, 0, inputTypes, converters); isStr = true;
if (!PrimitiveObjectInspectorUtils.getPrimitiveGrouping(originTsOI.getPrimitiveCategory()) .equals(PrimitiveObjectInspectorUtils.PrimitiveGrouping.DATE_GROUP)) { throw new UDFArgumentException("Third arg has to be timestamp got " + originTsOI.getTypeInfo().toString()); if (!PrimitiveObjectInspectorUtils.getPrimitiveGrouping(timestampOI.getPrimitiveCategory()) .equals(PrimitiveObjectInspectorUtils.PrimitiveGrouping.DATE_GROUP)) { throw new UDFArgumentException("First arg has to be timestamp got " + timestampOI.getTypeInfo().toString());