throws UDFArgumentException { ObjectInspector oi = initialize(arguments); if (getRequiredFiles() != null || getRequiredJars() != null) { return oi; Object constantValue = evaluate(argumentValues); oi = ObjectInspectorUtils.getConstantObjectInspector(oi, constantValue); } catch (HiveException e) {
public void setup(GenericUDF genericUDF) { if (needConfigure(genericUDF)) { genericUDF.configure(this); } if (needClose(genericUDF)) { registerCloseable(genericUDF); } }
@Override public void copyToNewInstance(Object newInstance) throws UDFArgumentException { super.copyToNewInstance(newInstance); // Need to preserve authorizer flag GenericUDFCurrentAuthorizer other = (GenericUDFCurrentAuthorizer) newInstance; if (this.authorizer != null) { other.authorizer = new Text(this.authorizer); } } }
private void runAndVerify(String expResult, GenericUDF udf, ObjectInspector[] initArgs, DeferredObject[] evalArgs) throws HiveException { udf.initialize(initArgs); Text output = (Text) udf.evaluate(evalArgs); assertEquals("frist_day() test ", expResult, output.toString()); } }
files = udf.getRequiredFiles(); jars = udf.getRequiredJars();
@Override protected Object _evaluate(Object row, int version) throws HiveException { if (isConstant) { // The output of this UDF is constant, so don't even bother evaluating. return ((ConstantObjectInspector) outputOI).getWritableConstantValue(); } rowObject = row; for (GenericUDF.DeferredObject deferredObject : childrenNeedingPrepare) { deferredObject.prepare(version); } return genericUDF.evaluate(deferredChildren); }
private TypeInfo getOutputTypeInfo(GenericUDF genericUdfClone, List<ObjectInspector> objectInspectorList) throws HiveException { ObjectInspector[] array = objectInspectorList.toArray(new ObjectInspector[objectInspectorList.size()]); ObjectInspector outputObjectInspector = genericUdfClone.initialize(array); return TypeInfoUtils.getTypeInfoFromObjectInspector(outputObjectInspector); }
ObjectInspector oi = genericUDF.initializeAndFoldConstants(childrenOIs); String[] requiredJars = genericUDF.getRequiredJars(); String[] requiredFiles = genericUDF.getRequiredFiles(); SessionState ss = SessionState.get();
public static void assertFunction(GenericUDF udf, ObjectInspector[] objectInspectors, Object[] arguments, Object expected) { try { udf.initialize(objectInspectors); } catch (UDFArgumentException e) { throw new RuntimeException("Error initializing UDF: " + udf.getClass() + ".", e); } udf.getRequiredFiles(); GenericUDF.DeferredObject[] deferredObjects = Arrays.stream(arguments) .map(object -> new GenericUDF.DeferredJavaObject(object)) .toArray(GenericUDF.DeferredObject[]::new); try { Object result = udf.evaluate(deferredObjects); Assert.assertEquals(result, expected); } catch (HiveException e) { throw new RuntimeException("Error evaluating UDF: " + udf.getClass() + ".", e); } } }
ExprNodeConstantDesc constantDesc; if (extracted[0] instanceof ExprNodeConstantDesc) { genericUDF = genericUDF.flip(); columnDesc = (ExprNodeColumnDesc) extracted[1]; constantDesc = (ExprNodeConstantDesc) extracted[0]; String udfName = genericUDF.getUdfName(); if (!allowed.contains(genericUDF.getUdfName())) { return expr;
protected void verifyReturnType(GenericUDF udf, String typeStr1, String typeStr2, String expectedTypeStr) throws HiveException { // Lookup type infos for our input types and expected return type PrimitiveTypeInfo type1 = TypeInfoFactory.getPrimitiveTypeInfo(typeStr1); PrimitiveTypeInfo type2 = TypeInfoFactory.getPrimitiveTypeInfo(typeStr2); PrimitiveTypeInfo expectedType = TypeInfoFactory.getPrimitiveTypeInfo(expectedTypeStr); // Initialize UDF which will output the return type for the UDF. ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(type1), PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(type2) }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals("Return type for " + udf.getDisplayString(new String[] {typeStr1, typeStr2}), expectedType, oi.getTypeInfo()); } }
List<ExprNodeDesc> children, TypeInfo returnType) throws HiveException { if (isCustomUDF(genericUDF.getUdfName())) {
@Override public Object exec(Tuple input) throws IOException { if (!inited) { evalUDF.configure(instantiateMapredContext()); schemaInfo.init(getInputSchema(), evalUDF, constantsInfo); inited = true; } List inputs = schemaInfo.inputObjectInspector.getStructFieldsDataAsList(input); DeferredObject[] arguments = new DeferredObject[inputs.size()]; for (int i=0 ; i<inputs.size() ; i++) { arguments[i] = new DeferredJavaObject(inputs.get(i)); } try { Object returnValue = evalUDF.evaluate(arguments); return HiveUtils.convertHiveToPig(returnValue, schemaInfo.outputObjectInspector, null); } catch (HiveException e) { throw new IOException(e); } }
@Override public String getExprString() { // Get the children expr strings String[] childrenExprStrings = new String[chidren.size()]; for (int i = 0; i < childrenExprStrings.length; i++) { childrenExprStrings[i] = chidren.get(i).getExprString(); } return genericUDF.getDisplayString(childrenExprStrings); }
if (hiveUDF != null) { try { hiveUDF.close(); } catch (IOException e) { if (LOG.isDebugEnabled()) {
@Test public void evaluate_SingleArgumentOnly() throws HiveException { when(deferredObject.get()).thenReturn(value); when(valueConverter.convert(value, unionOI)).thenReturn(converted); underTest.initialize(new ObjectInspector[] { unionOI }); Object result = underTest.evaluate(new DeferredObject[] { deferredObject }); assertThat(result, is(converted)); }
private void runAndVerify(String str, String expResult, GenericUDF udf) throws HiveException { DeferredObject valueObj0 = new DeferredJavaObject(str != null ? new Text(str) : null); DeferredObject[] args = { valueObj0 }; Text output = (Text) udf.evaluate(args); assertEquals("last_day() test ", expResult, output != null ? output.toString() : null); }
private TypeInfo getOutputTypeInfo(GenericUDF genericUdfClone, List<ObjectInspector> objectInspectorList) throws HiveException { ObjectInspector[] array = objectInspectorList.toArray(new ObjectInspector[objectInspectorList.size()]); ObjectInspector outputObjectInspector = genericUdfClone.initialize(array); return TypeInfoUtils.getTypeInfoFromObjectInspector(outputObjectInspector); }
files = udf.getRequiredFiles(); jars = udf.getRequiredJars();
ObjectInspector oi = genericUDF.initializeAndFoldConstants(childrenOIs); String[] requiredJars = genericUDF.getRequiredJars(); String[] requiredFiles = genericUDF.getRequiredFiles(); SessionState ss = SessionState.get();