private void transitionToFinished() { cleanupQueryQuietly(); queryStateTimer.endQuery(); queryState.setIf(FINISHED, currentState -> !currentState.isDone()); }
public boolean transitionToPlanning() { queryStateTimer.beginPlanning(); return queryState.setIf(PLANNING, currentState -> currentState.ordinal() < PLANNING.ordinal()); }
private static boolean isDone(TaskInfo taskInfo) { return taskInfo.getTaskStatus().getState().isDone(); } }
@Override public void addFinalTaskInfoListener(StateChangeListener<TaskInfo> stateChangeListener) { AtomicBoolean done = new AtomicBoolean(); StateChangeListener<TaskState> fireOnceStateChangeListener = state -> { if (state.isDone() && done.compareAndSet(false, true)) { stateChangeListener.stateChanged(getTaskInfo()); } }; taskStateMachine.addStateChangeListener(fireOnceStateChangeListener); fireOnceStateChangeListener.stateChanged(taskStateMachine.getState()); }
@Override public DateTime getLastHeartbeat() { return getQueryInfo().getQueryStats().getLastHeartbeat(); }
@Override public DateTime getCreateTime() { return getQueryInfo().getQueryStats().getCreateTime(); }
@Override public void start() { taskStateMachine.addStateChangeListener(newValue -> { if (newValue.isDone()) { clearSplits(); } }); }
@Override public synchronized int getQueuedPartitionedSplitCount() { if (taskStateMachine.getState().isDone()) { return 0; } return getPartitionedSplitCount() - runningDrivers; } }
@Override public void addStateChangeListener(StateChangeListener<TaskStatus> stateChangeListener) { taskStateMachine.addStateChangeListener(newValue -> stateChangeListener.stateChanged(getTaskStatus())); }
public boolean transitionToRunning() { queryStateTimer.beginRunning(); return queryState.setIf(RUNNING, currentState -> currentState.ordinal() < RUNNING.ordinal()); }
public boolean transitionToWaitingForResources() { queryStateTimer.beginWaitingForResources(); return queryState.setIf(WAITING_FOR_RESOURCES, currentState -> currentState.ordinal() < WAITING_FOR_RESOURCES.ordinal()); }
public boolean transitionToStarting() { queryStateTimer.beginStarting(); return queryState.setIf(STARTING, currentState -> currentState.ordinal() < STARTING.ordinal()); }
@Override public ListenableFuture<?> execute(CreateTable statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { return internalExecute(statement, metadata, accessControl, stateMachine.getSession(), parameters); }
public void setNoNewLookups() { if (!grouped) { get(Lifespan.taskWide()).setNoNewLookups(); } }
@Override public DataDefinitionExecution<?> createQueryExecution( String query, Session session, PreparedQuery preparedQuery, ResourceGroupId resourceGroup, WarningCollector warningCollector) { return createDataDefinitionExecution(query, session, resourceGroup, preparedQuery.getStatement(), preparedQuery.getParameters(), warningCollector); }
public void setNoNewLookups(Lifespan lifespan) { // If it's grouped execution, knowing no new probe operators will be created for a group // should be immediately propagated to build state, so that corresponding build // can move forward (e.g. clean up). // On the other hand, if there's a single build, knowing no new probe operators will be // created for a group has no immediate use. if (grouped) { get(lifespan).setNoNewLookups(); } }