@Override public void execute(String sql) { try { queryRunner.execute(queryRunner.getDefaultSession(), sql); } catch (Throwable e) { throw new RuntimeException("Error executing sql:\n" + sql, e); } } }
protected static void assertQuerySucceeds(QueryRunner queryRunner, Session session, @Language("SQL") String sql) { try { queryRunner.execute(session, sql); } catch (RuntimeException e) { fail(format("Expected query to succeed: %s", sql), e); } }
protected static void assertQueryReturnsEmptyResult(QueryRunner queryRunner, Session session, @Language("SQL") String sql) { try { MaterializedResult results = queryRunner.execute(session, sql).toTestTypes(); assertNotNull(results); assertEquals(results.getRowCount(), 0); } catch (RuntimeException ex) { fail("Execution of query failed: " + sql, ex); } }
protected static void assertQueryFails(QueryRunner queryRunner, Session session, @Language("SQL") String sql, @Language("RegExp") String expectedMessageRegExp) { try { queryRunner.execute(session, sql); fail(format("Expected query to fail: %s", sql)); } catch (RuntimeException ex) { assertExceptionMessage(sql, ex, expectedMessageRegExp); } }
@Test(timeOut = 60_000, expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = ".*Query exceeded distributed total memory limit of 2kB.*") public void testQueryTotalMemoryLimit() throws Exception { Map<String, String> properties = ImmutableMap.<String, String>builder() .put("query.max-memory", "1kB") .put("query.max-total-memory", "2kB") .build(); try (QueryRunner queryRunner = createQueryRunner(SESSION, properties)) { queryRunner.execute(SESSION, "SELECT COUNT(*), repeat(orderstatus, 1000) FROM orders GROUP BY 2"); } }
@Benchmark public MaterializedResult queryInformationSchema(BenchmarkData benchmarkData) { return benchmarkData.queryRunner.execute(benchmarkData.query); }
@Test public void testAdminCanRead() { Session admin = getSession("admin"); queryRunner.execute(admin, "SELECT * FROM disks"); }
private MaterializedResult execute(String sql) { return getQueryRunner().execute(SESSION, sql); } }
@Test(expectedExceptions = {SemanticException.class}, expectedExceptionsMessageRegExp = ".*Function log not registered") public void testLegacyLogFunctionDisabled() { try (QueryRunner runner = createQueryRunner(false)) { runner.execute(QUERY); } }
@Test(timeOut = 60_000, expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = ".*Query exceeded per-node user memory limit of 1kB.*") public void testQueryMemoryPerNodeLimit() throws Exception { Map<String, String> properties = ImmutableMap.<String, String>builder() .put("task.max-partial-aggregation-memory", "1B") .put("query.max-memory-per-node", "1kB") .build(); try (QueryRunner queryRunner = createQueryRunner(SESSION, properties)) { queryRunner.execute(SESSION, "SELECT COUNT(*), repeat(orderstatus, 1000) FROM orders GROUP BY 2"); } }
@Test public void testLegacyGroupBy() { MaterializedResult result = runner.execute("select * from (values nan(), nan(), nan()) group by 1"); List<MaterializedRow> rows = result.getMaterializedRows(); assertEquals(rows.size(), 3); rows.stream() .forEach(row -> assertTrue(Double.isNaN((Double) row.getField(0)))); }
@Test public void testLegacyLogFunctionEnabled() { try (QueryRunner queryRunner = createQueryRunner(true)) { MaterializedResult result = queryRunner.execute(QUERY); assertEquals(result.getOnlyValue(), 2.0); } }
@Test(timeOut = 60_000) public void testTimeout() { try { queryRunner.execute("SELECT * FROM disks"); fail(); } catch (PrestoException e) { assertEquals(e.getErrorCode(), ATOP_READ_TIMEOUT.toErrorCode(), e.getMessage()); } }
@Test public void testSelectWithUnenforcedConstraint() { createBlackholeAllTypesTable(); MaterializedResult rows = queryRunner.execute("SELECT * FROM blackhole_all_types where _bigint > 10"); assertEquals(rows.getRowCount(), 0); dropBlackholeAllTypesTable(); }
protected void assertAccessAllowed(Session session, @Language("SQL") String sql, TestingPrivilege... deniedPrivileges) { executeExclusively(() -> { try { queryRunner.getAccessControl().deny(deniedPrivileges); queryRunner.execute(session, sql); } finally { queryRunner.getAccessControl().reset(); } }); }
@Benchmark public MaterializedResult benchmarkReorderJoins(BenchmarkInfo benchmarkInfo) { return benchmarkInfo.getQueryRunner().execute(benchmarkInfo.getQuery()); }
private void assertOneNotNullResult(String query) { MaterializedResult results = getQueryRunner().execute(getSession(), query).toTestTypes(); assertEquals(results.getRowCount(), 1); assertEquals(results.getMaterializedRows().get(0).getFieldCount(), 1); assertNotNull(results.getMaterializedRows().get(0).getField(0)); } }
@Test(timeOut = 240_000, expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = ".*Query exceeded per-query local spill limit of 10B") public void testQueryMaxSpillPerNodeLimit() { try (QueryRunner queryRunner = createLocalQueryRunner(new NodeSpillConfig().setQueryMaxSpillPerNode(DataSize.succinctBytes(10)))) { queryRunner.execute(queryRunner.getDefaultSession(), "SELECT COUNT(DISTINCT clerk) as count, orderdate FROM orders GROUP BY orderdate ORDER BY count, orderdate"); } }
@Test(timeOut = 240_000, expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = ".*Query exceeded local spill limit of 10B") public void testMaxSpillPerNodeLimit() { try (QueryRunner queryRunner = createLocalQueryRunner(new NodeSpillConfig().setMaxSpillPerNode(DataSize.succinctBytes(10)))) { queryRunner.execute(queryRunner.getDefaultSession(), "SELECT COUNT(DISTINCT clerk) as count, orderdate FROM orders GROUP BY orderdate ORDER BY count, orderdate"); } }