@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { assert (arguments.length == 2); if (arguments[0].get() == null || arguments[1].get() == null) { return null; } Text s = (Text) converters[0].convert(arguments[0].get()); ArrayList<Text> result = new ArrayList<Text>(); if (constPattern == null) { Text regex = (Text) converters[1].convert(arguments[1].get()); for (String str : s.toString().split(regex.toString(), -1)) { result.add(new Text(str)); } } else { for (String str : constPattern.split(s.toString(), -1)) { result.add(new Text(str)); } } return result; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { bw.set(false); /**If field value or any constant string pattern value is null then return null*/ if (arguments[0].get() == null || isConstantNullPatternContain) { return null; } /**If all patterns are constant string and no pattern have null value the do short circuit boolean check * Else evaluate all patterns if any pattern contains null value then return null otherwise at last return matching result * */ Text columnValue = (Text) converters[0].convert(arguments[0].get()); Text pattern = new Text(); UDFLike likeUdf = new UDFLike(); for (int idx = 1; idx < arguments.length; idx++) { if (arguments[idx].get() == null) { return null; } pattern.set(converters[idx].convert(arguments[idx].get()).toString()); if (likeUdf.evaluate(columnValue, pattern).get() && !bw.get()) { bw.set(true); if (isAllPatternsConstant) { return bw; } } } return bw; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object valObject1 = arguments[0].get(); Object valObject2 = arguments[1].get(); Object valObject3 = arguments[2].get(); if (valObject1 == null || valObject2 == null || valObject3 == null) { return null; } Text str = (Text) converter1.convert(valObject1); IntWritable lenW = (IntWritable) converter2.convert(valObject2); Text pad = (Text) converter3.convert(valObject3); if (str == null || pad == null || lenW == null || pad.toString().isEmpty()) { return null; } int len = lenW.get(); builder.setLength(0); performOp(builder, len, str.toString(), pad.toString()); result.set(builder.toString()); return result; }
@Override public Object evaluate(DeferredObject[] arg0) throws HiveException { if (arg0.length != 1) { LOG.error("UDFHelloTest expects exactly 1 argument"); throw new HiveException("UDFHelloTest expects exactly 1 argument"); } if (arg0[0].get() == null) { LOG.warn("Empty input"); return null; } Text data = (Text) converters[0].convert(arg0[0].get()); String dataString = data.toString(); result.set(greeting + dataString); return result; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object valObject = arguments[0].get(); if (valObject == null) { return null; case BYTE: case INT: valObject = inputConverter.convert(valObject); resultInt.set(Math.abs(((IntWritable) valObject).get())); return resultInt; case LONG: valObject = inputConverter.convert(valObject); resultLong.set(Math.abs(((LongWritable) valObject).get())); return resultLong; case STRING: case DOUBLE: valObject = inputConverter.convert(valObject); if (valObject == null) { return null;
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object o0,o1; o0 = arguments[0].get(); if (o0 == null) { return null; o1 = arguments[1].get(); if (o1 == null) { return null; break; case SAME_TYPE: result.set(ObjectInspectorUtils.compare( o0, argumentOIs[0], o1, argumentOIs[1]) == 0); break; default: Object converted_o0 = converter0.convert(o0); if (converted_o0 == null) { return null; Object converted_o1 = converter1.convert(o1); if (converted_o1 == null) { return null; result.set(ObjectInspectorUtils.compare( converted_o0, compareOI, converted_o1, compareOI) == 0);
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object obj0; if ((obj0 = arguments[0].get()) == null) { return null; } String str0 = textConverters[0].convert(obj0).toString(); String soundexCode; try { soundexCode = soundex.soundex(str0); } catch (IllegalArgumentException e) { return null; } output.set(soundexCode); return output; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object o0,o1; o0 = arguments[0].get(); if (o0 == null) { return null; o1 = arguments[1].get(); if (o1 == null) { return null; break; case SAME_TYPE: result.set(ObjectInspectorUtils.compare( o0, argumentOIs[0], o1, argumentOIs[1]) <= 0); break; default: Object converted_o0 = converter0.convert(o0); if (converted_o0 == null) { return null; Object converted_o1 = converter1.convert(o1); if (converted_o1 == null) { return null; result.set(ObjectInspectorUtils.compare( converted_o0, compareOI, converted_o1, compareOI) <= 0);
private Object getTypeAppropriateValueFor(PrimitiveTypeInfo type, String value) { ObjectInspectorConverters.Converter converter = ObjectInspectorConverters.getConverter( TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(TypeInfoFactory.stringTypeInfo), TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(type)); return converter.convert(value); }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { if (arguments[0].get() == null || arguments[1].get() == null) { return null; } Text text = (Text) converters[0].convert(arguments[0].get()); Text subtext = (Text) converters[1].convert(arguments[1].get()); intWritable.set(GenericUDFUtils.findText(text, subtext, 0) + 1); return intWritable; }
ObjectInspector inputOI = TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo (astExprNodePair.getValue().getTypeInfo()); TypeInfoUtils.getTypeInfoFromTypeString(colType); ObjectInspector outputOI = TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(expectedType); Object convertedValue = value; if (!inputOI.getTypeName().equals(outputOI.getTypeName())) { convertedValue = ObjectInspectorConverters.getConverter(inputOI, outputOI).convert(value); if (convertedValue == null) { throw new SemanticException(ErrorMsg.PARTITION_SPEC_TYPE_MISMATCH, astKeyName,
TypeInfoUtils.getTypeInfoFromTypeString(alterPartitionDesc.getPartKeySpec().getType()); ObjectInspector outputOI = TypeInfoUtils.getStandardWritableObjectInspectorFromTypeInfo(expectedType); Converter converter = ObjectInspectorConverters.getConverter( PrimitiveObjectInspectorFactory.javaStringObjectInspector, outputOI); String value = part.getValues().get(colIndex); Object convertedValue = converter.convert(value); if (convertedValue == null) { throw new HiveException(" Converting from " + TypeInfoFactory.stringTypeInfo + " to " +
PrimitiveTypeInfo typeInfo = oi.getTypeInfo(); if (writeablePrimitives) { Converter c = ObjectInspectorConverters.getConverter(PrimitiveObjectInspectorFactory.javaStringObjectInspector, oi); return c.convert(s); case BINARY: try { String t = Text.decode(s.getBytes(), 0, s.getBytes().length); return t.getBytes(); } catch (CharacterCodingException e) {
converter = ObjectInspectorConverters.getConverter(oi, returnObjectInspector); if (reuse) { converted = converter.convert(o);
return (ConstantObjectInspector) oi; ObjectInspector writableOI = getStandardObjectInspector(oi, ObjectInspectorCopyOption.WRITABLE); Object writableValue = value == null ? value : ObjectInspectorConverters.getConverter(oi, writableOI).convert(value); switch (writableOI.getCategory()) { case PRIMITIVE: ListObjectInspector loi = (ListObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantListObjectInspector( getStandardObjectInspector( loi.getListElementObjectInspector(), ObjectInspectorCopyOption.WRITABLE MapObjectInspector moi = (MapObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantMapObjectInspector( getStandardObjectInspector( moi.getMapKeyObjectInspector(), ObjectInspectorCopyOption.WRITABLE
@Override public void iterate(AggregationBuffer agg, Object[] parameters) throws HiveException { Object rowExprVal = ObjectInspectorUtils.copyToStandardObject(parameters[0], inputOI[0]); Object defaultVal = parameters.length > 2 ? ObjectInspectorUtils.copyToStandardObject( defaultValueConverter.convert(parameters[2]), inputOI[0]) : null; ((LeadLagBuffer) agg).addRow(rowExprVal, defaultVal); }
public Integer compare(DeferredObject[] arguments) throws HiveException { Object o0,o1; o0 = arguments[0].get(); if (o0 == null) { return null; } o1 = arguments[1].get(); if (o1 == null) { return null; } if (compareType == CompareType.NEED_CONVERT) { Object converted_o0 = converter0.convert(o0); if (converted_o0 == null) { return null; } Object converted_o1 = converter1.convert(o1); if (converted_o1 == null) { return null; } return ObjectInspectorUtils.compare( converted_o0, compareOI, converted_o1, compareOI); } else { return ObjectInspectorUtils.compare( o0, argumentOIs[0], o1, argumentOIs[1]); } } }