@Override public Integer getMaxLength() { Integer maxLength1 = children.get(0).getMaxLength(); if (maxLength1 != null) { Integer maxLength2 = children.get(1).getMaxLength(); if (maxLength2 != null) { return maxLength1 > maxLength2 ? maxLength1 : maxLength2; } } return null; }
@Override public Integer getMaxLength() { return children.get(2).getMaxLength(); }
@Override public Integer getMaxLength() { return getStringExpression().getMaxLength(); }
@Override public Integer getMaxLength() { return getExpression().getMaxLength(); } }
@Override public Integer getMaxLength() { return getChildExpression().getMaxLength(); }
@Override protected boolean modifierFunction(ImmutableBytesWritable ptr, int len, int offset, byte[] array1Bytes, PDataType baseDataType, int actualLengthOfArray1, Integer maxLength, Expression array1Exp) { int actualLengthOfArray2 = Math.abs(PArrayDataType.getArrayLength(ptr, baseDataType, array1Exp.getMaxLength())); // FIXME: concatArrays will be fine if it's copying the separator bytes, including the terminating bytes. return PArrayDataType.concatArrays(ptr, len, offset, array1Bytes, baseDataType, actualLengthOfArray1, actualLengthOfArray2); }
protected void checkSizeCompatibility(ImmutableBytesWritable ptr, SortOrder sortOrder, Expression arrayExpr, PDataType baseDataType, Expression otherExpr, PDataType otherExpressionType) { if (!baseDataType.isSizeCompatible(ptr, null, otherExpressionType, sortOrder, otherExpr.getMaxLength(), otherExpr.getScale(), arrayExpr.getMaxLength(), arrayExpr.getScale())) { throw new DataExceedsCapacityException("Values are not size compatible"); } }
@Override public int getPrecision(int column) throws SQLException { Integer precision = rowProjector.getColumnProjector(column-1).getExpression().getMaxLength(); return precision == null ? 0 : precision; }
public static Expression create(Expression expression, PDataType toType, SortOrder toSortOrder, Integer maxLength, boolean rowKeyOrderOptimizable) throws SQLException { if ( toType == expression.getDataType() && toSortOrder == expression.getSortOrder() && (maxLength == null || maxLength.equals(expression.getMaxLength())) ) { return expression; } return new CoerceExpression(expression, toType, toSortOrder, maxLength, rowKeyOrderOptimizable); }
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()); }
@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; }
public TargetDataExpression(Expression expr) { this.type = expr.getDataType(); this.maxLength = expr.getMaxLength(); this.scale = expr.getScale(); this.sortOrder = expr.getSortOrder(); }
public TrimFunction(List<Expression> children) throws SQLException { super(children); if (getStringExpression().getDataType().isFixedWidth()) { maxLength = getStringExpression().getMaxLength(); } }
private Integer getMaxLength(Expression expression) { PDataType type = expression.getDataType(); if (type.isFixedWidth() && type.getByteSize() != null) { return type.getByteSize(); } return expression.getMaxLength(); }
@Override public Expression wrap(Expression lhs, Expression rhs, boolean rowKeyOrderOptimizable) throws SQLException { Expression e = rhs; PDataType rhsType = rhs.getDataType(); PDataType lhsType = lhs.getDataType(); if (rhsType == PDecimal.INSTANCE && lhsType != PDecimal.INSTANCE) { e = FloorDecimalExpression.create(rhs); } else if ((rhsType == PTimestamp.INSTANCE || rhsType == PUnsignedTimestamp.INSTANCE) && (lhsType != PTimestamp.INSTANCE && lhsType != PUnsignedTimestamp.INSTANCE)) { e = FloorDateExpression.create(rhs, TimeUnit.MILLISECOND); } e = CoerceExpression.create(e, lhsType, lhs.getSortOrder(), lhs.getMaxLength(), rowKeyOrderOptimizable); return e; }
private static void testExpression(LiteralExpression array, LiteralExpression delimiter, LiteralExpression nullString, PhoenixArray expected) throws SQLException { List<Expression> expressions = Lists.newArrayList((Expression) array); expressions.add(delimiter); expressions.add(nullString); Expression stringToArrayFunction = new StringToArrayFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); stringToArrayFunction.evaluate(null, ptr); PhoenixArray result = (PhoenixArray) stringToArrayFunction.getDataType().toObject(ptr, stringToArrayFunction.getSortOrder(), stringToArrayFunction.getMaxLength(), stringToArrayFunction.getScale()); assertEquals(expected, result); }
private static void testExpression(LiteralExpression array, LiteralExpression delimiter, LiteralExpression nullString, String expected) throws SQLException { List<Expression> expressions = Lists.newArrayList((Expression) array); expressions.add(delimiter); expressions.add(nullString); Expression arrayToStringFunction = new ArrayToStringFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); arrayToStringFunction.evaluate(null, ptr); String result = (String) arrayToStringFunction.getDataType().toObject(ptr, arrayToStringFunction.getSortOrder(), arrayToStringFunction.getMaxLength(), arrayToStringFunction.getScale()); assertEquals(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; }
private static void testExpression(LiteralExpression element, LiteralExpression length, PhoenixArray expected) throws SQLException { List<Expression> expressions = Lists.newArrayList((Expression) element); expressions.add(length); Expression arrayFillFunction = new ArrayFillFunction(expressions); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); arrayFillFunction.evaluate(null, ptr); PhoenixArray result = (PhoenixArray) arrayFillFunction.getDataType().toObject(ptr, arrayFillFunction.getSortOrder(), arrayFillFunction.getMaxLength(), arrayFillFunction.getScale()); assertEquals(expected, result); }
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()); }