Tabnine Logo
BasicQueryInfo.getState
Code IndexAdd Tabnine to your IDE (free)

How to use
getState
method
in
io.prestosql.server.BasicQueryInfo

Best Java code snippets using io.prestosql.server.BasicQueryInfo.getState (Showing top 20 results out of 315)

origin: prestosql/presto

@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();
}
origin: io.prestosql/presto-main

@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();
}
origin: io.prestosql/presto-main

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);
}
origin: prestosql/presto

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);
}
origin: io.prestosql/presto-main

@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());
}
origin: prestosql/presto

@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());
}
origin: io.prestosql/presto-main

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);
}
origin: prestosql/presto

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);
}
origin: prestosql/presto

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;
}
origin: io.prestosql/presto-main

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;
}
origin: prestosql/presto

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);
  }
}
origin: prestosql/presto

private void cancelAllQueries()
{
  QueryManager queryManager = coordinator.getQueryManager();
  for (BasicQueryInfo queryInfo : queryManager.getQueries()) {
    if (!queryInfo.getState().isDone()) {
      queryManager.cancelQuery(queryInfo.getQueryId());
    }
  }
}
origin: io.prestosql/presto-main

  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);
  }
}
origin: prestosql/presto

  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);
  }
}
origin: prestosql/presto

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());
    }
  }
}
origin: prestosql/presto

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)));
}
origin: prestosql/presto

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);
  }
}
origin: prestosql/presto

  @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());
    }
  }
}
origin: prestosql/presto

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);
}
origin: io.prestosql/presto-main

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);
}
io.prestosql.serverBasicQueryInfogetState

Popular methods of BasicQueryInfo

  • getQueryId
  • <init>
  • getErrorCode
  • getQueryStats
  • getMemoryPool
  • getQuery
  • getSession
  • getErrorType
  • getResourceGroupId
  • getSelf
  • isScheduled
  • isScheduled

Popular in Java

  • Making http requests using okhttp
  • getExternalFilesDir (Context)
  • getSystemService (Context)
  • requestLocationUpdates (LocationManager)
  • RandomAccessFile (java.io)
    Allows reading from and writing to a file in a random-access manner. This is different from the uni-
  • Charset (java.nio.charset)
    A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
  • Comparator (java.util)
    A Comparator is used to compare two objects to determine their ordering with respect to each other.
  • List (java.util)
    An ordered collection (also known as a sequence). The user of this interface has precise control ove
  • JFileChooser (javax.swing)
  • StringUtils (org.apache.commons.lang)
    Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
  • Top 12 Jupyter Notebook extensions
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now