@Override public String toString() { StringBuilder buf = new StringBuilder("["); for (ColumnProjector projector : columnProjectors) { buf.append(projector.getExpression()); buf.append(','); } if (buf.length() > 1) { buf.setLength(buf.length()-1); } buf.append(']'); return buf.toString(); }
/** * allow individual expressions to reset their state between rows */ public void reset() { for (ColumnProjector projector : columnProjectors) { projector.getExpression().reset(); } } }
@Override public int getScale(int column) throws SQLException { Integer scale = rowProjector.getColumnProjector(column-1).getExpression().getScale(); return scale == null ? 0 : scale; }
@Override public int getColumnDisplaySize(int column) throws SQLException { ColumnProjector projector = rowProjector.getColumnProjector(column-1); PDataType type = projector.getExpression().getDataType(); if (type == null) { return QueryConstants.NULL_DISPLAY_TEXT.length(); } if (type.isCoercibleTo(PDate.INSTANCE)) { return connection.getDatePattern().length(); } if (projector.getExpression().getMaxLength() != null) { return projector.getExpression().getMaxLength(); } return DEFAULT_DISPLAY_WIDTH; }
@Override public int getPrecision(int column) throws SQLException { Integer precision = rowProjector.getColumnProjector(column-1).getExpression().getMaxLength(); return precision == null ? 0 : precision; }
@Override public int isNullable(int column) throws SQLException { return rowProjector.getColumnProjector(column-1).getExpression().isNullable() ? ResultSetMetaData.columnNullable : ResultSetMetaData.columnNoNulls; }
private static TupleProjector getTupleProjector(RowProjector rowProj, List<TargetDataExpression> targetTypes) throws SQLException { Expression[] exprs = new Expression[targetTypes.size()]; int i = 0; for (ColumnProjector colProj : rowProj.getColumnProjectors()) { exprs[i] = CoerceExpression.create(colProj.getExpression(), targetTypes.get(i).getType(), targetTypes.get(i).getSortOrder(), targetTypes.get(i).getMaxLength()); i++; } return new TupleProjector(exprs); }
@Override public String getColumnTypeName(int column) throws SQLException { PDataType type = rowProjector.getColumnProjector(column-1).getExpression().getDataType(); return type == null ? null : type.getSqlTypeName(); }
@Override public boolean isSigned(int column) throws SQLException { PDataType type = rowProjector.getColumnProjector(column-1).getExpression().getDataType(); if (type == null) { return false; } return type.isCoercibleTo(PDecimal.INSTANCE); }
@Override public String getColumnClassName(int column) throws SQLException { PDataType type = rowProjector.getColumnProjector(column-1).getExpression().getDataType(); return type == null ? null : type.getJavaClassName(); }
@Override public int getColumnType(int column) throws SQLException { PDataType type = rowProjector.getColumnProjector(column-1).getExpression().getDataType(); return type == null ? Types.NULL : type.getResultSetSqlType(); }
ResultEntry(Tuple result) { final int prime = 31; this.result = result; int hashCode = 0; for (ColumnProjector column : rowProjector.getColumnProjectors()) { Expression e = column.getExpression(); if (e.evaluate(this.result, ptr1)) { hashCode = prime * hashCode + ptr1.hashCode(); } } this.hashCode = hashCode; }
public TupleProjector(RowProjector rowProjector) { List<? extends ColumnProjector> columnProjectors = rowProjector.getColumnProjectors(); int count = columnProjectors.size(); KeyValueSchemaBuilder builder = new KeyValueSchemaBuilder(0); expressions = new Expression[count]; for (int i = 0; i < count; i++) { Expression expression = columnProjectors.get(i).getExpression(); builder.addField(expression); expressions[i] = expression; } schema = builder.build(); valueSet = ValueBitSet.newInstance(schema); }
@Override public String getString(int columnIndex) throws SQLException { checkCursorState(); // Get the value using the expected type instead of trying to coerce to VARCHAR. // We can't coerce using our formatter because we don't have enough context in PDataType. ColumnProjector projector = rowProjector.getColumnProjector(columnIndex-1); PDataType type = projector.getExpression().getDataType(); Object value = projector.getValue(currentRow,type, ptr); if (wasNull = (value == null)) { return null; } // Run Object through formatter to get String. // This provides a simple way of getting a reasonable string representation // for types like DATE and TIME Format formatter = statement.getFormatter(type); return formatter == null ? value.toString() : formatter.format(value); }
@Override public Array getArray(int columnIndex) throws SQLException { checkCursorState(); // Get the value using the expected type instead of trying to coerce to VARCHAR. // We can't coerce using our formatter because we don't have enough context in PDataType. ColumnProjector projector = rowProjector.getColumnProjector(columnIndex-1); Array value = (Array)projector.getValue(currentRow, projector.getExpression().getDataType(), ptr); wasNull = (value == null); return value; }
@Override public Object getObject(int columnIndex) throws SQLException { checkCursorState(); ColumnProjector projector = rowProjector.getColumnProjector(columnIndex-1); Object value = projector.getValue(currentRow, projector.getExpression().getDataType(), ptr); wasNull = (value == null); return value; }
@Override public ColumnInfo apply(final ColumnProjector columnProjector) { return new ColumnInfo(columnProjector.getName(), columnProjector.getExpression().getDataType().getSqlType()); }
private static List<TargetDataExpression> checkProjectionNumAndExpressions( List<QueryPlan> selectPlans) throws SQLException { int columnCount = selectPlans.get(0).getProjector().getColumnCount(); List<TargetDataExpression> targetTypes = new ArrayList<TargetDataExpression>(columnCount); for (int i = 0; i < columnCount; i++) { for (QueryPlan plan : selectPlans) { if (columnCount !=plan.getProjector().getColumnCount()) { throw new SQLExceptionInfo.Builder(SQLExceptionCode .SELECT_COLUMN_NUM_IN_UNIONALL_DIFFS).setMessage("1st query has " + columnCount + " columns whereas 2nd " + "query has " + plan.getProjector().getColumnCount()) .build().buildException(); } ColumnProjector colproj = plan.getProjector().getColumnProjector(i); if(targetTypes.size() < i+1 ) { targetTypes.add(new TargetDataExpression(colproj.getExpression())); } else { compareExperssions(i, colproj.getExpression(), targetTypes); } } } return targetTypes; }
private static void assertLiteralEquals(Object o, RowProjector p, int i) { assertTrue(i < p.getColumnCount()); Expression e = p.getColumnProjector(i).getExpression(); assertTrue(e instanceof LiteralExpression); LiteralExpression l = (LiteralExpression)e; Object lo = l.getValue(); assertEquals(o, lo); }
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())); }