public PhoenixConnection getConnection() { return statement.getConnection(); }
@Override public ResultSetMetaData getMetaData() throws SQLException { return new PhoenixResultSetMetaData(statement.getConnection(), rowProjector); }
public StatementContext(PhoenixStatement statement, ColumnResolver resolver, Scan scan, SequenceManager seqManager) { this(statement, resolver, scan, seqManager, statement.getConnection().isRequestLevelMetricsEnabled()); }
private JoinSpec(JoinType type, ParseNode onNode, JoinTable joinTable, boolean singleValueOnly, ColumnResolver resolver) throws SQLException { this.type = type; this.onConditions = new ArrayList<EqualParseNode>(); this.joinTable = joinTable; this.singleValueOnly = singleValueOnly; this.dependencies = new HashSet<TableRef>(); this.onNodeVisitor = new OnNodeVisitor(resolver, onConditions, dependencies, joinTable, statement.getConnection()); if (onNode != null) { onNode.accept(this.onNodeVisitor); } }
private Table(DerivedTableNode tableNode, boolean isWildcard, TableRef tableRef) throws SQLException { this.tableNode = tableNode; this.isWildcard = isWildcard; this.dynamicColumns = Collections.<ColumnDef>emptyList(); this.tableSamplingRate=ConcreteTableNode.DEFAULT_TABLE_SAMPLING_RATE; this.subselect = SubselectRewriter.flatten(tableNode.getSelect(), statement.getConnection()); this.tableRef = tableRef; this.preFilters = new ArrayList<ParseNode>(); this.postFilters = new ArrayList<ParseNode>(); this.isPostFilterConvertible = SubselectRewriter.isPostFilterConvertible(subselect); }
private void incrementSequenceValues() throws SQLException { if (sequenceMap == null) { return; } Long scn = statement.getConnection().getSCN(); long timestamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn; ConnectionQueryServices services = statement.getConnection().getQueryServices(); services.incrementSequences(nextSequences, timestamp, srcSequenceValues, sqlExceptions); setSequenceValues(srcSequenceValues, dstSequenceValues, sqlExceptions); int offset = nextSequences.size(); for (int i = 0; i < currentSequences.size(); i++) { dstSequenceValues[sequencePosition[offset+i]] = services.currentSequenceValue(currentSequences.get(i), timestamp); } }
public QueryPlan optimize(PhoenixStatement statement, SelectStatement select) throws SQLException { return optimize(statement, select, FromCompiler.getResolverForQuery(select, statement.getConnection()), Collections.<PColumn>emptyList(), null); }
@Override public MutationState execute() throws SQLException { MutationState state = firstPlan.execute(); statement.getConnection().getMutationState().join(state); for (MutationPlan plan : plans.subList(1, plans.size())) { statement.getConnection().getMutationState().join(plan.execute()); } return state; }
public void addFilter(ParseNode filter) throws SQLException { if (joinSpecs.isEmpty()) { table.addFilter(filter); return; } WhereNodeVisitor visitor = new WhereNodeVisitor(origResolver, table, postFilters, Collections.<TableRef>singletonList(table.getTableRef()), isPrefilterAccepted, prefilterAcceptedTables, statement.getConnection()); filter.accept(visitor); }
public MutationPlan compile(final DropSequenceStatement sequence) throws SQLException { final PhoenixConnection connection = statement.getConnection(); final MetaDataClient client = new MetaDataClient(connection); final StatementContext context = new StatementContext(statement); return new BaseMutationPlan(context, operation) { @Override public MutationState execute() throws SQLException { return client.dropSequence(sequence); } @Override public ExplainPlan getExplainPlan() throws SQLException { return new ExplainPlan(Collections.singletonList("DROP SEQUENCE")); } }; } }
public MutationPlan compile(final CloseStatement close) throws SQLException { final PhoenixConnection connection = statement.getConnection(); final StatementContext context = new StatementContext(statement); final MetaDataClient client = new MetaDataClient(connection); return new BaseMutationPlan(context, operation) { @Override public MutationState execute() throws SQLException { return client.close(close); } @Override public ExplainPlan getExplainPlan() throws SQLException { return new ExplainPlan(Collections.singletonList("CLOSE CURSOR")); } }; } }
public MutationPlan compile(final OpenStatement open) throws SQLException { final PhoenixConnection connection = statement.getConnection(); final StatementContext context = new StatementContext(statement); final MetaDataClient client = new MetaDataClient(connection); return new BaseMutationPlan(context, operation) { @Override public MutationState execute() throws SQLException { return client.open(open); } @Override public ExplainPlan getExplainPlan() throws SQLException { return new ExplainPlan(Collections.singletonList("OPEN CURSOR")); } }; } }
public MutationPlan compile(final DeclareCursorStatement declare) throws SQLException { if(declare.getBindCount() != 0){ throw new SQLException("Cannot declare cursor, internal SELECT statement contains bindings!"); } final PhoenixConnection connection = statement.getConnection(); final StatementContext context = new StatementContext(statement); final MetaDataClient client = new MetaDataClient(connection); return new BaseMutationPlan(context, operation) { @Override public MutationState execute() throws SQLException { return client.declareCursor(declare, queryPlan); } @Override public ExplainPlan getExplainPlan() throws SQLException { return new ExplainPlan(Collections.singletonList("DECLARE CURSOR")); } }; } }
@Override public MutationState execute() throws SQLException { PhoenixConnection phxConn = stmt.getConnection(); Properties props = new Properties(); phxConn.getQueryServices().upgradeSystemTables(phxConn.getURL(), props); return MutationState.emptyMutationState(-1, -1, phxConn); }
@SuppressWarnings("unchecked") @Override public QueryPlan compilePlan(PhoenixStatement stmt, Sequence.ValueOp seqAction) throws SQLException { if(!getUdfParseNodes().isEmpty()) { stmt.throwIfUnallowedUserDefinedFunctions(getUdfParseNodes()); } SelectStatement select = SubselectRewriter.flatten(this, stmt.getConnection()); ColumnResolver resolver = FromCompiler.getResolverForQuery(select, stmt.getConnection()); select = StatementNormalizer.normalize(select, resolver); SelectStatement transformedSelect = SubqueryRewriter.transform(select, resolver, stmt.getConnection()); if (transformedSelect != select) { resolver = FromCompiler.getResolverForQuery(transformedSelect, stmt.getConnection()); select = StatementNormalizer.normalize(transformedSelect, resolver); } QueryPlan plan = new QueryCompiler(stmt, select, resolver, Collections.<PDatum>emptyList(), stmt.getConnection().getIteratorFactory(), new SequenceManager(stmt), true, false, null).compile(); plan.getContext().getSequenceManager().validateSequences(seqAction); return plan; }
public PTable createProjectedTable(RowProjector rowProjector) throws SQLException { assert(isSubselect()); TableRef tableRef = FromCompiler.getResolverForCompiledDerivedTable(statement.getConnection(), this.tableRef, rowProjector).getTables().get(0); List<ColumnRef> sourceColumns = new ArrayList<ColumnRef>(); PTable table = tableRef.getTable(); for (PColumn column : table.getColumns()) { sourceColumns.add(new ColumnRef(tableRef, column.getPosition())); } return TupleProjectionCompiler.createProjectedTable(tableRef, sourceColumns, false); } }
@Override public MutationState execute() throws SQLException { // We have a point lookup, so we know we have a simple set of fully qualified // keys for our ranges ScanRanges ranges = context.getScanRanges(); Iterator<KeyRange> iterator = ranges.getPointLookupKeyIterator(); MultiRowMutationState mutation = new MultiRowMutationState(ranges.getPointLookupCount()); while (iterator.hasNext()) { mutation.put(new ImmutableBytesPtr(iterator.next().getLowerRange()), new RowMutationState(PRow.DELETE_MARKER, 0, statement.getConnection().getStatementExecutionCounter(), NULL_ROWTIMESTAMP_INFO, null)); } return new MutationState(dataPlan.getTableRef(), mutation, 0, maxSize, maxSizeBytes, connection); }
private boolean isWildCardSelectForTable(List<AliasedNode> select, TableRef tableRef, ColumnResolver resolver) throws SQLException { ColumnRefParseNodeVisitor visitor = new ColumnRefParseNodeVisitor(resolver, statement.getConnection()); for (AliasedNode aliasedNode : select) { ParseNode node = aliasedNode.getNode(); if (node instanceof TableWildcardParseNode) { TableName tableName = ((TableWildcardParseNode) node).getTableName(); if (tableRef.equals(resolver.resolveTable(tableName.getSchemaName(), tableName.getTableName()))) { return true; } } } return false; }
protected QueryPlan compileSubquery(SelectStatement subquery, boolean pushDownMaxRows) throws SQLException { PhoenixConnection connection = this.statement.getConnection(); subquery = SubselectRewriter.flatten(subquery, connection); ColumnResolver resolver = FromCompiler.getResolverForQuery(subquery, connection); subquery = StatementNormalizer.normalize(subquery, resolver); SelectStatement transformedSubquery = SubqueryRewriter.transform(subquery, resolver, connection); if (transformedSubquery != subquery) { resolver = FromCompiler.getResolverForQuery(transformedSubquery, connection); subquery = StatementNormalizer.normalize(transformedSubquery, resolver); } int maxRows = this.statement.getMaxRows(); this.statement.setMaxRows(pushDownMaxRows ? maxRows : 0); // overwrite maxRows to avoid its impact on inner queries. QueryPlan plan = new QueryCompiler(this.statement, subquery, resolver, false, optimizeSubquery, null).compile(); if (optimizeSubquery) { plan = statement.getConnection().getQueryServices().getOptimizer().optimize(statement, plan); } this.statement.setMaxRows(maxRows); // restore maxRows. return plan; }
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); }