SelectStatement subquery = table.getAsSubquery(orderBy); if (!table.isSubselect()) { context.setCurrentTable(table.getTableRef()); PTable projectedTable = table.createProjectedTable(!projectPKColumns, context); TupleProjector projector = new TupleProjector(projectedTable); TupleProjector.serializeProjectorIntoScan(context.getScan(), projector); context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), subquery.getUdfParseNodes())); table.projectColumns(context.getScan()); return compileSingleFlatQuery(context, subquery, binds, asSubquery, !asSubquery, null, projectPKColumns ? projector : null, true); context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), subquery.getUdfParseNodes())); return new TupleProjectionPlan(plan, new TupleProjector(plan.getProjector()), table.compilePostFilterExpression(context)); Cost bestCost = null; for (JoinCompiler.Strategy strategy : strategies) { StatementContext newContext = new StatementContext( context.getStatement(), context.getResolver(), new Scan(), context.getSequenceManager()); QueryPlan plan = compileJoinQuery( strategy, newContext, binds, joinTable, asSubquery, projectPKColumns, orderBy); context.setResolver(bestPlan.getContext().getResolver()); context.setCurrentTable(bestPlan.getContext().getCurrentTable()); return bestPlan;
public PhoenixResultSet(ResultIterator resultIterator, RowProjector rowProjector, StatementContext ctx) throws SQLException { this.rowProjector = rowProjector; this.scanner = resultIterator; this.context = ctx; this.statement = context.getStatement(); this.readMetricsQueue = context.getReadMetricsQueue(); this.overAllQueryMetrics = context.getOverallQueryMetrics(); this.queryLogger = context.getQueryLogger() != null ? context.getQueryLogger() : QueryLogger.NO_OP_INSTANCE; }
public ClientAggregatePlan(StatementContext context, FilterableStatement statement, TableRef table, RowProjector projector, Integer limit, Integer offset, Expression where, OrderBy orderBy, GroupBy groupBy, Expression having, QueryPlan delegate) { super(context, statement, table, projector, limit, offset, where, orderBy, delegate); this.groupBy = groupBy; this.having = having; this.clientAggregators = context.getAggregationManager().getAggregators(); // We must deserialize rather than clone based off of client aggregators because // upon deserialization we create the server-side aggregators instead of the client-side // aggregators. We use the Configuration directly here to avoid the expense of creating // another one. this.serverAggregators = ServerAggregators.deserialize(context.getScan() .getAttribute(BaseScannerRegionObserver.AGGREGATORS), context.getConnection().getQueryServices().getConfiguration(), null); // Extract hash aggregate hint, if any. HintNode hints = statement.getHint(); useHashAgg = hints != null && hints.hasHint(HintNode.Hint.HASH_AGGREGATE); }
private void setMetricsInParentContext() { ReadMetricQueue parentCtxReadMetrics = parentStmtCtx.getReadMetricsQueue(); for (ReadMetricQueue readMetrics : readMetricsList) { parentCtxReadMetrics.combineReadMetrics(readMetrics); } OverAllQueryMetrics parentCtxQueryMetrics = parentStmtCtx.getOverallQueryMetrics(); for (OverAllQueryMetrics metric : overAllQueryMetricsList) { parentCtxQueryMetrics.combine(metric); } }
protected void addColumn(PColumn column) { EncodedColumnsUtil.setColumns(column, context.getCurrentTable().getTable(), context.getScan()); }
()); StatementContext ctx = queryPlan.getContext(); ReadMetricQueue readMetrics = ctx.getReadMetricsQueue(); String tableName = queryPlan.getTableRef().getTable().getPhysicalName().getString(); long renewScannerLeaseThreshold = queryPlan.getContext().getConnection() .getQueryServices().getRenewLeaseThresholdMilliSeconds(); for (Scan scan : scans) { scan.setAttribute(BaseScannerRegionObserver.SKIP_REGION_BOUNDARY_CHECK, Bytes .toBytes(true)); ScanMetricsHolder scanMetricsHolder = ScanMetricsHolder.getInstance(readMetrics, tableName, scan, ctx.getConnection().getLogLevel()); final TableResultIterator tableResultIterator = new TableResultIterator( queryPlan.getContext().getConnection().getMutationState(), scan, scanMetricsHolder, renewScannerLeaseThreshold, queryPlan, MapReduceParallelScanGrouper.getInstance()); ? RoundRobinResultIterator.newIterator(iterators, queryPlan) : ConcatResultIterator.newIterator(iterators); if (queryPlan.getContext().getSequenceManager().getSequenceCount() > 0) { iterator = new SequenceResultIterator(iterator, queryPlan.getContext() .getSequenceManager());
projectedTable = TupleProjectionCompiler.createProjectedTable(select, context); if (projectedTable != null) { context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), select.getUdfParseNodes())); ColumnResolver resolver = context.getResolver(); TableRef tableRef = context.getCurrentTable(); PTable table = tableRef.getTable(); context.setResolver(FromCompiler.getResolver(context.getConnection(), tableRef, select.getUdfParseNodes())); context.setResolver(resolver); // recover resolver RowProjector projector = ProjectionCompiler.compile(context, select, groupBy, asSubquery ? Collections.<PDatum>emptyList() : targetColumns, where); OrderBy orderBy = OrderByCompiler.compile( isInRowKeyOrder, where); context.getAggregationManager().compile(context, groupBy); TupleProjector.serializeProjectorIntoScan(context.getScan(), new TupleProjector(projectedTable));
public ClientHashAggregatingResultIterator(StatementContext context, ResultIterator resultIterator, Aggregators aggregators, List<Expression> groupByExpressions, OrderBy orderBy) { Objects.requireNonNull(resultIterator); Objects.requireNonNull(aggregators); Objects.requireNonNull(groupByExpressions); this.resultIterator = resultIterator; this.aggregators = aggregators; this.groupByExpressions = groupByExpressions; this.orderBy = orderBy; memoryChunk = context.getConnection().getQueryServices().getMemoryManager().allocate(CLIENT_HASH_AGG_MEMORY_CHUNK_SIZE); }
@Override protected void submitWork(final List<List<Scan>> nestedScans, List<List<Pair<Scan,Future<PeekingResultIterator>>>> nestedFutures, final Queue<PeekingResultIterator> allIterators, int estFlattenedSize, boolean isReverse, final ParallelScanGrouper scanGrouper) { ExecutorService executor = context.getConnection().getQueryServices().getExecutor(); final String tableName = tableRef.getTable().getPhysicalName().getString(); final TaskExecutionMetricsHolder taskMetrics = new TaskExecutionMetricsHolder(context.getReadMetricsQueue(), tableName); final PhoenixConnection conn = context.getConnection(); final long renewLeaseThreshold = conn.getQueryServices().getRenewLeaseThresholdMilliSeconds(); int expectedListSize = nestedScans.size() * 10;
private boolean getKeyExpressionCombinations(Pair<Expression, Expression> combination, StatementContext context, SelectStatement select, TableRef table, JoinType type, final List<Expression> joinExpressions, final List<Expression> hashExpressions) throws SQLException { if ((type != JoinType.Inner && type != JoinType.Semi) || this.noChildParentJoinOptimization) return false; Scan scanCopy = ScanUtil.newScan(context.getScan()); StatementContext contextCopy = new StatementContext(statement, context.getResolver(), scanCopy, new SequenceManager(statement)); contextCopy.setCurrentTable(table); List<Expression> lhsCombination = Lists.<Expression> newArrayList(); boolean complete = WhereOptimizer.getKeyExpressionCombination(lhsCombination, contextCopy, select, joinExpressions); if (lhsCombination.isEmpty()) return false; List<Expression> rhsCombination = Lists.newArrayListWithExpectedSize(lhsCombination.size()); for (int i = 0; i < lhsCombination.size(); i++) { Expression lhs = lhsCombination.get(i); for (int j = 0; j < joinExpressions.size(); j++) { if (lhs == joinExpressions.get(j)) { rhsCombination.add(hashExpressions.get(j)); break; } } } if (lhsCombination.size() == 1) { combination.setFirst(lhsCombination.get(0)); combination.setSecond(rhsCombination.get(0)); } else { combination.setFirst(new RowValueConstructorExpression(lhsCombination, false)); combination.setSecond(new RowValueConstructorExpression(rhsCombination, false)); } return type == JoinType.Semi && complete; }
public LocalIndexDataColumnRef(StatementContext context, TableRef tRef, String indexColumnName) throws MetaDataEntityNotFoundException, SQLException { super(FromCompiler.getResolver( FACTORY.namedTable( null, TableName.create(tRef.getTable().getSchemaName().getString(), tRef.getTable() .getParentTableName().getString())), context.getConnection(), false) .resolveTable(context.getCurrentTable().getTable().getSchemaName().getString(), tRef.getTable().getParentTableName().getString()), IndexUtil.getDataColumnFamilyName(indexColumnName), IndexUtil .getDataColumnName(indexColumnName)); position = context.getDataColumnPosition(this.getColumn()); columns = context.getDataColumns(); }
private synchronized void openCursor(Connection conn) throws SQLException { if(isOpen){ return; } this.scan = this.queryPlan.getContext().getScan(); isReversed=OrderBy.REV_ROW_KEY_ORDER_BY.equals(this.queryPlan.getOrderBy()); isOpen = true; }
Scan scan = ScanUtil.newScan(context.getScan()); SelectStatement select = SelectStatement.COUNT_ONE; StatementContext context = new StatementContext(statement, resolver, scan, new SequenceManager(statement)); long ts = timestamp; context.getAggregationManager().compile(context, GroupBy.EMPTY_GROUP_BY); try { Tuple row = iterator.next(); ImmutableBytesWritable ptr = context.getTempPtr(); totalMutationCount += (Long)projector.getColumnProjector(0).getValue(row, PLong.INSTANCE, ptr); } catch (SQLException e) {
Scan scan = queryPlanToBe.getContext().getScan(); ScanUtil.setTimeRange(scan, scan.getTimeRange().getMin(), serverTime); RowProjector aggProjectorToBe = ProjectionCompiler.compile(statementContext, select, GroupBy .EMPTY_GROUP_BY); statementContext.getAggregationManager().compile(queryPlan.getContext() ,GroupBy.EMPTY_GROUP_BY); if (queryPlan.getProjector().projectEveryRow()) { final Scan scan = context.getScan(); scan.setAttribute(BaseScannerRegionObserver.UPSERT_SELECT_TABLE, UngroupedAggregateRegionObserver.serialize(projectedTable)); scan.setAttribute(BaseScannerRegionObserver.UPSERT_SELECT_EXPRS, UngroupedAggregateRegionObserver.serialize(projectedExpressions)); final QueryPlan aggPlan = new AggregatePlan(context, select, statementContext.getCurrentTable(), aggProjector, null,null, OrderBy.EMPTY_ORDER_BY, null, GroupBy.EMPTY_GROUP_BY, null, originalQueryPlan); return new ServerUpsertSelectMutationPlan(queryPlan, tableRef, originalQueryPlan, context, connection, scan, aggPlan, aggProjector, maxSize, maxSizeBytes); final StatementContext context = new StatementContext(statement, resolver, new Scan(), new SequenceManager(statement)); UpsertValuesCompiler expressionBuilder = new UpsertValuesCompiler(context); final List<Expression> constantExpressions = Lists.newArrayListWithExpectedSize(valueNodes.size());
QueryPlan plan = iterator.next(); if (plan.getTableRef().getTable().getIndexType() == IndexType.LOCAL) { if (!plan.getContext().getDataColumns().isEmpty()) { iterator.remove(); QueryPlan plan = queryPlans.get(queryPlanIndex++); StatementContext context = plan.getContext(); noQueryReqd &= (!context.getScan().hasFilter() || context.getScan().getFilter() instanceof SkipScanFilter) && context.getScanRanges().isPointLookup(); Scan scan = context.getScan(); scan.setAttribute(BaseScannerRegionObserver.DELETE_AGG, QueryConstants.TRUE); context.getAggregationManager().compile(context, GroupBy.EMPTY_GROUP_BY); if (dataPlan.getProjector().projectEveryRow()) { projectorToBe = new RowProjector(projectorToBe,true);
if (context.getConnection().isDescVarLengthRowKeyUpgrade()) { RowProjector projector = plan.getProjector(); boolean optimizeProjection = false; boolean keyOnlyFilter = familyMap.isEmpty() && context.getWhereConditionColumns().isEmpty(); if (!projector.projectEverything()) { context.getWhereConditionColumns().clear(); for (PColumnFamily family : table.getColumnFamilies()) { context.addWhereConditionColumn(family.getName().getBytes(), null); cols < plan.getTableRef().getTable().getRowKeySchema().getFieldCount() && plan.getGroupBy().isOrderPreserving() && (context.getAggregationManager().isEmpty() || plan.getGroupBy().isUngroupedAggregate())) {
if (limit != null && orderBy.getOrderByExpressions().isEmpty() && having == null && ( ( statement.isDistinct() && ! statement.isAggregate() ) || ( ! statement.isDistinct() && ( context.getAggregationManager().isEmpty() || BaseScannerRegionObserver.KEY_ORDERED_GROUP_BY_EXPRESSIONS.equals(groupBy.getScanAttribName()) ) ) ) ) { int thresholdBytes = context.getConnection().getQueryServices().getProps().getInt( QueryServices.SPOOL_THRESHOLD_BYTES_ATTRIB, QueryServicesOptions.DEFAULT_SPOOL_THRESHOLD_BYTES); resultScanner = new OrderedAggregatingResultIterator(aggResultIterator, orderBy.getOrderByExpressions(), thresholdBytes, limit, offset); if (context.getSequenceManager().getSequenceCount() > 0) { resultScanner = new SequenceResultIterator(resultScanner, context.getSequenceManager());
ColumnRef ref = null; try { ref = context.getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); } catch (ColumnNotFoundException e) { if (context.getCurrentTable().getTable().getIndexType() == IndexType.LOCAL) { try { return new LocalIndexDataColumnRef(context, context.getCurrentTable(), node.getName()); } catch (ColumnFamilyNotFoundException c) { throw e; boolean isMultiTenant = context.getConnection().getTenantId() != null && table.isMultiTenant(); boolean isSharedViewIndex = table.getViewIndexId() != null; int minPosition = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0) + (isSharedViewIndex ? 1 : 0);
ResultIterator iterator = queryPlan.iterator(); if (parallelIteratorFactory == null) { return upsertSelect(new StatementContext(statement, queryPlan.getContext().getScan()), tableRef, projector, iterator, columnIndexes, pkSlotIndexes, useServerTimestamp, false); mutationState.setReadMetricQueue(context.getReadMetricsQueue()); return mutationState; } finally {
private static void projectAllTableColumns(StatementContext context, TableRef tableRef, boolean resolveColumn, List<Expression> projectedExpressions, List<ExpressionProjector> projectedColumns, List<? extends PDatum> targetColumns) throws SQLException { ColumnResolver resolver = context.getResolver(); PTable table = tableRef.getTable(); int projectedOffset = projectedExpressions.size(); int posOffset = table.getBucketNum() == null ? 0 : 1; int minPKOffset = getMinPKOffset(table, context.getConnection().getTenantId()); for (int i = posOffset, j = posOffset; i < table.getColumns().size(); i++) { PColumn column = table.getColumns().get(i); ImmutableBytesWritable ptr = context.getTempPtr(); if (IndexUtil.getViewConstantValue(column, ptr)) { expression = LiteralExpression.newConstant(column.getDataType().toObject(ptr), expression.getDataType());