@Override public SortOrder getSortOrder() { return children.get(0).getSortOrder(); } }
@Override public Aggregator newServerAggregator(Configuration conf, ImmutableBytesWritable ptr) { final Expression child = getAggregatorExpression(); return new HyperLogLogServerAggregator(child.getSortOrder(), ptr) { @Override protected PDataType getInputDataType() { return child.getDataType(); } }; }
@Override public Aggregator newServerAggregator(Configuration conf) { final Expression child = getAggregatorExpression(); return new HyperLogLogServerAggregator(child.getSortOrder()){ @Override protected PDataType getInputDataType() { return child.getDataType(); } }; }
@Override public SortOrder getSortOrder() { if (getLHSExpr().getDataType().isArrayType()) { return isNullArray ? getRHSExpr().getSortOrder() : getLHSExpr().getSortOrder(); } else { return isNullArray ? getLHSExpr().getSortOrder() : getRHSExpr().getSortOrder(); } }
@Override public DistinctValueWithCountClientAggregator newClientAggregator() { if (children.get(0).getDataType() == PDecimal.INSTANCE) { // Special Aggregators for DECIMAL datatype for more precision than double return new DecimalStddevPopAggregator(children, getAggregatorExpression().getSortOrder()); } return new StddevPopAggregator(children, getAggregatorExpression().getSortOrder()); }
@Override public DistinctValueWithCountClientAggregator newClientAggregator() { if (children.get(0).getDataType() == PDecimal.INSTANCE) { // Special Aggregators for DECIMAL datatype for more precision than double return new DecimalStddevSampAggregator(children, getAggregatorExpression().getSortOrder()); } return new StddevSampAggregator(children, getAggregatorExpression().getSortOrder()); }
protected void coerceBytes(ImmutableBytesWritable ptr, Expression arrayExpr, PDataType baseDataType, Expression otherExpr, PDataType otherExpressionType) { baseDataType.coerceBytes(ptr, null, otherExpressionType, otherExpr.getMaxLength(), otherExpr.getScale(), otherExpr.getSortOrder(), arrayExpr.getMaxLength(), arrayExpr.getScale(), arrayExpr.getSortOrder()); }
static double getArg(Expression exp, ImmutableBytesWritable ptr) { if (exp.getDataType() == PDecimal.INSTANCE) { return ((BigDecimal) exp.getDataType().toObject(ptr, exp.getSortOrder())).doubleValue(); } else { return exp.getDataType().getCodec().decodeDouble(ptr, exp.getSortOrder()); } }
@Override public Expression wrap(Expression lhs, Expression rhs, boolean rowKeyOrderOptimizable) throws SQLException { PDataType lhsType = lhs.getDataType(); Expression e = CoerceExpression.create(rhs, lhsType, lhs.getSortOrder(), lhs.getMaxLength(), rowKeyOrderOptimizable); return e; }
@Override public Aggregator newServerAggregator(Configuration conf) { Expression child = getAggregatorExpression(); return newAggregator(child.getDataType(), child.getSortOrder(), null); }
public TargetDataExpression(Expression expr) { this.type = expr.getDataType(); this.maxLength = expr.getMaxLength(); this.scale = expr.getScale(); this.sortOrder = expr.getSortOrder(); }
@Override public Aggregator newServerAggregator(Configuration conf, ImmutableBytesWritable ptr) { Expression child = getAggregatorExpression(); return newAggregator(child.getDataType(), child.getSortOrder(), ptr); }
private void init() { Expression offsetExpr = children.get(1); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); if (offsetExpr.isStateless() && offsetExpr.getDeterminism() == Determinism.ALWAYS && offsetExpr.evaluate(null, ptr)) { offsetPreCompute = (Integer) PInteger.INSTANCE.toObject(ptr, offsetExpr.getSortOrder()); } else offsetPreCompute = null; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (!getChildExpression().evaluate(tuple, ptr)) { return false; } if (ptr.getLength() == 0) { return true; } PDataType type = getDataType(); // FIXME: losing rowKeyOrderOptimizable here type.coerceBytes(ptr, type, getChildExpression().getSortOrder(), getSortOrder()); return true; }
private void testGetByteExpression(Expression data, Expression offset, int expected) throws SQLException { List<Expression> expressions = Lists.newArrayList(data, offset); Expression getByteFunction = new GetByteFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); getByteFunction.evaluate(null, ptr); Integer result = (Integer) getByteFunction.getDataType().toObject(ptr, getByteFunction.getSortOrder()); assertEquals(expected, result.intValue()); }
private void testSetByteExpression(Expression data, Expression offset, Expression newValue, byte[] expected) throws SQLException { List<Expression> expressions = Lists.newArrayList(data, offset, newValue); Expression setByteFunction = new SetByteFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); setByteFunction.evaluate(null, ptr); byte[] result = (byte[]) setByteFunction.getDataType() .toObject(ptr, setByteFunction.getSortOrder()); assertArrayEquals(expected, result); }
private void testSetBitExpression(Expression data, Expression offset, Expression newValue, byte[] expected) throws SQLException { List<Expression> expressions = Lists.newArrayList(data, offset, newValue); Expression setBitFunction = new SetBitFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); setBitFunction.evaluate(null, ptr); byte[] result = (byte[]) setBitFunction.getDataType().toObject(ptr, setBitFunction.getSortOrder()); assertArrayEquals(expected, result); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (getChild().evaluate(tuple, ptr)) { getDataType().coerceBytes(ptr, null, getChild().getDataType(), getChild().getMaxLength(), null, getChild().getSortOrder(), maxLength, null, getSortOrder(), rowKeyOrderOptimizable); return true; } return false; }
public static LiteralExpression getConstantExpression(Expression expression, ImmutableBytesWritable ptr) throws SQLException { Object value = null; PDataType type = expression.getDataType(); if (expression.evaluate(null, ptr) && ptr.getLength() != 0) { value = type.toObject(ptr.get(), ptr.getOffset(), ptr.getLength(), type, expression.getSortOrder(), expression.getMaxLength(), expression.getScale()); } return LiteralExpression.newConstant(value, type, expression.getDeterminism()); }
private void evaluateAndAssertResult(Expression expression, Object expectedResult, String context) { context = context == null ? "" : context; ImmutableBytesWritable ptr = new ImmutableBytesWritable(); assertTrue(expression.evaluate(null, ptr)); PDataType dataType = expression.getDataType(); SortOrder sortOrder = expression.getSortOrder(); Object result = dataType.toObject(ptr.get(), ptr.getOffset(), ptr.getLength(), dataType, sortOrder); assertEquals(context, expectedResult, result); }