@Test public void testCreateTableNotExistsFalse() { CreateTable statement = new CreateTable(QualifiedName.of("test_table"), ImmutableList.of(new ColumnDefinition(identifier("a"), "BIGINT", emptyList(), Optional.empty())), false, ImmutableList.of(), Optional.empty()); try { getFutureValue(new CreateTableTask().internalExecute(statement, metadata, new AllowAllAccessControl(), testSession, emptyList())); fail("expected exception"); } catch (RuntimeException e) { // Expected assertTrue(e instanceof PrestoException); PrestoException prestoException = (PrestoException) e; assertEquals(prestoException.getErrorCode(), ALREADY_EXISTS.toErrorCode()); } assertEquals(metadata.getCreateTableCallCount(), 1); }
@Override public boolean needsInput() { if (finishing || probePage != null) { return false; } if (buildPages == null) { Optional<NestedLoopJoinPages> nestedLoopJoinPages = tryGetFutureValue(nestedLoopJoinPagesFuture); if (nestedLoopJoinPages.isPresent()) { buildPages = nestedLoopJoinPages.get().getPages(); } } return buildPages != null; }
ListenableFuture<PrestoThriftSplitBatch> splitsFuture = client.getSplits( schemaTableName, new PrestoThriftNullableColumnSet(columnNames.orElse(null)), constraint, maxSize, List<ConnectorSplit> splits = batch.getSplits().stream() .map(ThriftSplitSource::toConnectorSplit) .collect(toImmutableList()); checkState(nextToken.compareAndSet(currentToken, batch.getNextToken())); checkState(hasMoreData.compareAndSet(true, nextToken.get() != null)); resultFuture = catchingThriftException(resultFuture); future.set(resultFuture); return toCompletableFuture(resultFuture);
private void updateSignalAndStatusFutures() { dataSignalFuture = whenAnyComplete(dataRequests); statusFuture = toCompletableFuture(nonCancellationPropagating(dataSignalFuture)); }
@Override public Page getNextPage() { if (isFinished()) { return null; } if (currentPage != null) { Page page = getFutureValue(currentPage); currentPage = null; return page; } pagesLeft--; completedBytes += page.getSizeInBytes(); if (pageProcessingDelayInMillis == 0) { return page; } else { currentPage = toCompletableFuture(executorService.schedule(() -> page, pageProcessingDelayInMillis, MILLISECONDS)); return null; } }
@Test public void testNonTransactionalClient() { Session session = sessionBuilder().build(); TransactionManager transactionManager = createTestTransactionManager(); QueryStateMachine stateMachine = createQueryStateMachine("START TRANSACTION", session, transactionManager); assertFalse(stateMachine.getSession().getTransactionId().isPresent()); try { getFutureValue(new StartTransactionTask().execute(new StartTransaction(ImmutableList.of()), transactionManager, metadata, new AllowAllAccessControl(), stateMachine, emptyList())); fail(); } catch (PrestoException e) { assertEquals(e.getErrorCode(), INCOMPATIBLE_CLIENT.toErrorCode()); } assertTrue(transactionManager.getAllTransactionInfos().isEmpty()); assertFalse(stateMachine.getQueryInfo(Optional.empty()).isClearTransactionId()); assertFalse(stateMachine.getQueryInfo(Optional.empty()).getStartedTransactionId().isPresent()); }
@Test(timeOut = 10000) public void testAddLocation() throws Exception pageBufferClientCallbackExecutor); URI location1 = URI.create("http://localhost:8081/foo"); processor.addPage(location1, createPage(1)); processor.addPage(location1, createPage(2)); exchangeClient.addLocation(location1); assertFalse(tryGetFutureValue(exchangeClient.isBlocked(), 10, MILLISECONDS).isPresent()); assertEquals(exchangeClient.isClosed(), false); URI location2 = URI.create("http://localhost:8082/bar"); processor.addPage(location2, createPage(4)); processor.addPage(location2, createPage(5)); assertPageEquals(getNextPage(exchangeClient), createPage(6)); assertFalse(tryGetFutureValue(exchangeClient.isBlocked(), 10, MILLISECONDS).isPresent()); assertEquals(exchangeClient.isClosed(), false);
ConnectorOutputTableHandle outputHandle = metadata.beginCreateTable(session, tableMetadata, Optional.empty()); Collection<Slice> fragments = getFutureValue(sink.finish()); assertTrue(new Path(filePath).getName().startsWith(getFilePrefix(outputHandle))); metadata.finishCreateTable(session, outputHandle, fragments, ImmutableList.of()); assertEquals(filterNonHiddenColumnMetadata(tableMetadata.getColumns()), CREATE_TABLE_COLUMNS); MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.of(storageFormat)); assertEqualsIgnoreOrder(result.getMaterializedRows(), CREATE_TABLE_DATA.getMaterializedRows()); Table table = getMetastoreClient().getTable(tableName.getSchemaName(), tableName.getTableName()).get(); assertEquals(table.getParameters().get(PRESTO_VERSION_NAME), TEST_SERVER_VERSION); assertEquals(table.getParameters().get(PRESTO_QUERY_ID_NAME), queryId);
@Test public void testTimeout() throws Exception { CompletableFuture<String> rootFuture = new CompletableFuture<>(); CompletableFuture<String> timeoutFuture = addTimeout(rootFuture, () -> "timeout", new Duration(0, MILLISECONDS), executorService); assertEquals(tryGetFutureValue(timeoutFuture, 10, SECONDS).orElse("failed"), "timeout"); assertTrue(timeoutFuture.isDone()); assertFalse(timeoutFuture.isCancelled()); // root exception is cancelled on a timeout assertFailure(() -> rootFuture.get(10, SECONDS), e -> assertInstanceOf(e, CancellationException.class)); assertTrue(rootFuture.isDone()); assertTrue(rootFuture.isCancelled()); }
public synchronized ListenableFuture<QueryResults> waitForResults(OptionalLong token, UriInfo uriInfo, String scheme, Duration wait, DataSize targetResultSize) { // before waiting, check if this request has already been processed and cached if (token.isPresent()) { Optional<QueryResults> cachedResult = getCachedResult(token.getAsLong(), uriInfo); if (cachedResult.isPresent()) { return immediateFuture(cachedResult.get()); } } // wait for a results data or query to finish, up to the wait timeout ListenableFuture<?> futureStateChange = addTimeout( getFutureStateChange(), () -> null, wait, timeoutExecutor); // when state changes, fetch the next result return Futures.transform(futureStateChange, ignored -> getNextResult(token, uriInfo, scheme, targetResultSize), resultsProcessorExecutor); }
@Test public void testToFromListenableFuture() throws Exception { assertGetUnchecked(future -> getFutureValue(toCompletableFuture(toListenableFuture(future)))); SettableFuture<?> settableFuture = SettableFuture.create(); toCompletableFuture(settableFuture).cancel(true); assertTrue(settableFuture.isCancelled()); CompletableFuture<Object> completableFuture = new CompletableFuture<>(); toListenableFuture(completableFuture).cancel(true); assertTrue(completableFuture.isCancelled()); assertEquals(tryGetFutureValue(toCompletableFuture(SettableFuture.create()), 10, MILLISECONDS), Optional.empty()); assertEquals(tryGetFutureValue(toListenableFuture(new CompletableFuture<>()), 10, MILLISECONDS), Optional.empty()); }
@Test public void test() "reset foo", session, URI.create("fake://uri"), new ResourceGroupId("test"), false, WarningCollector.NOOP); getFutureValue(new ResetSessionTask().execute( new ResetSession(QualifiedName.of(CATALOG_NAME, "baz")), transactionManager, assertEquals(sessionProperties, ImmutableSet.of("catalog.baz"));
@Test public void testCreateTableNotExistsTrue() { CreateTable statement = new CreateTable(QualifiedName.of("test_table"), ImmutableList.of(new ColumnDefinition(identifier("a"), "BIGINT", emptyList(), Optional.empty())), true, ImmutableList.of(), Optional.empty()); getFutureValue(new CreateTableTask().internalExecute(statement, metadata, new AllowAllAccessControl(), testSession, emptyList())); assertEquals(metadata.getCreateTableCallCount(), 1); }
@Test public void testBorrow() throws Exception getFutureValue(queue.borrowBatchAsync(3, elements -> new BorrowResult<>(elements, null))); assertFalse(queue.isFinished()); assertFalse(queue.isFinished() || done.get()); done.set(true); assertFalse(queue.isFinished()); ArrayList<Integer> list = new ArrayList<>(queue.getBatchAsync(100).get()); list.sort(Integer::compare); assertEquals(list, ImmutableList.of(1, 2, 3, 4, 5)); assertTrue(queue.isFinished());
@Test public void testTimeout() throws Exception { CompletableFuture<String> rootFuture = new CompletableFuture<>(); CompletableFuture<String> timeoutFuture = addTimeout(rootFuture, () -> "timeout", new Duration(0, MILLISECONDS), executorService); assertEquals(tryGetFutureValue(timeoutFuture, 10, SECONDS).get(), "timeout"); assertTrue(timeoutFuture.isDone()); assertFalse(timeoutFuture.isCancelled()); // root exception is cancelled on a timeout assertFailure(() -> rootFuture.get(10, SECONDS), e -> assertInstanceOf(e, CancellationException.class)); assertTrue(rootFuture.isDone()); assertTrue(rootFuture.isCancelled()); }
private void testSetSessionWithParameters(String property, Expression expression, String expectedValue, List<Expression> parameters) { QualifiedName qualifiedPropName = QualifiedName.of(CATALOG_NAME, property); QueryStateMachine stateMachine = QueryStateMachine.begin( format("set %s = 'old_value'", qualifiedPropName), TEST_SESSION, URI.create("fake://uri"), new ResourceGroupId("test"), false, transactionManager, accessControl, executor, metadata, WarningCollector.NOOP); getFutureValue(new SetSessionTask().execute(new SetSession(qualifiedPropName, expression), transactionManager, metadata, accessControl, stateMachine, parameters)); Map<String, String> sessionProperties = stateMachine.getSetSessionProperties(); assertEquals(sessionProperties, ImmutableMap.of(qualifiedPropName.toString(), expectedValue)); } }
@Override public boolean needsInput() { if (finishing || outputPage != null) { return false; } if (channelSet == null) { channelSet = tryGetFutureValue(channelSetFuture).orElse(null); } return channelSet != null; }
@Test public void testTimeoutCancel() throws Exception { CompletableFuture<String> rootFuture = new CompletableFuture<>(); CompletableFuture<String> timeoutFuture = addTimeout(rootFuture, () -> "timeout", new Duration(10, SECONDS), executorService); // check timeout assertEquals(tryGetFutureValue(timeoutFuture, 10, MILLISECONDS), Optional.<String>empty()); assertTrue(timeoutFuture.cancel(true)); assertTrue(timeoutFuture.isDone()); assertTrue(timeoutFuture.isCancelled()); // root exception is cancelled on a timeout assertTrue(rootFuture.isDone()); assertTrue(rootFuture.isCancelled()); }
@Test public void testCompleteUnmodifiableFuture() throws Exception { CompletableFuture<String> future = new CompletableFuture<>(); CompletableFuture<String> unmodifiableFuture = unmodifiableFuture(future); assertTrue(future.complete("done")); assertEquals(future.getNow(null), "done"); assertTrue(unmodifiableFuture.isDone()); assertEquals(unmodifiableFuture.getNow(null), "done"); }
@Test public void testFailedFuture() throws Exception { CompletableFuture<Object> future = failedFuture(new SQLException("foo")); assertTrue(future.isCompletedExceptionally()); assertFailure(future::get, e -> { assertInstanceOf(e, ExecutionException.class); assertTrue(e.getCause() instanceof SQLException); assertEquals(e.getCause().getMessage(), "foo"); }); }