@Test public void testApproxSetOnlyNulls() { MaterializedResult actual = computeActual("SELECT cardinality(approx_set(null)) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), actual.getTypes()) .row(new Object[] {null}) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testLimit() { assertEquals(computeActual("SELECT * FROM orders LIMIT 10").getRowCount(), 10); }
@Test public void testExampleSystemTable() { assertQuery("SELECT name FROM sys.example", "SELECT 'test' AS name"); MaterializedResult result = computeActual("SHOW SCHEMAS"); assertTrue(result.getOnlyColumnAsSet().containsAll(ImmutableSet.of("sf100", "tiny", "sys"))); result = computeActual("SHOW TABLES FROM sys"); assertEquals(result.getOnlyColumnAsSet(), ImmutableSet.of("example")); }
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); } }
@Test public void testApproxSetVarchar() { MaterializedResult actual = computeActual("SELECT cardinality(approx_set(CAST(custkey AS VARCHAR))) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), BIGINT) .row(1024L) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
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 public void testShowTables() { MaterializedResult actualTables = computeActual("SHOW TABLES").toTestTypes(); MaterializedResult expectedTables = MaterializedResult.resultBuilder(getQueryRunner().getDefaultSession(), VARCHAR) .row("orders") .build(); assertContains(actualTables, expectedTables); }
public static MaterializedResult materializeSourceDataStream(ConnectorSession session, ConnectorPageSource pageSource, List<Type> types) { MaterializedResult.Builder builder = resultBuilder(session, types); while (!pageSource.isFinished()) { Page outputPage = pageSource.getNextPage(); if (outputPage == null) { break; } builder.page(outputPage); } return builder.build(); }
private MaterializedResult getMaterializedRows(List<UUID> uuids, List<Long> columnIds, List<Type> columnTypes) throws IOException { MaterializedResult.Builder rows = MaterializedResult.resultBuilder(SESSION, columnTypes); for (UUID uuid : uuids) { try (ConnectorPageSource pageSource = getPageSource(columnIds, columnTypes, uuid)) { MaterializedResult result = materializeSourceDataStream(SESSION, pageSource, columnTypes); rows.rows(result.getMaterializedRows()); } } return rows.build(); }
/** * Overrides original implementation because of usage of 'extra' column. */ @Test @Override public void testDescribeTable() { MaterializedResult actualColumns = this.computeActual("DESC orders").toTestTypes(); MaterializedResult.Builder builder = MaterializedResult.resultBuilder(this.getQueryRunner().getDefaultSession(), VarcharType.VARCHAR, VarcharType.VARCHAR, VarcharType.VARCHAR, VarcharType.VARCHAR); for (MaterializedRow row : actualColumns.getMaterializedRows()) { builder.row(row.getField(0), row.getField(1), "", ""); } MaterializedResult filteredActual = builder.build(); builder = MaterializedResult.resultBuilder(this.getQueryRunner().getDefaultSession(), VarcharType.VARCHAR, VarcharType.VARCHAR, VarcharType.VARCHAR, VarcharType.VARCHAR); MaterializedResult expectedColumns = builder .row("orderkey", "bigint", "", "") .row("custkey", "bigint", "", "") .row("orderstatus", "varchar", "", "") .row("totalprice", "double", "", "") .row("orderdate", "varchar", "", "") .row("orderpriority", "varchar", "", "") .row("clerk", "varchar", "", "") .row("shippriority", "integer", "", "") .row("comment", "varchar", "", "").build(); assertEquals(filteredActual, expectedColumns, String.format("%s != %s", filteredActual, expectedColumns)); }
@Test public void testLimitInInlineView() { MaterializedResult actual = computeActual("SELECT orderkey FROM (SELECT orderkey FROM orders LIMIT 100) T LIMIT 10"); MaterializedResult all = computeExpected("SELECT orderkey FROM orders", actual.getTypes()); assertEquals(actual.getMaterializedRows().size(), 10); assertContains(all, actual); }
@Test public void selectLargeInterval() { MaterializedResult result = computeActual("SELECT INTERVAL '30' DAY"); assertEquals(result.getRowCount(), 1); assertEquals(result.getMaterializedRows().get(0).getField(0), new SqlIntervalDayTime(30, 0, 0, 0, 0)); result = computeActual("SELECT INTERVAL '" + Short.MAX_VALUE + "' YEAR"); assertEquals(result.getRowCount(), 1); assertEquals(result.getMaterializedRows().get(0).getField(0), new SqlIntervalYearMonth(Short.MAX_VALUE, 0)); }
public void assertQuery(@Language("SQL") String actual, @Language("SQL") String expected, boolean ensureOrdering) { MaterializedResult actualResults = null; try { actualResults = runner.execute(runner.getDefaultSession(), actual).toTestTypes(); } catch (RuntimeException ex) { fail("Execution of 'actual' query failed: " + actual, ex); } MaterializedResult expectedResults = null; try { expectedResults = runner.execute(runner.getDefaultSession(), expected).toTestTypes(); } catch (RuntimeException ex) { fail("Execution of 'expected' query failed: " + expected, ex); } assertEquals(actualResults.getTypes(), expectedResults.getTypes(), "Types mismatch for query: \n " + actual + "\n:"); List<MaterializedRow> actualRows = actualResults.getMaterializedRows(); List<MaterializedRow> expectedRows = expectedResults.getMaterializedRows(); if (ensureOrdering) { if (!actualRows.equals(expectedRows)) { assertEquals(actualRows, expectedRows, "For query: \n " + actual + "\n:"); } } else { assertEqualsIgnoreOrder(actualRows, expectedRows, "For query: \n " + actual); } }
@Test public void testShardingByTemporalDateColumn() { // Make sure we have at least 2 different orderdate. assertEquals(computeActual("SELECT count(DISTINCT orderdate) >= 2 FROM orders WHERE orderdate < date '1992-02-08'").getOnlyValue(), true); assertUpdate("CREATE TABLE test_shard_temporal_date " + "WITH (temporal_column = 'orderdate') AS " + "SELECT orderdate, orderkey " + "FROM orders " + "WHERE orderdate < date '1992-02-08'", "SELECT count(*) " + "FROM orders " + "WHERE orderdate < date '1992-02-08'"); MaterializedResult results = computeActual("SELECT orderdate, \"$shard_uuid\" FROM test_shard_temporal_date"); // Each shard will only contain data of one date. SetMultimap<String, LocalDate> shardDateMap = HashMultimap.create(); for (MaterializedRow row : results.getMaterializedRows()) { shardDateMap.put((String) row.getField(1), (LocalDate) row.getField(0)); } for (Collection<LocalDate> dates : shardDateMap.asMap().values()) { assertEquals(dates.size(), 1); } // Make sure we have all the rows assertQuery("SELECT orderdate, orderkey FROM test_shard_temporal_date", "SELECT orderdate, orderkey FROM orders WHERE orderdate < date '1992-02-08'"); }
@Test public void testGroupByNan() { MaterializedResult actual = computeActual("SELECT * FROM (VALUES nan(), nan(), nan()) GROUP BY 1"); assertTrue(Double.isNaN((Double) actual.getOnlyValue())); }
@Test public void testCreateExternalTable() throws Exception { File tempDir = createTempDir(); File dataFile = new File(tempDir, "test.txt"); Files.write("hello\nworld\n", dataFile, UTF_8); @Language("SQL") String createTableSql = format("" + "CREATE TABLE %s.%s.test_create_external (\n" + " name varchar\n" + ")\n" + "WITH (\n" + " external_location = '%s',\n" + " format = 'TEXTFILE'\n" + ")", getSession().getCatalog().get(), getSession().getSchema().get(), new Path(tempDir.toURI().toASCIIString()).toString()); assertUpdate(createTableSql); MaterializedResult actual = computeActual("SHOW CREATE TABLE test_create_external"); assertEquals(actual.getOnlyValue(), createTableSql); actual = computeActual("SELECT name FROM test_create_external"); assertEquals(actual.getOnlyColumnAsSet(), ImmutableSet.of("hello", "world")); assertUpdate("DROP TABLE test_create_external"); // file should still exist after drop assertFile(dataFile); deleteRecursively(tempDir.toPath(), ALLOW_INSECURE); }
private void assertCastWithJsonParse(String json, String castSqlType, Type expectedType, Object expected) { String query = "" + "SELECT CAST(JSON_PARSE(col) AS " + castSqlType + ") " + "FROM (VALUES('" + json + "')) AS t(col)"; // building queries with VALUES to avoid constant folding MaterializedResult result = runner.execute(query); assertEquals(result.getTypes().size(), 1); assertEquals(result.getTypes().get(0), expectedType); assertEquals(result.getOnlyValue(), expected); }
protected MaterializedResult computeActual(Session session, @Language("SQL") String sql) { return queryRunner.execute(session, sql).toTestTypes(); }
public static void assertWindowQueryWithNulls(@Language("SQL") String sql, MaterializedResult expected, LocalQueryRunner localQueryRunner) { MaterializedResult actual = executeWindowQueryWithNulls(sql, localQueryRunner); assertEqualsIgnoreOrder(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testTopNUnpartitionedWindow() { MaterializedResult actual = computeActual("" + "SELECT * FROM (\n" + " SELECT row_number() OVER (ORDER BY orderkey) rn, orderkey, orderstatus\n" + " FROM orders\n" + ") WHERE rn <= 5"); String sql = "SELECT row_number() OVER (), orderkey, orderstatus FROM orders ORDER BY orderkey LIMIT 5"; MaterializedResult expected = computeExpected(sql, actual.getTypes()); assertEquals(actual, expected); }