public void beginAnalysis() { queryStateTimer.beginAnalyzing(); }
public void beginDistributedPlanning() { queryStateTimer.beginDistributedPlanning(); }
public void beginFinishing() { beginFinishing(tickerNanos()); }
public void beginWaitingForResources() { beginWaitingForResources(tickerNanos()); }
public void beginPlanning() { beginPlanning(tickerNanos()); }
public void beginRunning() { beginRunning(tickerNanos()); }
public void beginStarting() { beginStarting(tickerNanos()); }
private void beginStarting(long now) { beginPlanning(now); planningTime.compareAndSet(null, nanosSince(beginPlanningNanos, now)); }
private void beginPlanning(long now) { beginWaitingForResources(now); resourceWaitingTime.compareAndSet(null, nanosSince(beginResourceWaitingNanos, now)); beginPlanningNanos.compareAndSet(null, now); }
private void endQuery(long now) { beginFinishing(now); finishingTime.compareAndSet(null, nanosSince(beginFinishingNanos, now)); executionTime.compareAndSet(null, nanosSince(beginPlanningNanos, now)); endNanos.compareAndSet(null, now); }
private void beginFinishing(long now) { beginRunning(now); beginFinishingNanos.compareAndSet(null, now); }
private void beginRunning(long now) { beginStarting(now); }
public void endAnalysis() { queryStateTimer.endAnalysis(); }
public void endDistributedPlanning() { queryStateTimer.endDistributedPlanning(); }
private QueryStateMachine( String query, Session session, URI self, Optional<ResourceGroupId> resourceGroup, TransactionManager transactionManager, Executor executor, Ticker ticker, Metadata metadata, WarningCollector warningCollector) { this.query = requireNonNull(query, "query is null"); this.session = requireNonNull(session, "session is null"); this.queryId = session.getQueryId(); this.self = requireNonNull(self, "self is null"); this.resourceGroup = requireNonNull(resourceGroup, "resourceGroup is null"); this.transactionManager = requireNonNull(transactionManager, "transactionManager is null"); this.queryStateTimer = new QueryStateTimer(ticker); this.metadata = requireNonNull(metadata, "metadata is null"); this.queryState = new StateMachine<>("query " + query, executor, QUEUED, TERMINAL_QUERY_STATES); this.finalQueryInfo = new StateMachine<>("finalQueryInfo-" + queryId, executor, Optional.empty()); this.outputManager = new QueryOutputManager(executor); this.warningCollector = requireNonNull(warningCollector, "warningCollector is null"); }
public boolean transitionToPlanning() { queryStateTimer.beginPlanning(); return queryState.setIf(PLANNING, currentState -> currentState.ordinal() < PLANNING.ordinal()); }
public boolean transitionToWaitingForResources() { queryStateTimer.beginWaitingForResources(); return queryState.setIf(WAITING_FOR_RESOURCES, currentState -> currentState.ordinal() < WAITING_FOR_RESOURCES.ordinal()); }
public boolean transitionToFinishing() { queryStateTimer.beginFinishing(); if (!queryState.setIf(FINISHING, currentState -> currentState != FINISHING && !currentState.isDone())) { return false; } Optional<TransactionId> transactionId = session.getTransactionId(); if (transactionId.isPresent() && transactionManager.transactionExists(transactionId.get()) && transactionManager.isAutoCommit(transactionId.get())) { ListenableFuture<?> commitFuture = transactionManager.asyncCommit(transactionId.get()); Futures.addCallback(commitFuture, new FutureCallback<Object>() { @Override public void onSuccess(@Nullable Object result) { transitionToFinished(); } @Override public void onFailure(Throwable throwable) { transitionToFailed(throwable); } }, directExecutor()); } else { transitionToFinished(); } return true; }
public boolean transitionToRunning() { queryStateTimer.beginRunning(); return queryState.setIf(RUNNING, currentState -> currentState.ordinal() < RUNNING.ordinal()); }
public boolean transitionToStarting() { queryStateTimer.beginStarting(); return queryState.setIf(STARTING, currentState -> currentState.ordinal() < STARTING.ordinal()); }