@Override public Integer getScale() { return delegate.getScale(); }
@Override public Integer getScale() { return children.get(2).getScale(); } }
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 getScale(int column) throws SQLException { Integer scale = rowProjector.getColumnProjector(column-1).getExpression().getScale(); return scale == null ? 0 : scale; }
protected Integer getScale(Expression e) { Integer scale = e.getScale(); if (scale != null) { return scale; } PDataType dataType = e.getDataType(); if (dataType != null) { scale = dataType.getScale(null); if (scale != null) { return scale; } } return null; } protected int getPrecision(Expression e) {
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()); }
public TargetDataExpression(Expression expr) { this.type = expr.getDataType(); this.maxLength = expr.getMaxLength(); this.scale = expr.getScale(); this.sortOrder = expr.getSortOrder(); }
@Override public final Object getValue(Tuple tuple, PDataType type, ImmutableBytesWritable ptr) throws SQLException { try { Expression expression = getExpression(); if (!expression.evaluate(tuple, ptr)) { return null; } if (ptr.getLength() == 0) { return null; } return type.toObject(ptr, expression.getDataType(), expression.getSortOrder(), expression.getMaxLength(), expression.getScale()); } catch (RuntimeException e) { // FIXME: Expression.evaluate does not throw SQLException // so this will unwrap throws from that. if (e.getCause() instanceof SQLException) { throw (SQLException) e.getCause(); } throw e; } }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { Expression delimiterExpr = children.get(1); if (!delimiterExpr.evaluate(tuple, ptr)) { return false; } else if (ptr.getLength() == 0) { return true; } String delimiter = (String) delimiterExpr.getDataType().toObject(ptr, delimiterExpr.getSortOrder(), delimiterExpr.getMaxLength(), delimiterExpr.getScale()); Expression arrayExpr = children.get(0); if (!arrayExpr.evaluate(tuple, ptr)) { return false; } else if (ptr.getLength() == 0) { return true; } PhoenixArray array = (PhoenixArray) arrayExpr.getDataType().toObject(ptr, arrayExpr.getSortOrder(), arrayExpr.getMaxLength(), arrayExpr.getScale()); Expression nullExpr = children.get(2); String nullString = null; if (nullExpr.evaluate(tuple, ptr) && ptr.getLength() != 0) { nullString = (String) nullExpr.getDataType().toObject(ptr, nullExpr.getSortOrder(), nullExpr.getMaxLength(), nullExpr.getScale()); } return PArrayDataType.arrayToString(ptr, array, delimiter, nullString, getSortOrder()); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { Expression delimiterExpr = children.get(1); String delimiter; if (!delimiterExpr.evaluate(tuple, ptr)) { return false; } else if (ptr.getLength() == 0) { delimiter = ""; } else { delimiter = (String) delimiterExpr.getDataType().toObject(ptr, delimiterExpr.getSortOrder(), delimiterExpr.getMaxLength(), delimiterExpr.getScale()); } Expression stringExpr = children.get(0); if (!stringExpr.evaluate(tuple, ptr)) { return false; } else if (ptr.getLength() == 0) { return true; } String string = (String) stringExpr.getDataType().toObject(ptr, stringExpr.getSortOrder(), stringExpr.getMaxLength(), stringExpr.getScale()); Expression nullExpr = children.get(2); String nullString = null; if (nullExpr.evaluate(tuple, ptr) && ptr.getLength() != 0) { nullString = (String) nullExpr.getDataType().toObject(ptr, nullExpr.getSortOrder(), nullExpr.getMaxLength(), nullExpr.getScale()); } return PArrayDataType.stringToArray(ptr, string, delimiter, nullString, getSortOrder()); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { boolean evaluated = children.get(0).evaluate(tuple, ptr); if (evaluated) { // Will potentially evaluate to null without evaluating the second expression return true; } if (tuple.isImmutable()) {// True for the last time an evaluation is happening on the row Expression secondChild = children.get(1); if (secondChild.evaluate(tuple, ptr)) { // Coerce the type of the second child to the type of the first child getDataType().coerceBytes(ptr, null, secondChild.getDataType(), secondChild.getMaxLength(), secondChild.getScale(), secondChild.getSortOrder(), getMaxLength(), getScale(), getSortOrder()); return true; } } return false; }
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); }
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()); }
public static ColumnResolver getResolverForCompiledDerivedTable(PhoenixConnection connection, TableRef tableRef, RowProjector projector) throws SQLException { List<PColumn> projectedColumns = new ArrayList<PColumn>(); PTable table = tableRef.getTable(); for (PColumn column : table.getColumns()) { Expression sourceExpression = projector.getColumnProjector(column.getPosition()).getExpression(); PColumnImpl projectedColumn = new PColumnImpl(column.getName(), column.getFamilyName(), sourceExpression.getDataType(), sourceExpression.getMaxLength(), sourceExpression.getScale(), sourceExpression.isNullable(), column.getPosition(), sourceExpression.getSortOrder(), column.getArraySize(), column.getViewConstant(), column.isViewReferenced(), column.getExpressionStr(), column.isRowTimestamp(), column.isDynamic(), column.getColumnQualifierBytes(), column.getTimestamp()); projectedColumns.add(projectedColumn); } PTable t = PTableImpl.builderWithColumns(table, projectedColumns) .build(); return new SingleTableColumnResolver(connection, new TableRef(tableRef.getTableAlias(), t, tableRef.getLowerBoundTimeStamp(), tableRef.hasDynamicCols())); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (!getElementExpr().evaluate(tuple, ptr)) { return false; } Object element = getElementExpr().getDataType().toObject(ptr, getElementExpr().getSortOrder(), getElementExpr().getMaxLength(), getElementExpr().getScale()); if (!getLengthExpr().evaluate(tuple, ptr) || ptr.getLength() == 0) { return false; } int length = (Integer) getLengthExpr().getDataType().toObject(ptr, getLengthExpr().getSortOrder(), getLengthExpr().getMaxLength(), getLengthExpr().getScale()); if (length <= 0) { throw new IllegalArgumentException("Array length should be greater than 0"); } Object[] elements = new Object[length]; Arrays.fill(elements, element); PhoenixArray array = PDataType.instantiatePhoenixArray(getElementExpr().getDataType(), elements); //When max length of a char array is not the max length of the element passed in if (getElementExpr().getDataType().isFixedWidth() && getMaxLength() != null && getMaxLength() != array.getMaxLength()) { array = new PhoenixArray(array, getMaxLength()); } ptr.set(((PArrayDataType) getDataType()).toBytes(array, getElementExpr().getDataType(), getElementExpr().getSortOrder())); return true; }
@Test public void testColumnProjectionUnionAll() throws SQLException { Connection conn = DriverManager.getConnection(getUrl()); try { conn.createStatement().execute("CREATE TABLE t1(k INTEGER PRIMARY KEY,"+ " col1 CHAR(8), col2 VARCHAR(10), col3 decimal(10,2))"); conn.createStatement().execute("CREATE TABLE t2(k TINYINT PRIMARY KEY," + " col1 CHAR(20), col2 CHAR(30), col3 double)"); QueryPlan plan = getQueryPlan("SELECT * from t1 union all select * from t2", Collections.emptyList()); RowProjector rowProj = plan.getProjector(); assertTrue(rowProj.getColumnProjector(0).getExpression().getDataType() instanceof PInteger); assertTrue(rowProj.getColumnProjector(1).getExpression().getDataType() instanceof PChar); assertTrue(rowProj.getColumnProjector(1).getExpression().getMaxLength() == 20); assertTrue(rowProj.getColumnProjector(2).getExpression().getDataType() instanceof PVarchar); assertTrue(rowProj.getColumnProjector(2).getExpression().getMaxLength() == 30); assertTrue(rowProj.getColumnProjector(3).getExpression().getDataType() instanceof PDecimal); assertTrue(rowProj.getColumnProjector(3).getExpression().getScale() == 2); } finally { conn.close(); } }