public void checkPlanIsDeterministic(String sql) { checkPlanIsDeterministic(localQueryRunner.getDefaultSession(), sql); }
@Override public Session getSession() { return queryRunner.getDefaultSession(); }
protected AbstractOperatorBenchmark( Session session, LocalQueryRunner localQueryRunner, String benchmarkName, int warmupIterations, int measuredIterations) { super(benchmarkName, warmupIterations, measuredIterations); this.localQueryRunner = requireNonNull(localQueryRunner, "localQueryRunner is null"); TransactionId transactionId = localQueryRunner.getTransactionManager().beginTransaction(false); this.session = session.beginTransactionId( transactionId, localQueryRunner.getTransactionManager(), new AllowAllAccessControl()); }
protected void assertDistributedPlan(String sql, PlanMatchPattern pattern) { assertDistributedPlan(sql, getQueryRunner().getDefaultSession(), pattern); }
public void dropTable(String tableName) { Session session = localQueryRunner.getDefaultSession(); Metadata metadata = localQueryRunner.getMetadata(); Optional<TableHandle> tableHandle = metadata.getTableHandle(session, QualifiedObjectName.valueOf(tableName)); assertTrue(tableHandle.isPresent(), "Table " + tableName + " does not exist"); metadata.dropTable(session, tableHandle.get()); }
private StatsCalculatorTester(LocalQueryRunner queryRunner) { this.statsCalculator = queryRunner.getStatsCalculator(); this.session = queryRunner.getDefaultSession(); this.metadata = queryRunner.getMetadata(); this.queryRunner = queryRunner; }
private Session singleNodeOutput(boolean force) { return Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(FORCE_SINGLE_NODE_OUTPUT, Boolean.toString(force)) .build(); } }
private Session optimizeTopNRowNumber(boolean enabled) { return Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(OPTIMIZE_TOP_N_ROW_NUMBER, Boolean.toString(enabled)) .build(); } }
@TearDown(Level.Invocation) public void dropPointsTable() { queryRunner.inTransaction(queryRunner.getDefaultSession(), transactionSession -> { Metadata metadata = queryRunner.getMetadata(); Optional<TableHandle> tableHandle = metadata.getTableHandle(transactionSession, QualifiedObjectName.valueOf("memory.default.points")); assertTrue(tableHandle.isPresent(), "Table memory.default.points does not exist"); metadata.dropTable(transactionSession, tableHandle.get()); return null; }); }
private static LocalQueryRunner createQueryRunner(Map<String, String> sessionProperties) { Session.SessionBuilder sessionBuilder = testSessionBuilder() .setCatalog("local") .setSchema("tiny") .setSystemProperty("task_concurrency", "1"); // these tests don't handle exchanges from local parallel sessionProperties.entrySet().forEach(entry -> sessionBuilder.setSystemProperty(entry.getKey(), entry.getValue())); LocalQueryRunner queryRunner = new LocalQueryRunner(sessionBuilder.build()); queryRunner.createCatalog(queryRunner.getDefaultSession().getCatalog().get(), new TpchConnectorFactory(1), ImmutableMap.of()); return queryRunner; }
private Session withSpatialPartitioning(String tableName) { return Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(SPATIAL_PARTITIONING_TABLE_NAME, tableName) .build(); } }
@BeforeClass public void setUp() { queryRunner = new LocalQueryRunner(testSessionBuilder() .setCatalog("local") .setSchema("tiny") .build()); queryRunner.createCatalog( queryRunner.getDefaultSession().getCatalog().get(), new TpchConnectorFactory(1), ImmutableMap.of()); }
public static void assertPlannerWarnings(LocalQueryRunner queryRunner, @Language("SQL") String sql, Map<String, String> sessionProperties, List<WarningCode> expectedWarnings, Optional<List<Rule<?>>> rules) { Session.SessionBuilder sessionBuilder = testSessionBuilder() .setCatalog(queryRunner.getDefaultSession().getCatalog().get()) .setSchema(queryRunner.getDefaultSession().getSchema().get()); sessionProperties.forEach(sessionBuilder::setSystemProperty); WarningCollector warningCollector = new DefaultWarningCollector(new WarningCollectorConfig()); try { queryRunner.inTransaction(sessionBuilder.build(), transactionSession -> { if (rules.isPresent()) { createPlan(queryRunner, transactionSession, sql, warningCollector, rules.get()); } else { queryRunner.createPlan(transactionSession, sql, LogicalPlanner.Stage.CREATED, false, warningCollector); } return null; }); } catch (SemanticException e) { // ignore } Set<WarningCode> warnings = warningCollector.getWarnings().stream() .map(PrestoWarning::getWarningCode) .collect(toImmutableSet()); for (WarningCode expectedWarning : expectedWarnings) { if (!warnings.contains(expectedWarning)) { fail("Expected warning: " + expectedWarning); } } }
public TestStatsCalculator() { this.queryRunner = new LocalQueryRunner(testSessionBuilder() .setCatalog("local") .setSchema("tiny") .setSystemProperty("task_concurrency", "1") // these tests don't handle exchanges from local parallel .build()); queryRunner.createCatalog( queryRunner.getDefaultSession().getCatalog().get(), new TpchConnectorFactory(1), ImmutableMap.of()); }
@BeforeClass public void setUp() { Session.SessionBuilder sessionBuilder = testSessionBuilder() .setCatalog("local") .setSchema("tiny") .setSystemProperty("task_concurrency", "1") .setSystemProperty("iterative_optimizer_enabled", "true") .setSystemProperty("iterative_optimizer_timeout", "1ms"); queryRunner = new LocalQueryRunner(sessionBuilder.build()); queryRunner.createCatalog(queryRunner.getDefaultSession().getCatalog().get(), new TpchConnectorFactory(1), ImmutableMap.of()); }
Optional.empty(), noLookup(), queryRunner.getDefaultSession(), symbolAllocator.getTypes()); CachingCostProvider costProvider = new CachingCostProvider( statsProvider, Optional.empty(), queryRunner.getDefaultSession(), symbolAllocator.getTypes());
@Test public void testDistributedSort() { ImmutableList<PlanMatchPattern.Ordering> orderBy = ImmutableList.of(sort("ORDERKEY", DESCENDING, LAST)); assertDistributedPlan( "SELECT orderkey FROM orders ORDER BY orderkey DESC", output( exchange(REMOTE, GATHER, orderBy, exchange(LOCAL, GATHER, orderBy, sort(orderBy, exchange(REMOTE, REPARTITION, tableScan("orders", ImmutableMap.of( "ORDERKEY", "orderkey")))))))); assertDistributedPlan( "SELECT orderkey FROM orders ORDER BY orderkey DESC", Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(DISTRIBUTED_SORT, Boolean.toString(false)) .build(), output( sort(orderBy, exchange(LOCAL, GATHER, exchange(REMOTE, GATHER, tableScan("orders", ImmutableMap.of( "ORDERKEY", "orderkey"))))))); } }
@Test public void testUsesDistributedJoinIfNaturallyPartitionedOnProbeSymbols() Session broadcastJoin = Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(JOIN_DISTRIBUTION_TYPE, JoinDistributionType.BROADCAST.name()) .setSystemProperty(FORCE_SINGLE_NODE_OUTPUT, Boolean.toString(false))
@Test public void testBroadcastCorrelatedSubqueryAvoidsRemoteExchangeBeforeAggregation() Session broadcastJoin = Session.builder(this.getQueryRunner().getDefaultSession()) .setSystemProperty(JOIN_DISTRIBUTION_TYPE, JoinDistributionType.BROADCAST.name()) .setSystemProperty(FORCE_SINGLE_NODE_OUTPUT, Boolean.toString(false))
localQueryRunner.getDefaultSession(), false, false,