if(!conversionHelper.update(oi)) { StringBuilder sb = new StringBuilder(); sb.append("The arguments for IN should be the same type! Types are: {");
returnOIResolver.update(arguments[0]);
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentTypeException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i + 1 < arguments.length; i += 2) { if (!arguments[i].getTypeName().equals(serdeConstants.BOOLEAN_TYPE_NAME)) { throw new UDFArgumentTypeException(i, "\"" + serdeConstants.BOOLEAN_TYPE_NAME + "\" is expected after WHEN, " + "but \"" + arguments[i].getTypeName() + "\" is found"); } if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expressions after THEN should have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i + 1].getTypeName() + "\" is found"); } } if (arguments.length % 2 == 1) { int i = arguments.length - 2; if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expression after ELSE should have the same type as those after THEN: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i + 1].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }
+ "\" is found"); if (!keyOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "Key type \"" + arguments[i].getTypeName() if (!valueOIResolver.update(arguments[i]) && !compatibleTypes(arguments[i], arguments[i-2])) { throw new UDFArgumentTypeException(i, "Value type \"" + arguments[i].getTypeName()
returnOIResolver.update(arguments[0]);
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (arguments.length != 3) { throw new UDFArgumentLengthException( "The function IF(expr1,expr2,expr3) accepts exactly 3 arguments."); } boolean conditionTypeIsOk = (arguments[0].getCategory() == ObjectInspector.Category.PRIMITIVE); if (conditionTypeIsOk) { PrimitiveObjectInspector poi = ((PrimitiveObjectInspector) arguments[0]); conditionTypeIsOk = (poi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.BOOLEAN || poi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.VOID); } if (!conditionTypeIsOk) { throw new UDFArgumentTypeException(0, "The first argument of function IF should be \"" + serdeConstants.BOOLEAN_TYPE_NAME + "\", but \"" + arguments[0].getTypeName() + "\" is found"); } if (!(returnOIResolver.update(arguments[1]) && returnOIResolver .update(arguments[2]))) { throw new UDFArgumentTypeException(2, "The second and the third arguments of function IF should have the same type, " + "but they are different: \"" + arguments[1].getTypeName() + "\" and \"" + arguments[2].getTypeName() + "\""); } return returnOIResolver.get(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentTypeException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i + 1 < arguments.length; i += 2) { if (!arguments[i].getTypeName().equals(serdeConstants.BOOLEAN_TYPE_NAME)) { throw new UDFArgumentTypeException(i, "\"" + serdeConstants.BOOLEAN_TYPE_NAME + "\" is expected after WHEN, " + "but \"" + arguments[i].getTypeName() + "\" is found"); } if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expressions after THEN should have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i + 1].getTypeName() + "\" is found"); } } if (arguments.length % 2 == 1) { int i = arguments.length - 2; if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expression after ELSE should have the same type as those after THEN: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i + 1].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }
returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); boolean r = caseOIResolver.update(arguments[0]); assert (r); for (int i = 1; i + 1 < arguments.length; i += 2) { if (!caseOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "The expressions after WHEN should have the same type with that after CASE: \"" + arguments[i].getTypeName() + "\" is found"); if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expressions after THEN should have the same type: \"" if (!returnOIResolver.update(arguments[i + 1])) { throw new UDFArgumentTypeException(i + 1, "The expression after ELSE should have the same type as those after THEN: \""
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (arguments.length != 3) { throw new UDFArgumentLengthException( "The function IF(expr1,expr2,expr3) accepts exactly 3 arguments."); } boolean conditionTypeIsOk = (arguments[0].getCategory() == ObjectInspector.Category.PRIMITIVE); if (conditionTypeIsOk) { PrimitiveObjectInspector poi = ((PrimitiveObjectInspector) arguments[0]); conditionTypeIsOk = (poi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.BOOLEAN || poi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.VOID); } if (!conditionTypeIsOk) { throw new UDFArgumentTypeException(0, "The first argument of function IF should be \"" + serdeConstants.BOOLEAN_TYPE_NAME + "\", but \"" + arguments[0].getTypeName() + "\" is found"); } if (!(returnOIResolver.update(arguments[1]) && returnOIResolver .update(arguments[2]))) { throw new UDFArgumentTypeException(2, "The second and the third arguments of function IF should have the same type, " + "but they are different: \"" + arguments[1].getTypeName() + "\" and \"" + arguments[2].getTypeName() + "\""); } return returnOIResolver.get(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { GenericUDFUtils.ReturnObjectInspectorResolver returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i < arguments.length; i++) { if (!returnOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "Argument type \"" + arguments[i].getTypeName() + "\" is different from preceding arguments. " + "Previous type was \"" + arguments[i - 1].getTypeName() + "\""); } } converters = new Converter[arguments.length]; ObjectInspector returnOI = returnOIResolver.get(PrimitiveObjectInspectorFactory.javaStringObjectInspector); for (int i = 0; i < arguments.length; i++) { converters[i] = ObjectInspectorConverters.getConverter(arguments[i], returnOI); } return ObjectInspectorFactory.getStandardListObjectInspector(returnOI); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { GenericUDFUtils.ReturnObjectInspectorResolver returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i < arguments.length; i++) { if (!returnOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "Argument type \"" + arguments[i].getTypeName() + "\" is different from preceding arguments. " + "Previous type was \"" + arguments[i - 1].getTypeName() + "\""); } } converters = new Converter[arguments.length]; ObjectInspector returnOI = returnOIResolver.get(PrimitiveObjectInspectorFactory.javaStringObjectInspector); for (int i = 0; i < arguments.length; i++) { converters[i] = ObjectInspectorConverters.getConverter(arguments[i], returnOI); } return ObjectInspectorFactory.getStandardListObjectInspector(returnOI); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { argumentOIs = arguments; if (arguments.length != 2) { throw new UDFArgumentLengthException( "The operator 'NVL' accepts 2 arguments."); } returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (!(returnOIResolver.update(arguments[0]) && returnOIResolver .update(arguments[1]))) { throw new UDFArgumentTypeException(1, "The first and seconds arguments of function NLV should have the same type, " + "but they are different: \"" + arguments[0].getTypeName() + "\" and \"" + arguments[1].getTypeName() + "\""); } return returnOIResolver.get(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentTypeException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i < arguments.length; i++) { if (!returnOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "The expressions after COALESCE should all have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { argumentOIs = arguments; if (arguments.length != 2) { throw new UDFArgumentLengthException( "The operator 'MYISNULL' accepts 2 arguments."); } returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (!(returnOIResolver.update(arguments[0]) && returnOIResolver .update(arguments[1]))) { throw new UDFArgumentTypeException(2, "The first and seconds arguments of function MYISNULL should have the same type, " + "but they are different: \"" + arguments[0].getTypeName() + "\" and \"" + arguments[1].getTypeName() + "\""); } return returnOIResolver.get(); }
/** * Update returnObjectInspector and valueInspectorsAreTheSame based on the * ObjectInspector seen for UnionAll. * * @return false if there is a type mismatch */ public boolean updateForUnionAll(ObjectInspector oi) throws UDFArgumentTypeException { return update(oi, true); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentTypeException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); for (int i = 0; i < arguments.length; i++) { if (!returnOIResolver.update(arguments[i])) { throw new UDFArgumentTypeException(i, "The expressions after COALESCE should all have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }
/** * Update returnObjectInspector and valueInspectorsAreTheSame based on the * ObjectInspector seen. * * @return false if there is a type mismatch */ public boolean update(ObjectInspector oi) throws UDFArgumentTypeException { return update(oi, false); }
/** * Update returnObjectInspector and valueInspectorsAreTheSame based on the * ObjectInspector seen for comparison (for example GenericUDFIn). * * @return false if there is a type mismatch */ public boolean updateForComparison(ObjectInspector oi) throws UDFArgumentTypeException { return update(oi, ConversionType.COMPARISON); }
/** * Update returnObjectInspector and valueInspectorsAreTheSame based on the * ObjectInspector seen for UnionAll. * * @return false if there is a type mismatch */ public boolean updateForUnionAll(ObjectInspector oi) throws UDFArgumentTypeException { return update(oi, ConversionType.UNION); }
/** * Update returnObjectInspector and valueInspectorsAreTheSame based on the * ObjectInspector seen. * * @return false if there is a type mismatch */ public boolean update(ObjectInspector oi) throws UDFArgumentTypeException { return update(oi, ConversionType.COMMON); }