private boolean allInputColsRepeating(VectorizedRowBatch batch) { int varArgCount = 0; for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isVariable() && !batch.cols[argDescs[i].getColumnNum()].isRepeating) { return false; } varArgCount += 1; } if (varArgCount > 0) { return true; } else { return false; } }
private void setResult(int i, VectorizedRowBatch b) { // get arguments for (int j = 0; j < argDescs.length; j++) { deferredChildren[j] = argDescs[j].getDeferredJavaObject(i, b, j, writers); } // call function Object result; try { result = genericUDF.evaluate(deferredChildren); } catch (HiveException e) { /* For UDFs that expect primitive types (like int instead of Integer or IntWritable), * this will catch the the exception that happens if they are passed a NULL value. * Then the default NULL handling logic will apply, and the result will be NULL. */ result = null; } // set output column vector entry if (result == null) { b.cols[outputColumn].noNulls = false; b.cols[outputColumn].isNull[i] = true; } else { b.cols[outputColumn].isNull[i] = false; setOutputCol(b.cols[outputColumn], i, result); } }
init(); } catch (Exception e) { throw new RuntimeException(e); if (allInputColsRepeating(batch)) { setResult(0, batch); batch.cols[outputColumnNum].isRepeating = true; return; for(int j = 0; j != n; j++) { int i = sel[j]; setResult(i, batch); setResult(i, batch);
argDescs[i] = new VectorUDFArgDesc(); variableArgPositions.add(i); exprResultColumnNums.add(e.getOutputColumnNum()); argDescs[i].setVariable(e.getOutputColumnNum()); } else if (child instanceof ExprNodeColumnDesc) { variableArgPositions.add(i); argDescs[i].setVariable(getInputColumnIndex(((ExprNodeColumnDesc) child).getColumn())); } else if (child instanceof ExprNodeConstantDesc) { argDescs[i].setConstant((ExprNodeConstantDesc) child); } else if (child instanceof ExprNodeDynamicValueDesc) { VectorExpression e = getVectorExpression(child, VectorExpressionDescriptor.Mode.PROJECTION); variableArgPositions.add(i); exprResultColumnNums.add(e.getOutputColumnNum()); argDescs[i].setVariable(e.getOutputColumnNum()); } else if (child instanceof ExprNodeFieldDesc) { variableArgPositions.add(i); exprResultColumnNums.add(e.getOutputColumnNum()); argDescs[i].setVariable(e.getOutputColumnNum()); } else { throw new HiveException("Unable to vectorize custom UDF. Encountered unsupported expr desc : " VectorUDFAdaptor ve = new VectorUDFAdaptor(expr, outputColumnNum, resultTypeName, argDescs); ve.setSuppressEvaluateExceptions(adaptorSuppressEvaluateExceptions); ve.setChildExpressions(childVEs);
GenericUDF genericUDF = new GenericUDFIsNull(); TypeInfo typeInfoStr = TypeInfoFactory.stringTypeInfo; argDescs[i] = new VectorUDFArgDesc(); argDescs[0].setVariable(0); argDescs[1].setConstant((ExprNodeConstantDesc) children.get(1)); funcDesc = new ExprNodeGenericFuncDesc(typeInfoStr, genericUDF, "myisnull", children); vudf = new VectorUDFAdaptor(funcDesc, 3, "String", argDescs); } catch (HiveException e) { b = getBatchStrDblLongWithStrOut(); b.cols[0].noNulls = false; b.cols[0].isNull[0] = true; // set 1st entry to null vudf.evaluate(b); out = (BytesColumnVector) b.cols[3];
argDescs[i] = new VectorUDFArgDesc(); variableArgPositions.add(i); exprResultColumnNums.add(e.getOutputColumn()); argDescs[i].setVariable(e.getOutputColumn()); } else if (child instanceof ExprNodeColumnDesc) { variableArgPositions.add(i); argDescs[i].setVariable(getInputColumnIndex(((ExprNodeColumnDesc) child).getColumn())); } else if (child instanceof ExprNodeConstantDesc) { argDescs[i].setConstant((ExprNodeConstantDesc) child); } else if (child instanceof ExprNodeDynamicValueDesc) { VectorExpression e = getVectorExpression(child, VectorExpressionDescriptor.Mode.PROJECTION); variableArgPositions.add(i); exprResultColumnNums.add(e.getOutputColumn()); argDescs[i].setVariable(e.getOutputColumn()); } else { throw new HiveException("Unable to vectorize custom UDF. Encountered unsupported expr desc : " VectorExpression ve = new VectorUDFAdaptor(expr, outputCol, resultTypeName, argDescs);
children.add(colDesc); VectorUDFArgDesc[] argDescs = new VectorUDFArgDesc[1]; argDescs[0] = new VectorUDFArgDesc(); argDescs[0].setVariable(0); funcDesc = new ExprNodeGenericFuncDesc(typeInfo, genericUDFBridge, genericUDFBridge.getUdfName(), children); vudf = new VectorUDFAdaptor(funcDesc, 1, "Long", argDescs); } catch (HiveException e) { VectorizedRowBatch b = getBatchLongInLongOut(); vudf.evaluate(b); b = getBatchLongInLongOut(); out = (LongColumnVector) b.cols[1]; b.cols[0].noNulls = false; vudf.evaluate(b); assertFalse(out.noNulls); assertEquals(1000, out.vector[0]); b = getBatchLongInLongOut(); out = (LongColumnVector) b.cols[1]; b.cols[0].isRepeating = true; vudf.evaluate(b);
argDescs[i] = new VectorUDFArgDesc(); argDescs[i].setVariable(i); vudf = new VectorUDFAdaptor(funcDesc, 3, "String", argDescs); } catch (HiveException e) { VectorizedRowBatch b = getBatchStrDblLongWithStrOut(); vudf.evaluate(b); byte[] result = null; byte[] result2 = null; b = getBatchStrDblLongWithStrOut(); b.cols[1].noNulls = false; vudf.evaluate(b); out = (BytesColumnVector) b.cols[3]; assertFalse(out.noNulls); b = getBatchStrDblLongWithStrOut(); b.cols[0].isRepeating = true; b.cols[1].isRepeating = true; b.cols[2].isRepeating = true; vudf.evaluate(b);
public void init() throws HiveException, UDFArgumentException { genericUDF = expr.getGenericUDF(); deferredChildren = new GenericUDF.DeferredObject[expr.getChildren().size()]; childrenOIs = new ObjectInspector[expr.getChildren().size()]; writers = VectorExpressionWriterFactory.getExpressionWriters(expr.getChildren()); for (int i = 0; i < childrenOIs.length; i++) { childrenOIs[i] = writers[i].getObjectInspector(); } MapredContext context = MapredContext.get(); if (context != null) { context.setup(genericUDF); } outputTypeInfo = expr.getTypeInfo(); outputVectorAssignRow = new VectorAssignRow(); outputVectorAssignRow.init(outputTypeInfo, outputColumnNum); genericUDF.initialize(childrenOIs); // Initialize constant arguments for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isConstant()) { argDescs[i].prepareConstant(); } } }
if (parent instanceof VectorUDFAdaptor) { VectorUDFAdaptor parentAdaptor = (VectorUDFAdaptor) parent; VectorUDFArgDesc[] argDescs = parentAdaptor.getArgDescs(); for (VectorUDFArgDesc argDesc : argDescs) { if (argDesc.getColumnNum() == oldExpression.getOutputColumnNum()) { argDesc.setColumnNum(newExpression.getOutputColumnNum()); break;
public DeferredObject getDeferredJavaObject(int row, VectorizedRowBatch b, int argPosition, VectorExpressionWriter[] writers) { if (isConstant()) { return this.constObjVal; } else { // get column ColumnVector cv = b.cols[columnNum]; // write value to object that can be inspected Object o; try { o = writers[argPosition].writeValue(cv, row); return new GenericUDF.DeferredJavaObject(o); } catch (HiveException e) { throw new RuntimeException("Unable to get Java object from VectorizedRowBatch", e); } } }
private void setResult(int i, VectorizedRowBatch b) throws HiveException { // get arguments for (int j = 0; j < argDescs.length; j++) { deferredChildren[j] = argDescs[j].getDeferredJavaObject(i, b, j, writers); } // call function Object result; if (!suppressEvaluateExceptions) { result = genericUDF.evaluate(deferredChildren); } else { try { result = genericUDF.evaluate(deferredChildren); } catch (HiveException e) { /* For UDFs that expect primitive types (like int instead of Integer or IntWritable), * this will catch the the exception that happens if they are passed a NULL value. * Then the default NULL handling logic will apply, and the result will be NULL. */ result = null; } } // Set output column vector entry. Since we have one output column, the logical index = 0. outputVectorAssignRow.assignRowColumn( b, /* batchIndex */ i, /* logicalColumnIndex */ 0, result); }
init(); } catch (Exception e) { throw new RuntimeException(e); if (allInputColsRepeating(batch)) { setResult(0, batch); batch.cols[outputColumn].isRepeating = true; return; for(int j = 0; j != n; j++) { int i = sel[j]; setResult(i, batch); setResult(i, batch);
private boolean allInputColsRepeating(VectorizedRowBatch batch) { int varArgCount = 0; for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isVariable() && !batch.cols[argDescs[i].getColumnNum()].isRepeating) { return false; } varArgCount += 1; } if (varArgCount > 0) { return true; } else { return false; } }
public void init() throws HiveException, UDFArgumentException { genericUDF = expr.getGenericUDF(); deferredChildren = new GenericUDF.DeferredObject[expr.getChildren().size()]; childrenOIs = new ObjectInspector[expr.getChildren().size()]; writers = VectorExpressionWriterFactory.getExpressionWriters(expr.getChildren()); for (int i = 0; i < childrenOIs.length; i++) { childrenOIs[i] = writers[i].getObjectInspector(); } MapredContext context = MapredContext.get(); if (context != null) { context.setup(genericUDF); } outputOI = VectorExpressionWriterFactory.genVectorExpressionWritable(expr) .getObjectInspector(); genericUDF.initialize(childrenOIs); // Initialize constant arguments for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isConstant()) { argDescs[i].prepareConstant(); } } }
private void setResult(int i, VectorizedRowBatch b) { // get arguments for (int j = 0; j < argDescs.length; j++) { deferredChildren[j] = argDescs[j].getDeferredJavaObject(i, b, j, writers); } // call function Object result; try { result = genericUDF.evaluate(deferredChildren); } catch (HiveException e) { /* For UDFs that expect primitive types (like int instead of Integer or IntWritable), * this will catch the the exception that happens if they are passed a NULL value. * Then the default NULL handling logic will apply, and the result will be NULL. */ result = null; } // set output column vector entry if (result == null) { b.cols[outputColumn].noNulls = false; b.cols[outputColumn].isNull[i] = true; } else { b.cols[outputColumn].isNull[i] = false; setOutputCol(b.cols[outputColumn], i, result); } }
public DeferredObject getDeferredJavaObject(int row, VectorizedRowBatch b, int argPosition, VectorExpressionWriter[] writers) { if (isConstant()) { return this.constObjVal; } else { // get column ColumnVector cv = b.cols[columnNum]; // write value to object that can be inspected Object o; try { o = writers[argPosition].writeValue(cv, row); return new GenericUDF.DeferredJavaObject(o); } catch (HiveException e) { throw new RuntimeException("Unable to get Java object from VectorizedRowBatch", e); } } }
private boolean allInputColsRepeating(VectorizedRowBatch batch) { int varArgCount = 0; for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isVariable() && !batch.cols[argDescs[i].getColumnNum()].isRepeating) { return false; } varArgCount += 1; } if (varArgCount > 0) { return true; } else { return false; } }
public void init() throws HiveException, UDFArgumentException { genericUDF = expr.getGenericUDF(); deferredChildren = new GenericUDF.DeferredObject[expr.getChildren().size()]; childrenOIs = new ObjectInspector[expr.getChildren().size()]; writers = VectorExpressionWriterFactory.getExpressionWriters(expr.getChildren()); for (int i = 0; i < childrenOIs.length; i++) { childrenOIs[i] = writers[i].getObjectInspector(); } outputOI = VectorExpressionWriterFactory.genVectorExpressionWritable(expr) .getObjectInspector(); genericUDF.initialize(childrenOIs); // Initialize constant arguments for (int i = 0; i < argDescs.length; i++) { if (argDescs[i].isConstant()) { argDescs[i].prepareConstant(); } } }
public DeferredObject getDeferredJavaObject(int row, VectorizedRowBatch b, int argPosition, VectorExpressionWriter[] writers) { if (isConstant()) { return this.constObjVal; } else { // get column ColumnVector cv = b.cols[columnNum]; // write value to object that can be inspected Object o; try { o = writers[argPosition].writeValue(cv, row); return new GenericUDF.DeferredJavaObject(o); } catch (HiveException e) { throw new RuntimeException("Unable to get Java object from VectorizedRowBatch", e); } } }