@Override public RowProjector getProjector() { return delegate.getProjector(); }
final PhoenixStatement pstmt = statement.unwrap(PhoenixStatement.class); final QueryPlan queryPlan = pstmt.compileQuery(sqlQuery); final List<? extends ColumnProjector> projectedColumns = queryPlan.getProjector().getColumnProjectors(); columnInfos = Lists.newArrayListWithCapacity(projectedColumns.size()); columnInfos = Lists.transform(projectedColumns, new Function<ColumnProjector,ColumnInfo>() {
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; }
isValidStatement(queryPlan); final String tableName = queryPlan.getTableRef().getTable().getName().getString(); final List<? extends ColumnProjector> projectedColumns = queryPlan.getProjector().getColumnProjectors(); final List<String> columns = Lists.transform(projectedColumns, new Function<ColumnProjector,String>() {
@Override public ResultSetMetaData getMetaData() throws SQLException { if (statement.getOperation().isMutation()) { return null; } int paramCount = statement.getBindCount(); List<Object> params = this.getParameters(); BitSet unsetParams = new BitSet(statement.getBindCount()); for (int i = 0; i < paramCount; i++) { if ( params.get(i) == BindManager.UNBOUND_PARAMETER) { unsetParams.set(i); params.set(i, null); } } try { // Just compile top level query without optimizing to get ResultSetMetaData QueryPlan plan = statement.compilePlan(this, Sequence.ValueOp.VALIDATE_SEQUENCE); return new PhoenixResultSetMetaData(this.getConnection(), plan.getProjector()); } finally { int lastSetBit = 0; while ((lastSetBit = unsetParams.nextSetBit(lastSetBit)) != -1) { params.set(lastSetBit, BindManager.UNBOUND_PARAMETER); lastSetBit++; } } }
List<? extends ColumnProjector> projectors = dataPlan.getProjector().getColumnProjectors(); List<PDatum> targetDatums = Lists.newArrayListWithExpectedSize(projectors.size()); for (ColumnProjector projector : projectors) {
protected QueryPlan compileSingleQuery(StatementContext context, SelectStatement select, List<Object> binds, boolean asSubquery, boolean allowPageFilter) throws SQLException{ SelectStatement innerSelect = select.getInnerSelectStatement(); if (innerSelect == null) { return compileSingleFlatQuery(context, select, binds, asSubquery, allowPageFilter, null, null, true); } QueryPlan innerPlan = compileSubquery(innerSelect, false); TupleProjector tupleProjector = new TupleProjector(innerPlan.getProjector()); innerPlan = new TupleProjectionPlan(innerPlan, tupleProjector, null); // Replace the original resolver and table with those having compiled type info. TableRef tableRef = context.getResolver().getTables().get(0); ColumnResolver resolver = FromCompiler.getResolverForCompiledDerivedTable(statement.getConnection(), tableRef, innerPlan.getProjector()); context.setResolver(resolver); tableRef = resolver.getTables().get(0); context.setCurrentTable(tableRef); boolean isInRowKeyOrder = innerPlan.getGroupBy() == GroupBy.EMPTY_GROUP_BY && innerPlan.getOrderBy() == OrderBy.EMPTY_ORDER_BY; return compileSingleFlatQuery(context, select, binds, asSubquery, allowPageFilter, innerPlan, tupleProjector, isInRowKeyOrder); }
this.resultSet = new PhoenixResultSet(this.resultIterator, queryPlan.getProjector() .cloneIfNecessary(), queryPlan.getContext());
ResultIterator iterator = plan.iterator(); try { RowProjector projector = plan.getProjector(); ImmutableBytesWritable ptr = new ImmutableBytesWritable(); int columnCount = projector.getColumnCount();
for (int i = 0; i < plans.size(); i++) { QueryPlan subPlan = plans.get(i); TupleProjector projector = getTupleProjector(subPlan.getProjector(), targetTypes); subPlan = new TupleProjectionPlan(subPlan, projector, null); plans.set(i, subPlan); for (int i = 0; i < plan.getProjector().getColumnCount(); i++) { ColumnProjector colProj = plan.getProjector().getColumnProjector(i); String name = selectNodes == null ? colProj.getName() : selectNodes.get(i).getAlias(); PName colName = PNameFactory.newName(name);
public QueryPlan compileUnionAll(SelectStatement select) throws SQLException { List<SelectStatement> unionAllSelects = select.getSelects(); List<QueryPlan> plans = new ArrayList<QueryPlan>(); for (int i=0; i < unionAllSelects.size(); i++ ) { SelectStatement subSelect = unionAllSelects.get(i); // Push down order-by and limit into sub-selects. if (!select.getOrderBy().isEmpty() || select.getLimit() != null) { if (select.getOffset() == null) { subSelect = NODE_FACTORY.select(subSelect, select.getOrderBy(), select.getLimit(), null); } else { subSelect = NODE_FACTORY.select(subSelect, select.getOrderBy(), null, null); } } QueryPlan subPlan = compileSubquery(subSelect, true); plans.add(subPlan); } TableRef tableRef = UnionCompiler.contructSchemaTable(statement, plans, select.hasWildcard() ? null : select.getSelect()); ColumnResolver resolver = FromCompiler.getResolver(tableRef); StatementContext context = new StatementContext(statement, resolver, scan, sequenceManager); QueryPlan plan = compileSingleFlatQuery(context, select, statement.getParameters(), false, false, null, null, false); plan = new UnionPlan(context, select, tableRef, plan.getProjector(), plan.getLimit(), plan.getOffset(), plan.getOrderBy(), GroupBy.EMPTY_GROUP_BY, plans, context.getBindManager().getParameterMetaData()); return plan; }
this.resultSet = new PhoenixResultSet(this.resultIterator, queryPlan.getProjector().cloneIfNecessary(), queryPlan.getContext()); } catch (SQLException e) { LOG.error(String.format(" Error [%s] initializing PhoenixRecordReader. ",e.getMessage()));
RowProjector projector = bestPlan.getProjector(); TableRef tableRef = bestPlan.getTableRef(); PTable table = tableRef.getTable();
PTable projectedTable = table.createProjectedTable(plan.getProjector()); context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), subquery.getUdfParseNodes())); return new TupleProjectionPlan(plan, new TupleProjector(plan.getProjector()), table.compilePostFilterExpression(context));
List<Object> binds = Collections.emptyList(); QueryPlan plan = getQueryPlan(query, binds); RowProjector p = plan.getProjector();
this.resultSet = new PhoenixResultSet(iterator, queryPlan.getProjector().cloneIfNecessary(), queryPlan.getContext()); this.iterator = SparkJdbcUtil.resultSetToSparkInternalRows(resultSet, schema, new InputMetrics());
private QueryPlan addPlan(PhoenixStatement statement, SelectStatement select, PTable index, List<? extends PDatum> targetColumns, ParallelIteratorFactory parallelIteratorFactory, QueryPlan dataPlan, boolean isHinted) throws SQLException { int nColumns = dataPlan.getProjector().getColumnCount(); String tableAlias = dataPlan.getTableRef().getTableAlias(); String alias = tableAlias==null ? null : '"' + tableAlias + '"'; // double quote in case it's case sensitive if (plan.getProjector().getColumnCount() == nColumns) { return plan; } else if (index.getIndexType() == IndexType.GLOBAL) {
@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(); } }
} else { FilterableStatement statement = plan.getStatement(); RowProjector projector = plan.getProjector(); boolean optimizeProjection = false; boolean keyOnlyFilter = familyMap.isEmpty() && context.getWhereConditionColumns().isEmpty();
SelectStatement subquery = table.getAsSubquery(orderBy); QueryPlan plan = compileSubquery(subquery, false); initialProjectedTable = table.createProjectedTable(plan.getProjector()); tableRef = plan.getTableRef(); context.getScan().setFamilyMap(plan.getContext().getScan().getFamilyMap()); query = joinTable.getAsSingleSubquery((SelectStatement) plan.getStatement(), asSubquery); tupleProjector = new TupleProjector(plan.getProjector()); SelectStatement subquery = rhsTable.getAsSubquery(orderBy); QueryPlan plan = compileSubquery(subquery, false); rhsProjTable = rhsTable.createProjectedTable(plan.getProjector()); rhsTableRef = plan.getTableRef(); context.getScan().setFamilyMap(plan.getContext().getScan().getFamilyMap()); rhs = rhsJoinTable.getAsSingleSubquery((SelectStatement) plan.getStatement(), asSubquery); tupleProjector = new TupleProjector(plan.getProjector());