columnTypeResolvers[c] = new ReturnObjectInspectorResolver(true); if (!columnTypeResolvers[c].updateForUnionAll(parentFields[p].get(c) .getFieldObjectInspector())) { outputFieldOIs.add(columnTypeResolvers[c].get(fieldOI));
case PRIMITIVE: { if (constantInSet.contains(((PrimitiveObjectInspector) compareOI) .getPrimitiveJavaObject(conversionHelper.convertIfNecessary(arguments[0].get(), argumentOIs[0])))) { bw.set(true); .convertIfNecessary(arguments[0].get(), argumentOIs[0])))) { bw.set(true); return bw; .convertIfNecessary(arguments[0].get(), argumentOIs[0])))) { bw.set(true); return bw; .convertIfNecessary(arguments[0].get(), argumentOIs[0])))) { bw.set(true); return bw; for (int i = 1; i < arguments.length; i++) { if (ObjectInspectorUtils.compare( conversionHelper.convertIfNecessary( arguments[0].get(), argumentOIs[0]), compareOI, conversionHelper.convertIfNecessary( arguments[i].get(), argumentOIs[i], false), compareOI) == 0) { bw.set(true);
returnOIResolvers.add(new ReturnObjectInspectorResolver()); for (int ii = 0; ii < numRows.get(); ++ii) { int index = ii * numCols + jj + 1; if (index < args.length && !returnOIResolvers.get(jj).update(args[index])) { throw new UDFArgumentException( "Argument " + (jj + 1) + "'s type (" + for (int ii = 0; ii < numCols; ++ii) { fieldNames.add("col" + ii); fieldOIs.add(returnOIResolvers.get(ii).get());
columnTypeResolvers[c] = new ReturnObjectInspectorResolver(true); assert (parentFields[p].size() == columns); for (int c = 0; c < columns; c++) { if (!columnTypeResolvers[c].updateForUnionAll(parentFields[p].get(c) .getFieldObjectInspector())) { outputFieldOIs.add(columnTypeResolvers[c].get(fieldOI));
conversionHelper = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if(!conversionHelper.update(oi)) { StringBuilder sb = new StringBuilder(); sb.append("The arguments for IN should be the same type! Types are: {"); compareOI = conversionHelper.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(); }
conversionHelper = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if(!conversionHelper.update(oi)) { StringBuilder sb = new StringBuilder(); sb.append("The arguments for IN should be the same type! Types are: {"); compareOI = conversionHelper.get();
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentTypeException { argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(); for (int i = 0; i + 1 < arguments.length; i += 2) { if (!arguments[i].getTypeName().equals(Constants.BOOLEAN_TYPE_NAME)) { throw new UDFArgumentTypeException(i, "\"" + Constants.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(); }
@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; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (arguments.length != 1) { throw new UDFArgumentLengthException( "The function SORT_ARRAY(array(obj1, obj2,...)) needs one argument."); } switch(arguments[0].getCategory()) { case LIST: if(((ListObjectInspector)(arguments[0])).getListElementObjectInspector() .getCategory().equals(Category.PRIMITIVE)) { break; } default: throw new UDFArgumentTypeException(0, "Argument 1" + " of function SORT_ARRAY must be " + serdeConstants.LIST_TYPE_NAME + "<" + Category.PRIMITIVE + ">, but " + arguments[0].getTypeName() + " was found."); } ObjectInspector elementObjectInspector = ((ListObjectInspector)(arguments[0])).getListElementObjectInspector(); argumentOIs = arguments; converters = new Converter[arguments.length]; ObjectInspector returnOI = returnOIResolver.get(elementObjectInspector); converters[0] = ObjectInspectorConverters.getConverter(elementObjectInspector, returnOI); return ObjectInspectorFactory.getStandardListObjectInspector(returnOI); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { bw.set(false); if (arguments[0].get() == null) { return null; } for (int i=1; i<arguments.length; i++) { if(ObjectInspectorUtils.compare( conversionHelper.convertIfNecessary( arguments[0].get(), argumentOIs[0]), compareOI, conversionHelper.convertIfNecessary( arguments[i].get(), argumentOIs[i]), compareOI) == 0) { bw.set(true); return bw; } } // Nothing matched. See comment at top. for (int i=1; i<arguments.length; i++) { if(arguments[i].get() == null) { return null; } } return bw; }
@Override public Object terminatePartial(AggregationBuffer agg) throws HiveException { LOG.info("Start terminatePartial"); MyAggBuffer myAgg = (MyAggBuffer) agg; String rtn = null; try { rtn = initData.engine.invokeFunction("convert_to_string", (Object)myAgg.data).toString(); } catch (Exception e) { throw new HiveException("Error invoking the partial function", e); } Map<String,String> out = new HashMap<String,String>(); out.put("data", rtn); out.put("script", initData.script); out.put("language", initData.language); out.put("returntype", initData.returnType); try { Object tmp = outputResolver.convertIfNecessary(out, intermediateInternal); LOG.info("End terminatePartial"); return tmp; } catch (Exception e) { e.printStackTrace(System.err); throw new HiveException("bad stuff", e); } }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { GenericUDFUtils.ReturnObjectInspectorResolver returnOIResolver; 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(); if (returnOI == null) { returnOI = PrimitiveObjectInspectorFactory .getPrimitiveJavaObjectInspector(PrimitiveObjectInspector.PrimitiveCategory.STRING); } 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 { if (arguments.length < 3) { throw new UDFArgumentLengthException( "The function nvl2(string1, value_if_not_null, value_if_null) needs " + "at least three arguments."); } for (int i = 0; i < arguments.length; i++) { if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(i, "Only primitive type arguments are accepted but " + arguments[i].getTypeName() + " is passed."); } } 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 value of return should have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object exprValue = arguments[0].get(); for (int i = 1; i + 1 < arguments.length; i += 2) { Object caseKey = arguments[i].get(); // May need to convert to common type to compare PrimitiveObjectInspector caseOI = (PrimitiveObjectInspector) caseOIResolver.get(); if (PrimitiveObjectInspectorUtils.comparePrimitiveObjects( caseOIResolver.convertIfNecessary(exprValue, argumentOIs[0]), caseOI, caseOIResolver.convertIfNecessary(caseKey, argumentOIs[i], false), caseOI)) { Object caseValue = arguments[i + 1].get(); return returnOIResolver.convertIfNecessary(caseValue, argumentOIs[i + 1]); } } // Process else statement if (arguments.length % 2 == 0) { int i = arguments.length - 2; Object elseValue = arguments[i + 1].get(); return returnOIResolver.convertIfNecessary(elseValue, argumentOIs[i + 1]); } return null; }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length < 2) { throw new UDFArgumentLengthException("The function nvl(expr1, expr2) needs at least two arguments."); } for (int i = 0; i < arguments.length; i++) { if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(i, "Only primitive type arguments are accepted but " + arguments[i].getTypeName() + " is passed."); } } argumentOIs = arguments; returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); if (!(returnOIResolver.update(arguments[0]) && returnOIResolver.update(arguments[1]))) { throw new UDFArgumentTypeException(1, "The first and the second arguments of function NVL should have the same type, " + "but they are different: \"" + arguments[0].getTypeName() + "\" and \"" + arguments[1].getTypeName() + "\""); } return returnOIResolver.get(); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object exprValue = arguments[0].get(); for (int i = 1; i + 1 < arguments.length; i += 2) { Object caseKey = arguments[i].get(); if (PrimitiveObjectInspectorUtils.comparePrimitiveObjects(exprValue, (PrimitiveObjectInspector) argumentOIs[0], caseKey, (PrimitiveObjectInspector) argumentOIs[i])) { Object caseValue = arguments[i + 1].get(); return returnOIResolver.convertIfNecessary(caseValue, argumentOIs[i + 1]); } } // Process else statement if (arguments.length % 2 == 0) { int i = arguments.length - 2; Object elseValue = arguments[i + 1].get(); return returnOIResolver.convertIfNecessary(elseValue, argumentOIs[i + 1]); } return null; }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { for (int i = 0; i < arguments.length; i++) { if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(i, "Only primitive type arguments are accepted but " + arguments[i].getTypeName() + " is passed."); } } 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 value of return should 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 { 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 { for (int i = 0; i < arguments.length; i++) { if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(i, "Only primitive type arguments are accepted but " + arguments[i].getTypeName() + " is passed."); } } 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 value of return should have the same type: \"" + returnOIResolver.get().getTypeName() + "\" is expected but \"" + arguments[i].getTypeName() + "\" is found"); } } return returnOIResolver.get(); }