@Override public GenericUDF negative() { return new GenericUDFOPEqualOrLessThan(); } }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (!arguments[0].getTypeName().equals("boolean")) { throw new UDFArgumentTypeException(0, "First argument for BETWEEN should be boolean type"); } egt.initialize(new ObjectInspector[] {arguments[1], arguments[2]}); elt.initialize(new ObjectInspector[] {arguments[1], arguments[3]}); argumentOIs = arguments; return PrimitiveObjectInspectorFactory.writableBooleanObjectInspector; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { boolean invert = (Boolean) ((PrimitiveObjectInspector) argumentOIs[0]) .getPrimitiveJavaObject(arguments[0].get()); BooleanWritable left = ((BooleanWritable)egt.evaluate(new DeferredObject[] {arguments[1], arguments[2]})); if (left == null) { return null; } if (!invert && !left.get()) { result.set(false); return result; } BooleanWritable right = ((BooleanWritable)elt.evaluate(new DeferredObject[] {arguments[1], arguments[3]})); if (right == null) { return null; } boolean between = left.get() && right.get(); result.set(invert ? !between : between); return result; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { boolean invert = (Boolean) ((PrimitiveObjectInspector) argumentOIs[0]) .getPrimitiveJavaObject(arguments[0].get()); BooleanWritable left = ((BooleanWritable)egt.evaluate(new DeferredObject[] {arguments[1], arguments[2]})); if (left == null) { return null; } if (!invert && !left.get()) { result.set(false); return result; } BooleanWritable right = ((BooleanWritable)elt.evaluate(new DeferredObject[] {arguments[1], arguments[3]})); if (right == null) { return null; } boolean between = left.get() && right.get(); result.set(invert ? !between : between); return result; }
@Override public GenericUDF flip() { return new GenericUDFOPEqualOrLessThan(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (!arguments[0].getTypeName().equals("boolean")) { throw new UDFArgumentTypeException(0, "First argument for BETWEEN should be boolean type"); } egt.initialize(new ObjectInspector[] {arguments[1], arguments[2]}); elt.initialize(new ObjectInspector[] {arguments[1], arguments[3]}); argumentOIs = arguments; return PrimitiveObjectInspectorFactory.writableBooleanObjectInspector; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { boolean invert = (Boolean) ((PrimitiveObjectInspector) argumentOIs[0]) .getPrimitiveJavaObject(arguments[0].get()); BooleanWritable left = ((BooleanWritable)egt.evaluate(new DeferredObject[] {arguments[1], arguments[2]})); if (left == null) { return null; } if (!invert && !left.get()) { result.set(false); return result; } BooleanWritable right = ((BooleanWritable)elt.evaluate(new DeferredObject[] {arguments[1], arguments[3]})); if (right == null) { return null; } boolean between = left.get() && right.get(); result.set(invert ? !between : between); return result; }
@Override public GenericUDF negative() { return new GenericUDFOPEqualOrLessThan(); } }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (!arguments[0].getTypeName().equals("boolean")) { throw new UDFArgumentTypeException(0, "First argument for BETWEEN should be boolean type"); } egt.initialize(new ObjectInspector[] {arguments[1], arguments[2]}); elt.initialize(new ObjectInspector[] {arguments[1], arguments[3]}); argumentOIs = arguments; return PrimitiveObjectInspectorFactory.writableBooleanObjectInspector; }
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { boolean invert = (Boolean) ((PrimitiveObjectInspector) argumentOIs[0]) .getPrimitiveJavaObject(arguments[0].get()); BooleanWritable left = ((BooleanWritable)egt.evaluate(new DeferredObject[] {arguments[1], arguments[2]})); if (left == null) { return null; } if (!invert && !left.get()) { result.set(false); return result; } BooleanWritable right = ((BooleanWritable)elt.evaluate(new DeferredObject[] {arguments[1], arguments[3]})); if (right == null) { return null; } boolean between = left.get() && right.get(); result.set(invert ? !between : between); return result; }
@Override public GenericUDF flip() { return new GenericUDFOPEqualOrLessThan(); }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (!arguments[0].getTypeName().equals("boolean")) { throw new UDFArgumentTypeException(0, "First argument for BETWEEN should be boolean type"); } egt.initialize(new ObjectInspector[] {arguments[1], arguments[2]}); elt.initialize(new ObjectInspector[] {arguments[1], arguments[3]}); argumentOIs = arguments; return PrimitiveObjectInspectorFactory.writableBooleanObjectInspector; }
private static ExprNodeGenericFuncDesc lessThanEq(List<ExprNodeDesc> children) { return new ExprNodeGenericFuncDesc(children.get(0).getTypeInfo(), new GenericUDFOPEqualOrLessThan(), children); }
Lists.newArrayList(comparisonExpression, leftExpression)); final ExprNodeDesc rightComparator = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, new GenericUDFOPEqualOrLessThan(), Lists.newArrayList(comparisonExpression, rightExpression)); ExprNodeDesc newExpression = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo,
private long evaluateBetweenExpr(Statistics stats, ExprNodeDesc pred, AnnotateStatsProcCtx aspCtx, List<String> neededCols, FilterOperator fop) throws SemanticException, CloneNotSupportedException { final ExprNodeGenericFuncDesc fd = (ExprNodeGenericFuncDesc) pred; final boolean invert = Boolean.TRUE.equals( ((ExprNodeConstantDesc) fd.getChildren().get(0)).getValue()); // boolean invert (not) final ExprNodeDesc comparisonExpression = fd.getChildren().get(1); // expression final ExprNodeDesc leftExpression = fd.getChildren().get(2); // left expression final ExprNodeDesc rightExpression = fd.getChildren().get(3); // right expression // Short circuit and return the current number of rows if this is a // synthetic predicate with dynamic values if (leftExpression instanceof ExprNodeDynamicValueDesc) { return stats.getNumRows(); } // We transform the BETWEEN clause to AND clause (with NOT on top in invert is true). // This is more straightforward, as the evaluateExpression method will deal with // generating the final row count relying on the basic comparator evaluation methods final ExprNodeDesc leftComparator = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, new GenericUDFOPEqualOrGreaterThan(), Lists.newArrayList(comparisonExpression, leftExpression)); final ExprNodeDesc rightComparator = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, new GenericUDFOPEqualOrLessThan(), Lists.newArrayList(comparisonExpression, rightExpression)); ExprNodeDesc newExpression = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, new GenericUDFOPAnd(), Lists.newArrayList(leftComparator, rightComparator)); if (invert) { newExpression = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, new GenericUDFOPNot(), Lists.newArrayList(newExpression)); } return evaluateExpression(stats, newExpression, aspCtx, neededCols, fop, 0); }
writeFile(inspector, testFilePath2); GenericUDF udf = new GenericUDFOPEqualOrLessThan(); List<ExprNodeDesc> childExpr = Lists.newArrayList(); createTestSarg(inspector, udf, childExpr);
break; case LESS_THAN_EQUAL: genericUdf = new GenericUDFOPEqualOrLessThan(); break; case GREATER_THAN:
GenericUDF udf = new GenericUDFOPEqualOrLessThan(); List<ExprNodeDesc> childExpr = Lists.newArrayList(); ExprNodeColumnDesc col = new ExprNodeColumnDesc(Long.class, "userid", "T", false); ExprNodeGenericFuncDesc en = new ExprNodeGenericFuncDesc(inspector, udf, childExpr); GenericUDF udf1 = new GenericUDFOPEqualOrLessThan(); List<ExprNodeDesc> childExpr1 = Lists.newArrayList(); ExprNodeColumnDesc col1 = new ExprNodeColumnDesc(Double.class, "subtype", "T", false);
FileInputFormat.setInputPaths(conf, testFilePath.toString()); GenericUDF udf = new GenericUDFOPEqualOrLessThan(); List<ExprNodeDesc> childExpr = Lists.newArrayList(); ExprNodeConstantDesc con;
FileInputFormat.setInputPaths(conf, testFilePath.toString()); GenericUDF udf = new GenericUDFOPEqualOrLessThan(); List<ExprNodeDesc> childExpr = Lists.newArrayList(); ExprNodeConstantDesc con;