How to use

getState

method

in

io.prestosql.server.BasicQueryInfo

@GET
public List<BasicQueryInfo> getAllQueryInfo(@QueryParam("state") String stateFilter)
{
  QueryState expectedState = stateFilter == null ? null : QueryState.valueOf(stateFilter.toUpperCase(Locale.ENGLISH));
  ImmutableList.Builder<BasicQueryInfo> builder = new ImmutableList.Builder<>();
  for (BasicQueryInfo queryInfo : queryManager.getQueries()) {
    if (stateFilter == null || queryInfo.getState() == expectedState) {
      builder.add(queryInfo);
    }
  }
  return builder.build();
}

@GET
public List<BasicQueryInfo> getAllQueryInfo(@QueryParam("state") String stateFilter)
{
  QueryState expectedState = stateFilter == null ? null : QueryState.valueOf(stateFilter.toUpperCase(Locale.ENGLISH));
  ImmutableList.Builder<BasicQueryInfo> builder = new ImmutableList.Builder<>();
  for (BasicQueryInfo queryInfo : queryManager.getQueries()) {
    if (stateFilter == null || queryInfo.getState() == expectedState) {
      builder.add(queryInfo);
    }
  }
  return builder.build();
}

public static QueryStateInfo createQueryStateInfo(BasicQueryInfo queryInfo, Optional<ResourceGroupId> group)
{
  Optional<QueryProgressStats> progress = Optional.empty();
  if (!queryInfo.getState().isDone() && queryInfo.getState() != QUEUED) {
    progress = Optional.of(createQueryProgressStats(queryInfo.getQueryStats()));
  }
  return createQueryStateInfo(queryInfo, group, Optional.empty(), progress);
}

public static QueryStateInfo createQueryStateInfo(BasicQueryInfo queryInfo, Optional<ResourceGroupId> group)
{
  Optional<QueryProgressStats> progress = Optional.empty();
  if (!queryInfo.getState().isDone() && queryInfo.getState() != QUEUED) {
    progress = Optional.of(createQueryProgressStats(queryInfo.getQueryStats()));
  }
  return createQueryStateInfo(queryInfo, group, Optional.empty(), progress);
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public List<QueryStateInfo> getQueryStateInfos(@QueryParam("user") String user)
{
  List<BasicQueryInfo> queryInfos = queryManager.getQueries();
  if (!isNullOrEmpty(user)) {
    queryInfos = queryInfos.stream()
        .filter(queryInfo -> Pattern.matches(user, queryInfo.getSession().getUser()))
        .collect(toImmutableList());
  }
  return queryInfos.stream()
      .filter(queryInfo -> !queryInfo.getState().isDone())
      .map(this::getQueryStateInfo)
      .collect(toImmutableList());
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public List<QueryStateInfo> getQueryStateInfos(@QueryParam("user") String user)
{
  List<BasicQueryInfo> queryInfos = queryManager.getQueries();
  if (!isNullOrEmpty(user)) {
    queryInfos = queryInfos.stream()
        .filter(queryInfo -> Pattern.matches(user, queryInfo.getSession().getUser()))
        .collect(toImmutableList());
  }
  return queryInfos.stream()
      .filter(queryInfo -> !queryInfo.getState().isDone())
      .map(this::getQueryStateInfo)
      .collect(toImmutableList());
}

private QueryStateInfo getQueryStateInfo(BasicQueryInfo queryInfo)
{
  Optional<ResourceGroupId> groupId = queryInfo.getResourceGroupId();
  if (queryInfo.getState() == QUEUED) {
    return createQueuedQueryStateInfo(
        queryInfo,
        groupId,
        groupId.map(resourceGroupManager::getPathToRoot));
  }
  return createQueryStateInfo(queryInfo, groupId);
}

private QueryStateInfo getQueryStateInfo(BasicQueryInfo queryInfo)
{
  Optional<ResourceGroupId> groupId = queryInfo.getResourceGroupId();
  if (queryInfo.getState() == QUEUED) {
    return createQueuedQueryStateInfo(
        queryInfo,
        groupId,
        groupId.map(resourceGroupManager::getPathToRoot));
  }
  return createQueryStateInfo(queryInfo, groupId);
}

private static boolean isLeaked(Map<QueryId, BasicQueryInfo> queryIdToInfo, QueryId queryId)
{
  BasicQueryInfo queryInfo = queryIdToInfo.get(queryId);
  if (queryInfo == null) {
    return true;
  }
  DateTime queryEndTime = queryInfo.getQueryStats().getEndTime();
  if (queryInfo.getState() == RUNNING || queryEndTime == null) {
    return false;
  }
  return secondsBetween(queryEndTime, now()).getSeconds() >= DEFAULT_LEAK_CLAIM_DELTA_SEC;
}

private static boolean isLeaked(Map<QueryId, BasicQueryInfo> queryIdToInfo, QueryId queryId)
{
  BasicQueryInfo queryInfo = queryIdToInfo.get(queryId);
  if (queryInfo == null) {
    return true;
  }
  DateTime queryEndTime = queryInfo.getQueryStats().getEndTime();
  if (queryInfo.getState() == RUNNING || queryEndTime == null) {
    return false;
  }
  return secondsBetween(queryEndTime, now()).getSeconds() >= DEFAULT_LEAK_CLAIM_DELTA_SEC;
}

public static void waitForQueryCount(DistributedQueryRunner queryRunner, Set<QueryState> countingStates, int expectedCount)
    throws InterruptedException
{
  QueryManager queryManager = queryRunner.getCoordinator().getQueryManager();
  while (queryManager.getQueries().stream()
      .filter(q -> countingStates.contains(q.getState())).count() != expectedCount) {
    MILLISECONDS.sleep(500);
  }
}

private void cancelAllQueries()
{
  QueryManager queryManager = coordinator.getQueryManager();
  for (BasicQueryInfo queryInfo : queryManager.getQueries()) {
    if (!queryInfo.getState().isDone()) {
      queryManager.cancelQuery(queryInfo.getQueryId());
    }
  }
}

  private void assertStateCounts(List<BasicQueryInfo> infos, int expectedFinished, int expectedFailed, int expectedRunning)
  {
    int failed = 0;
    int finished = 0;
    int running = 0;
    for (BasicQueryInfo info : infos) {
      switch (info.getState()) {
        case FINISHED:
          finished++;
          break;
        case FAILED:
          failed++;
          break;
        case RUNNING:
          running++;
          break;
        default:
          fail("Unexpected query state " + info.getState());
      }
    }
    assertEquals(failed, expectedFailed);
    assertEquals(finished, expectedFinished);
    assertEquals(running, expectedRunning);
  }
}

  private void assertStateCounts(List<BasicQueryInfo> infos, int expectedFinished, int expectedFailed, int expectedRunning)
  {
    int failed = 0;
    int finished = 0;
    int running = 0;
    for (BasicQueryInfo info : infos) {
      switch (info.getState()) {
        case FINISHED:
          finished++;
          break;
        case FAILED:
          failed++;
          break;
        case RUNNING:
          running++;
          break;
        default:
          fail("Unexpected query state " + info.getState());
      }
    }
    assertEquals(failed, expectedFailed);
    assertEquals(finished, expectedFinished);
    assertEquals(running, expectedRunning);
  }
}

private void testNoLeak(@Language("SQL") String query)
    throws Exception
{
  Map<String, String> properties = ImmutableMap.<String, String>builder()
      .put("task.verbose-stats", "true")
      .build();
  try (DistributedQueryRunner queryRunner = createQueryRunner(TINY_SESSION, properties)) {
    executor.submit(() -> queryRunner.execute(query)).get();
    for (BasicQueryInfo info : queryRunner.getCoordinator().getQueryManager().getQueries()) {
      assertEquals(info.getState(), FINISHED);
    }
    // Make sure we didn't leak any memory on the workers
    for (TestingPrestoServer worker : queryRunner.getServers()) {
      Optional<MemoryPool> reserved = worker.getLocalMemoryManager().getReservedPool();
      assertTrue(reserved.isPresent());
      assertEquals(reserved.get().getMaxBytes(), reserved.get().getFreeBytes());
      MemoryPool general = worker.getLocalMemoryManager().getGeneralPool();
      assertEquals(general.getMaxBytes(), general.getFreeBytes());
    }
  }
}

public static void waitForQueryState(DistributedQueryRunner queryRunner, QueryId queryId, Set<QueryState> expectedQueryStates)
    throws InterruptedException
{
  QueryManager queryManager = queryRunner.getCoordinator().getQueryManager();
  do {
    // Heartbeat all the running queries, so they don't die while we're waiting
    for (BasicQueryInfo queryInfo : queryManager.getQueries()) {
      if (queryInfo.getState() == RUNNING) {
        queryManager.recordHeartbeat(queryInfo.getQueryId());
      }
    }
    MILLISECONDS.sleep(500);
  }
  while (!expectedQueryStates.contains(queryManager.getQueryState(queryId)));
}

private void waitForQueryToBeKilled(DistributedQueryRunner queryRunner)
    throws InterruptedException
{
  while (true) {
    for (BasicQueryInfo info : queryRunner.getCoordinator().getQueryManager().getQueries()) {
      if (info.getState().isDone()) {
        assertNotNull(info.getErrorCode());
        assertEquals(info.getErrorCode().getCode(), CLUSTER_OUT_OF_MEMORY.toErrorCode().getCode());
        return;
      }
    }
    MILLISECONDS.sleep(10);
  }
}

  @Test(timeOut = 60_000L)
  public void testQueryCpuLimit()
      throws Exception
  {
    try (DistributedQueryRunner queryRunner = builder().setSingleExtraProperty("query.max-cpu-time", "1ms").build()) {
      QueryId queryId = createQuery(queryRunner, TEST_SESSION, "SELECT COUNT(*) FROM lineitem");
      waitForQueryState(queryRunner, queryId, FAILED);
      QueryManager queryManager = queryRunner.getCoordinator().getQueryManager();
      BasicQueryInfo queryInfo = queryManager.getQueryInfo(queryId);
      assertEquals(queryInfo.getState(), FAILED);
      assertEquals(queryInfo.getErrorCode(), EXCEEDED_CPU_LIMIT.toErrorCode());
    }
  }
}

private static QueryStateInfo createQueryStateInfo(
    BasicQueryInfo queryInfo,
    Optional<ResourceGroupId> groupId,
    Optional<List<ResourceGroupInfo>> pathToRoot,
    Optional<QueryProgressStats> progress)
{
  return new QueryStateInfo(
      queryInfo.getQueryId(),
      queryInfo.getState(),
      groupId,
      queryInfo.getQuery(),
      queryInfo.getQueryStats().getCreateTime(),
      queryInfo.getSession().getUser(),
      queryInfo.getSession().getSource(),
      queryInfo.getSession().getClientInfo(),
      queryInfo.getSession().getCatalog(),
      queryInfo.getSession().getSchema(),
      pathToRoot,
      progress);
}

private static QueryStateInfo createQueryStateInfo(
    BasicQueryInfo queryInfo,
    Optional<ResourceGroupId> groupId,
    Optional<List<ResourceGroupInfo>> pathToRoot,
    Optional<QueryProgressStats> progress)
{
  return new QueryStateInfo(
      queryInfo.getQueryId(),
      queryInfo.getState(),
      groupId,
      queryInfo.getQuery(),
      queryInfo.getQueryStats().getCreateTime(),
      queryInfo.getSession().getUser(),
      queryInfo.getSession().getSource(),
      queryInfo.getSession().getClientInfo(),
      queryInfo.getSession().getCatalog(),
      queryInfo.getSession().getSchema(),
      pathToRoot,
      progress);
}