import com.facebook.presto.Session; //导入依赖的package包/类
public static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("slack")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new DistributedQueryRunner(defaultSession, 1);
    queryRunner.installPlugin(new SlackPlugin());

    queryRunner.createCatalog(
            "slack",
            "slack",
            ImmutableMap.of("token", System.getenv("SLACK_TOKEN")));

    return queryRunner;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("github")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new DistributedQueryRunner(defaultSession, 1);
    queryRunner.installPlugin(new GithubPlugin());

    queryRunner.createCatalog(
            "github",
            "github",
            ImmutableMap.of("token", System.getenv("GITHUB_TOKEN")));

    return queryRunner;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
private static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = TestingSession.testSessionBuilder()
            .setCatalog("twitter")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new DistributedQueryRunner(defaultSession, 1);
    queryRunner.installPlugin(new TwitterPlugin());

    queryRunner.createCatalog(
            "twitter",
            "twitter",
            ImmutableMap.of(
                    "customer_key", System.getenv("TWITTER_CUSTOMER_KEY"),
                    "customer_secret", System.getenv("TWITTER_CUSTOMER_SECRET"),
                    "token", System.getenv("TWITTER_TOKEN"),
                    "secret", System.getenv("TWITTER_SECRET")));

    return queryRunner;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
private static LocalQueryRunner createLocalQueryRunner()
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("tpch")
            .setSchema(TINY_SCHEMA_NAME)
            .build();

    LocalQueryRunner localQueryRunner = new LocalQueryRunner(defaultSession);
    InMemoryNodeManager nodeManager = localQueryRunner.getNodeManager();
    localQueryRunner.createCatalog("tpch", new TpchConnectorFactory(nodeManager, 1), ImmutableMap.<String, String>of());

    HyperLogLogPlugin plugin = new HyperLogLogPlugin();
    for (Type type : plugin.getTypes()) {
        localQueryRunner.getTypeManager().addType(type);
    }
    for (ParametricType parametricType : plugin.getParametricTypes()) {
        localQueryRunner.getTypeManager().addParametricType(parametricType);
    }

    localQueryRunner.getMetadata().addFunctions(extractFunctions(plugin.getFunctions()));

    return localQueryRunner;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
@Override
public List<QualifiedObjectName> listTables(Session session, QualifiedTablePrefix prefix)
{
    requireNonNull(prefix, "prefix is null");

    String schemaNameOrNull = prefix.getSchemaName().orElse(null);
    Set<QualifiedObjectName> tables = new LinkedHashSet<>();
    for (ConnectorEntry entry : allConnectorsFor(prefix.getCatalogName())) {
        ConnectorMetadata metadata = entry.getMetadata(session);
        ConnectorSession connectorSession = session.toConnectorSession(entry.getCatalog());
        for (QualifiedObjectName tableName : transform(metadata.listTables(connectorSession, schemaNameOrNull), convertFromSchemaTableName(prefix.getCatalogName()))) {
            tables.add(tableName);
        }
    }
    return ImmutableList.copyOf(tables);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public StatementAnalyzer(
        Analysis analysis,
        Metadata metadata,
        SqlParser sqlParser,
        AccessControl accessControl, Session session,
        boolean experimentalSyntaxEnabled,
        Optional<QueryExplainer> queryExplainer)
{
    this.analysis = requireNonNull(analysis, "analysis is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.sqlParser = requireNonNull(sqlParser, "sqlParser is null");
    this.accessControl = requireNonNull(accessControl, "accessControl is null");
    this.session = requireNonNull(session, "session is null");
    this.experimentalSyntaxEnabled = experimentalSyntaxEnabled;
    this.queryExplainer = requireNonNull(queryExplainer, "queryExplainer is null");
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public static LocalQueryRunner createLocalQueryRunner()
{
    Session session = testSessionBuilder()
            .setCatalog("raptor")
            .setSchema("benchmark")
            .build();
    LocalQueryRunner localQueryRunner = new LocalQueryRunner(session);

    // add tpch
    InMemoryNodeManager nodeManager = localQueryRunner.getNodeManager();
    localQueryRunner.createCatalog("tpch", new TpchConnectorFactory(nodeManager, 1), ImmutableMap.<String, String>of());

    // add raptor
    ConnectorFactory raptorConnectorFactory = createRaptorConnectorFactory(TPCH_CACHE_DIR, nodeManager);
    localQueryRunner.createCatalog("raptor", raptorConnectorFactory, ImmutableMap.of());

    if (!localQueryRunner.tableExists(session, "orders")) {
        localQueryRunner.execute("CREATE TABLE orders AS SELECT * FROM tpch.sf1.orders");
    }
    if (!localQueryRunner.tableExists(session, "lineitem")) {
        localQueryRunner.execute("CREATE TABLE lineitem AS SELECT * FROM tpch.sf1.lineitem");
    }
    return localQueryRunner;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public String getGraphvizPlan(Session session, Statement statement, Type planType)
{
    DataDefinitionTask<?> task = dataDefinitionTask.get(statement.getClass());
    if (task != null) {
        // todo format as graphviz
        return explainTask(statement, task);
    }

    switch (planType) {
        case LOGICAL:
            Plan plan = getLogicalPlan(session, statement);
            return PlanPrinter.graphvizLogicalPlan(plan.getRoot(), plan.getTypes());
        case DISTRIBUTED:
            SubPlan subPlan = getDistributedPlan(session, statement);
            return PlanPrinter.graphvizDistributedPlan(subPlan);
    }
    throw new IllegalArgumentException("Unhandled plan type: " + planType);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
@Override
public List<QualifiedObjectName> listViews(Session session, QualifiedTablePrefix prefix)
{
    requireNonNull(prefix, "prefix is null");

    String schemaNameOrNull = prefix.getSchemaName().orElse(null);
    Set<QualifiedObjectName> views = new LinkedHashSet<>();
    for (ConnectorEntry entry : allConnectorsFor(prefix.getCatalogName())) {
        ConnectorMetadata metadata = entry.getMetadata(session);
        ConnectorSession connectorSession = session.toConnectorSession(entry.getCatalog());
        for (QualifiedObjectName tableName : transform(metadata.listViews(connectorSession, schemaNameOrNull), convertFromSchemaTableName(prefix.getCatalogName()))) {
            views.add(tableName);
        }
    }
    return ImmutableList.copyOf(views);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public static ExpressionAnalysis analyzeExpressionsWithSymbols(
        Session session,
        Metadata metadata,
        SqlParser sqlParser,
        Map<Symbol, Type> types,
        Iterable<? extends Expression> expressions)
{
    List<Field> fields = DependencyExtractor.extractUnique(expressions).stream()
            .map(symbol -> {
                Type type = types.get(symbol);
                checkArgument(type != null, "No type for symbol %s", symbol);
                return Field.newUnqualified(symbol.getName(), type);
            })
            .collect(toImmutableList());

    return analyzeExpressions(session, metadata, sqlParser, new RelationType(fields), expressions);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public static RowExpression translate(
        Expression expression,
        FunctionKind functionKind,
        IdentityHashMap<Expression, Type> types,
        FunctionRegistry functionRegistry,
        TypeManager typeManager,
        Session session,
        boolean optimize)
{
    RowExpression result = new Visitor(functionKind, types, typeManager, session.getTimeZoneKey()).process(expression, null);

    requireNonNull(result, "translated expression is null");

    if (optimize) {
        ExpressionOptimizer optimizer = new ExpressionOptimizer(functionRegistry, typeManager, session);
        return optimizer.optimize(result);
    }

    return result;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public Query(Session session,
        String query,
        QueryManager queryManager,
        ExchangeClient exchangeClient)
{
    requireNonNull(session, "session is null");
    requireNonNull(query, "query is null");
    requireNonNull(queryManager, "queryManager is null");
    requireNonNull(exchangeClient, "exchangeClient is null");

    this.session = session;
    this.queryManager = queryManager;

    QueryInfo queryInfo = queryManager.createQuery(session, query);
    queryId = queryInfo.getQueryId();
    this.exchangeClient = exchangeClient;
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
@Override
public CompletableFuture<?> execute(RenameTable statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine)
{
    Session session = stateMachine.getSession();
    QualifiedObjectName tableName = createQualifiedObjectName(session, statement, statement.getSource());
    Optional<TableHandle> tableHandle = metadata.getTableHandle(session, tableName);
    if (!tableHandle.isPresent()) {
        throw new SemanticException(MISSING_TABLE, statement, "Table '%s' does not exist", tableName);
    }

    QualifiedObjectName target = createQualifiedObjectName(session, statement, statement.getTarget());
    if (!metadata.getCatalogNames().containsKey(target.getCatalogName())) {
        throw new SemanticException(MISSING_CATALOG, statement, "Target catalog '%s' does not exist", target.getCatalogName());
    }
    if (metadata.getTableHandle(session, target).isPresent()) {
        throw new SemanticException(TABLE_ALREADY_EXISTS, statement, "Target table '%s' already exists", target);
    }
    if (!tableName.getCatalogName().equals(target.getCatalogName())) {
        throw new SemanticException(NOT_SUPPORTED, statement, "Table rename across catalogs is not supported");
    }
    accessControl.checkCanRenameTable(session.getRequiredTransactionId(), session.getIdentity(), tableName, target);

    metadata.renameTable(session, tableHandle.get(), target);

    return completedFuture(null);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
@POST
@Produces(MediaType.APPLICATION_JSON)
public Response createQuery(String query, @Context HttpServletRequest servletRequest)
{
    assertRequest(!isNullOrEmpty(query), "SQL query is empty");

    Session session = createSessionForRequest(servletRequest, accessControl, sessionPropertyManager, queryIdGenerator.createNextQueryId());
    ClientSession clientSession = session.toClientSession(serverUri(), false, new Duration(2, MINUTES));

    StatementClient client = new StatementClient(httpClient, queryResultsCodec, clientSession, query);

    List<Column> columns = getColumns(client);
    Iterator<List<Object>> iterator = flatten(new ResultsPageIterator(client));
    SimpleQueryResults results = new SimpleQueryResults(columns, iterator);

    return Response.ok(results, MediaType.APPLICATION_JSON_TYPE).build();
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
private Operator interpretedFilterProject(Expression filter, Expression projection, Session session)
{
    FilterFunction filterFunction = new InterpretedFilterFunction(
            filter,
            SYMBOL_TYPES,
            INPUT_MAPPING,
            metadata,
            SQL_PARSER,
            session
    );

    ProjectionFunction projectionFunction = new InterpretedProjectionFunction(
            projection,
            SYMBOL_TYPES,
            INPUT_MAPPING,
            metadata,
            SQL_PARSER,
            session
    );

    OperatorFactory operatorFactory = new FilterAndProjectOperator.FilterAndProjectOperatorFactory(0, new PlanNodeId("test"), new GenericPageProcessor(filterFunction, ImmutableList.of(projectionFunction)), toTypes(
            ImmutableList.of(projectionFunction)));
    return operatorFactory.createOperator(createDriverContext(session));
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public String getPlan(Session session, Statement statement, Type planType)
{
    DataDefinitionTask<?> task = dataDefinitionTask.get(statement.getClass());
    if (task != null) {
        return explainTask(statement, task);
    }

    switch (planType) {
        case LOGICAL:
            Plan plan = getLogicalPlan(session, statement);
            return PlanPrinter.textLogicalPlan(plan.getRoot(), plan.getTypes(), metadata, session);
        case DISTRIBUTED:
            SubPlan subPlan = getDistributedPlan(session, statement);
            return PlanPrinter.textDistributedPlan(subPlan, metadata, session);
    }
    throw new IllegalArgumentException("Unhandled plan type: " + planType);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public StandaloneQueryRunner(Session defaultSession)
        throws Exception
{
    requireNonNull(defaultSession, "defaultSession is null");

    try {
        server = createTestingPrestoServer();
    }
    catch (Exception e) {
        close();
        throw e;
    }

    this.prestoClient = new TestingPrestoClient(server, defaultSession);

    refreshNodes();

    server.getMetadata().addFunctions(AbstractTestQueries.CUSTOM_FUNCTIONS);

    SessionPropertyManager sessionPropertyManager = server.getMetadata().getSessionPropertyManager();
    sessionPropertyManager.addSystemSessionProperties(AbstractTestQueries.TEST_SYSTEM_PROPERTIES);
    sessionPropertyManager.addConnectorSessionProperties("catalog", AbstractTestQueries.TEST_CATALOG_PROPERTIES);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
public SqlTaskExecution create(Session session, QueryContext queryContext, TaskStateMachine taskStateMachine, SharedBuffer sharedBuffer, PlanFragment fragment, List<TaskSource> sources)
{
    boolean verboseStats = getVerboseStats(session);
    TaskContext taskContext = queryContext.addTaskContext(
            taskStateMachine,
            session,
            requireNonNull(operatorPreAllocatedMemory, "operatorPreAllocatedMemory is null"),
            verboseStats,
            cpuTimerEnabled);

    return createSqlTaskExecution(
            taskStateMachine,
            taskContext,
            sharedBuffer,
            fragment,
            sources,
            planner,
            taskExecutor,
            taskNotificationExecutor,
            queryMonitor);
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
private static DistributedQueryRunner createQueryRunner()
        throws Exception
{
    Session session = testSessionBuilder()
            .setSource("test")
            .setCatalog("tpch")
            .setSchema("tiny")
            .build();

    DistributedQueryRunner queryRunner = new DistributedQueryRunner(session, 4, ImmutableMap.of("optimizer.optimize-hash-generation", "false"));

    try {
        queryRunner.installPlugin(new TpchPlugin());
        queryRunner.createCatalog("tpch", "tpch");

        queryRunner.installPlugin(new SampledTpchPlugin());
        queryRunner.createCatalog("tpch_sampled", "tpch_sampled");

        return queryRunner;
    }
    catch (Exception e) {
        queryRunner.close();
        throw e;
    }
}
 

import com.facebook.presto.Session; //导入依赖的package包/类
/**
 * Returns list of queues to enter, or null if query does not match rule
 */
public List<QueryQueueDefinition> match(Session session)
{
    if (userRegex != null && !userRegex.matcher(session.getUser()).matches()) {
        return null;
    }
    if (sourceRegex != null) {
        String source = session.getSource().orElse("");
        if (!sourceRegex.matcher(source).matches()) {
            return null;
        }
    }

    for (Map.Entry<String, Pattern> entry : sessionPropertyRegexes.entrySet()) {
        String value = session.getSystemProperties().getOrDefault(entry.getKey(), "");
        if (!entry.getValue().matcher(value).matches()) {
            return null;
        }
    }

    return queues;
}