All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.trino.execution.DataDefinitionExecution Maven / Gradle / Ivy
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.trino.execution;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.inject.Inject;
import io.airlift.units.DataSize;
import io.airlift.units.Duration;
import io.trino.Session;
import io.trino.execution.QueryPreparer.PreparedQuery;
import io.trino.execution.StateMachine.StateChangeListener;
import io.trino.execution.querystats.PlanOptimizersStatsCollector;
import io.trino.execution.warnings.WarningCollector;
import io.trino.server.BasicQueryInfo;
import io.trino.server.ResultQueryInfo;
import io.trino.server.protocol.Slug;
import io.trino.spi.QueryId;
import io.trino.sql.planner.Plan;
import io.trino.sql.tree.Expression;
import io.trino.sql.tree.Statement;
import jakarta.annotation.Nullable;
import org.joda.time.DateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Throwables.throwIfInstanceOf;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
import static java.util.Objects.requireNonNull;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
public class DataDefinitionExecution
implements QueryExecution
{
private final DataDefinitionTask task;
private final T statement;
private final Slug slug;
private final QueryStateMachine stateMachine;
private final List parameters;
private final WarningCollector warningCollector;
private DataDefinitionExecution(
DataDefinitionTask task,
T statement,
Slug slug,
QueryStateMachine stateMachine,
List parameters,
WarningCollector warningCollector)
{
this.task = requireNonNull(task, "task is null");
this.statement = requireNonNull(statement, "statement is null");
this.slug = requireNonNull(slug, "slug is null");
this.stateMachine = requireNonNull(stateMachine, "stateMachine is null");
this.parameters = parameters;
this.warningCollector = requireNonNull(warningCollector, "warningCollector is null");
}
@Override
public Slug getSlug()
{
return slug;
}
@Override
public Session getSession()
{
return stateMachine.getSession();
}
@Override
public DataSize getUserMemoryReservation()
{
return DataSize.ofBytes(0);
}
@Override
public DataSize getTotalMemoryReservation()
{
return DataSize.ofBytes(0);
}
@Override
public DateTime getCreateTime()
{
return stateMachine.getCreateTime();
}
@Override
public Optional getExecutionStartTime()
{
return stateMachine.getExecutionStartTime();
}
@Override
public DateTime getLastHeartbeat()
{
return stateMachine.getLastHeartbeat();
}
@Override
public Optional getEndTime()
{
return stateMachine.getEndTime();
}
@Override
public Duration getTotalCpuTime()
{
return new Duration(0, NANOSECONDS);
}
@Override
public BasicQueryInfo getBasicQueryInfo()
{
return stateMachine.getFinalQueryInfo()
.map(BasicQueryInfo::new)
.orElseGet(() -> stateMachine.getBasicQueryInfo(Optional.empty()));
}
@Override
public void start()
{
try {
// transition to running
if (!stateMachine.transitionToRunning()) {
// query already running or finished
return;
}
ListenableFuture future = task.execute(statement, stateMachine, parameters, warningCollector);
Futures.addCallback(future, new FutureCallback<>()
{
@Override
public void onSuccess(@Nullable Void result)
{
stateMachine.transitionToFinishing();
}
@Override
public void onFailure(Throwable throwable)
{
fail(throwable);
}
}, directExecutor());
}
catch (Throwable e) {
fail(e);
throwIfInstanceOf(e, Error.class);
}
}
@Override
public void setOutputInfoListener(Consumer listener)
{
// DDL does not have an output
}
@Override
public void outputTaskFailed(TaskId taskId, Throwable failure)
{
// DDL does not have an output
}
@Override
public void resultsConsumed()
{
stateMachine.resultsConsumed();
}
@Override
public ListenableFuture getStateChange(QueryState currentState)
{
return stateMachine.getStateChange(currentState);
}
@Override
public void addStateChangeListener(StateChangeListener stateChangeListener)
{
stateMachine.addStateChangeListener(stateChangeListener);
}
@Override
public void addFinalQueryInfoListener(StateChangeListener stateChangeListener)
{
stateMachine.addQueryInfoStateChangeListener(stateChangeListener);
}
@Override
public void fail(Throwable cause)
{
stateMachine.transitionToFailed(cause);
}
@Override
public boolean isDone()
{
return getState().isDone();
}
@Override
public void cancelQuery()
{
stateMachine.transitionToCanceled();
}
@Override
public void cancelStage(StageId stageId)
{
// no-op
}
@Override
public void failTask(TaskId taskId, Exception reason)
{
// no-op
}
@Override
public void recordHeartbeat()
{
stateMachine.recordHeartbeat();
}
@Override
public boolean shouldWaitForMinWorkers()
{
return false;
}
@Override
public void pruneInfo()
{
// no-op
}
@Override
public boolean isInfoPruned()
{
return false;
}
@Override
public QueryId getQueryId()
{
return stateMachine.getQueryId();
}
@Override
public QueryInfo getQueryInfo()
{
return stateMachine.getFinalQueryInfo().orElseGet(() -> stateMachine.updateQueryInfo(Optional.empty()));
}
@Override
public ResultQueryInfo getResultQueryInfo()
{
return stateMachine.getFinalQueryInfo().map(ResultQueryInfo::new).orElseGet(() -> stateMachine.updateResultQueryInfo(Optional.empty(), Optional::empty));
}
@Override
public Optional getQueryPlan()
{
return Optional.empty();
}
@Override
public QueryState getState()
{
return stateMachine.getQueryState();
}
@Override
public Optional getPlanningTime()
{
return stateMachine.getPlanningTime();
}
public List getParameters()
{
return parameters;
}
public static class DataDefinitionExecutionFactory
implements QueryExecutionFactory>
{
private final Map, DataDefinitionTask> tasks;
@Inject
public DataDefinitionExecutionFactory(Map, DataDefinitionTask> tasks)
{
this.tasks = requireNonNull(tasks, "tasks is null");
}
@Override
public DataDefinitionExecution createQueryExecution(
PreparedQuery preparedQuery,
QueryStateMachine stateMachine,
Slug slug,
WarningCollector warningCollector,
PlanOptimizersStatsCollector planOptimizersStatsCollector)
{
return createDataDefinitionExecution(preparedQuery.getStatement(), preparedQuery.getParameters(), stateMachine, slug, warningCollector);
}
private DataDefinitionExecution createDataDefinitionExecution(
T statement,
List parameters,
QueryStateMachine stateMachine,
Slug slug,
WarningCollector warningCollector)
{
@SuppressWarnings("unchecked")
DataDefinitionTask task = (DataDefinitionTask) tasks.get(statement.getClass());
checkArgument(task != null, "no task for statement: %s", statement.getClass().getSimpleName());
stateMachine.setUpdateType(task.getName());
return new DataDefinitionExecution<>(task, statement, slug, stateMachine, parameters, warningCollector);
}
}
}
