public static Builder resultBuilder(ConnectorSession session, Type... types) { return resultBuilder(session, ImmutableList.copyOf(types)); }
@Test public void testTableSampleBernoulli() { DescriptiveStatistics stats = new DescriptiveStatistics(); int total = computeExpected("SELECT orderkey FROM orders", ImmutableList.of(BIGINT)).getMaterializedRows().size(); for (int i = 0; i < 100; i++) { List<MaterializedRow> values = computeActual("SELECT orderkey FROM orders TABLESAMPLE BERNOULLI (50)").getMaterializedRows(); assertEquals(values.size(), ImmutableSet.copyOf(values).size(), "TABLESAMPLE produced duplicate rows"); stats.addValue(values.size() * 1.0 / total); } double mean = stats.getGeometricMean(); assertTrue(mean > 0.45 && mean < 0.55, format("Expected mean sampling rate to be ~0.5, but was %s", mean)); }
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 testValuesWithUnusedColumns() { MaterializedResult actual = computeActual("SELECT foo FROM (values (1, 2)) a(foo, bar)"); MaterializedResult expected = resultBuilder(getSession(), actual.getTypes()) .row(1) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testMergeHyperLogLogWithNulls() { MaterializedResult actual = computeActual("SELECT cardinality(merge(create_hll(IF(orderstatus = 'O', custkey)))) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), BIGINT) .row(1001L) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testPartiallyPreGroupedPartitionWithEmptyInput() { List<Page> input = rowPagesBuilder(BIGINT, VARCHAR, BIGINT, VARCHAR) .pageBreak() .pageBreak() .build(); WindowOperatorFactory operatorFactory = createFactoryUnbounded( ImmutableList.of(BIGINT, VARCHAR, BIGINT, VARCHAR), Ints.asList(0, 1, 2, 3), ROW_NUMBER, Ints.asList(0, 1), Ints.asList(1), Ints.asList(3), ImmutableList.of(SortOrder.ASC_NULLS_LAST), 0); MaterializedResult expected = resultBuilder(driverContext.getSession(), BIGINT, VARCHAR, BIGINT, VARCHAR, BIGINT) .build(); assertOperatorEquals(operatorFactory, driverContext, input, expected); }
@Test public void testShowTables() { Set<String> expectedTables = ImmutableSet.copyOf(transform(TpchTable.getTables(), TpchTable::getTableName)); MaterializedResult result = computeActual("SHOW TABLES"); assertTrue(result.getOnlyColumnAsSet().containsAll(expectedTables)); }
private MaterializedResult readTable( ConnectorTableHandle tableHandle, List<ColumnHandle> columnHandles, ConnectorSession session, TupleDomain<ColumnHandle> tupleDomain, OptionalInt expectedSplitCount, Optional<HiveStorageFormat> expectedStorageFormat) throws Exception { ConnectorMetadata metadata = newMetadata(); ConnectorTransactionHandle transactionHandle = newTransaction(); List<ConnectorTableLayoutResult> tableLayoutResults = metadata.getTableLayouts(session, tableHandle, new Constraint<>(tupleDomain, bindings -> true), Optional.empty()); ConnectorTableLayoutHandle layoutHandle = getOnlyElement(tableLayoutResults).getTableLayout().getHandle(); List<ConnectorSplit> splits = getAllSplits(splitManager.getSplits(transactionHandle, session, layoutHandle)); if (expectedSplitCount.isPresent()) { assertEquals(splits.size(), expectedSplitCount.getAsInt()); } ImmutableList.Builder<MaterializedRow> allRows = ImmutableList.builder(); for (ConnectorSplit split : splits) { try (ConnectorPageSource pageSource = pageSourceProvider.createPageSource(transactionHandle, session, split, columnHandles)) { if (expectedStorageFormat.isPresent()) { assertPageSourceType(pageSource, expectedStorageFormat.get()); } MaterializedResult result = materializeSourceDataStream(session, pageSource, getTypes(columnHandles)); allRows.addAll(result.getMaterializedRows()); } } return new MaterializedResult(allRows.build(), getTypes(columnHandles)); }
@Test public void testDescribeOutput() { Session session = Session.builder(getSession()) .addPreparedStatement("my_query", "SELECT * FROM nation") .build(); MaterializedResult actual = computeActual(session, "DESCRIBE OUTPUT my_query"); MaterializedResult expected = resultBuilder(session, VARCHAR, VARCHAR, VARCHAR, VARCHAR, VARCHAR, BIGINT, BOOLEAN) .row("nationkey", session.getCatalog().get(), session.getSchema().get(), "nation", "bigint", 8, false) .row("name", session.getCatalog().get(), session.getSchema().get(), "nation", "varchar(25)", 0, false) .row("regionkey", session.getCatalog().get(), session.getSchema().get(), "nation", "bigint", 8, false) .row("comment", session.getCatalog().get(), session.getSchema().get(), "nation", "varchar(152)", 0, false) .build(); assertEqualsIgnoreOrder(actual, expected); }
private MaterializedResult readTable( Transaction transaction, ConnectorTableHandle tableHandle, List<ColumnHandle> columnHandles, ConnectorSession session, TupleDomain<ColumnHandle> tupleDomain, OptionalInt expectedSplitCount, Optional<HiveStorageFormat> expectedStorageFormat) throws Exception { List<ConnectorTableLayoutResult> tableLayoutResults = transaction.getMetadata().getTableLayouts( session, tableHandle, new Constraint<>(tupleDomain), Optional.empty()); ConnectorTableLayoutHandle layoutHandle = getOnlyElement(tableLayoutResults).getTableLayout().getHandle(); List<ConnectorSplit> splits = getAllSplits(splitManager.getSplits(transaction.getTransactionHandle(), session, layoutHandle, UNGROUPED_SCHEDULING)); if (expectedSplitCount.isPresent()) { assertEquals(splits.size(), expectedSplitCount.getAsInt()); } ImmutableList.Builder<MaterializedRow> allRows = ImmutableList.builder(); for (ConnectorSplit split : splits) { try (ConnectorPageSource pageSource = pageSourceProvider.createPageSource(transaction.getTransactionHandle(), session, split, columnHandles)) { expectedStorageFormat.ifPresent(format -> assertPageSourceType(pageSource, format)); MaterializedResult result = materializeSourceDataStream(session, pageSource, getTypes(columnHandles)); allRows.addAll(result.getMaterializedRows()); } } return new MaterializedResult(allRows.build(), getTypes(columnHandles)); }
@Test public void testShowCatalogsLike() { MaterializedResult result = computeActual(format("SHOW CATALOGS LIKE '%s'", getSession().getCatalog().get())); assertEquals(result.getOnlyColumnAsSet(), ImmutableSet.of(getSession().getCatalog().get())); }
@Test public void testBucketedTableDoubleFloat() throws Exception { try (Transaction transaction = newTransaction()) { ConnectorMetadata metadata = transaction.getMetadata(); ConnectorSession session = newSession(); ConnectorTableHandle tableHandle = getTableHandle(metadata, tableBucketedDoubleFloat); List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(session, tableHandle).values()); Map<String, Integer> columnIndex = indexColumns(columnHandles); assertTableIsBucketed(tableHandle); ImmutableMap<ColumnHandle, NullableValue> bindings = ImmutableMap.<ColumnHandle, NullableValue>builder() .put(columnHandles.get(columnIndex.get("t_float")), NullableValue.of(REAL, (long) floatToRawIntBits(87.1f))) .put(columnHandles.get(columnIndex.get("t_double")), NullableValue.of(DOUBLE, 88.2)) .build(); // floats and doubles are not supported, so we should see all splits MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.fromFixedValues(bindings), OptionalInt.of(32), Optional.empty()); assertEquals(result.getRowCount(), 100); } }
@Test public void testShowSchemas() { MaterializedResult actualSchemas = computeActual("SHOW SCHEMAS").toTestTypes(); MaterializedResult.Builder resultBuilder = MaterializedResult.resultBuilder(getQueryRunner().getDefaultSession(), VARCHAR) .row(getQueryRunner().getDefaultSession().getSchema().orElse("tpch")); assertContains(actualSchemas, resultBuilder.build()); }
@Test public void testEmptyProbe() { TaskContext taskContext = createTaskContext(); RowPagesBuilder buildPages = rowPagesBuilder(ImmutableList.of(GEOMETRY, VARCHAR)) .row(POLYGON_A, "A") .row(null, "null") .pageBreak() .row(POLYGON_B, "B"); RowPagesBuilder probePages = rowPagesBuilder(ImmutableList.of(GEOMETRY, VARCHAR)); MaterializedResult expected = resultBuilder(taskContext.getSession(), ImmutableList.of(VARCHAR, VARCHAR)).build(); assertSpatialJoin(taskContext, INNER, buildPages, probePages, expected); }
@Test public void testDateToTimestampCoercion() { // allow running tests with a connector that supports TIMESTAMP but not DATE // ordinary date MaterializedResult rows = h2QueryRunner.execute(TEST_SESSION, "SELECT DATE '2018-01-13'", ImmutableList.of(TIMESTAMP)); assertEquals(rows.getOnlyValue(), LocalDate.of(2018, 1, 13).atStartOfDay()); // date, which midnight was skipped in JVM zone LocalDate forwardOffsetChangeAtMidnightInJvmZone = LocalDate.of(1970, 1, 1); checkState(ZoneId.systemDefault().getRules().getValidOffsets(forwardOffsetChangeAtMidnightInJvmZone.atStartOfDay()).size() == 0, "This test assumes certain JVM time zone"); rows = h2QueryRunner.execute(TEST_SESSION, DateTimeFormatter.ofPattern("'SELECT DATE '''uuuu-MM-dd''").format(forwardOffsetChangeAtMidnightInJvmZone), ImmutableList.of(TIMESTAMP)); assertEquals(rows.getOnlyValue(), forwardOffsetChangeAtMidnightInJvmZone.atStartOfDay()); } }
@Test public void testGroupByNanArray() { MaterializedResult actual = computeActual("SELECT a FROM (VALUES (ARRAY[nan(), 2e0, 3e0]), (ARRAY[nan(), 2e0, 3e0])) t(a) GROUP BY a"); List<MaterializedRow> actualRows = actual.getMaterializedRows(); assertEquals(actualRows.size(), 1); assertTrue(Double.isNaN(((List<Double>) actualRows.get(0).getField(0)).get(0))); assertEquals(((List<Double>) actualRows.get(0).getField(0)).get(1), 2.0); assertEquals(((List<Double>) actualRows.get(0).getField(0)).get(2), 3.0); }
@Test public void testDefaultExplainTextFormat() { String query = "SELECT * FROM orders"; MaterializedResult result = computeActual("EXPLAIN " + query); assertEquals(getOnlyElement(result.getOnlyColumnAsSet()), getExplainPlan(query, LOGICAL)); }
protected void assertTableColumnNames(String tableName, String... columnNames) { MaterializedResult result = computeActual("DESCRIBE " + tableName); List<String> expected = ImmutableList.copyOf(columnNames); List<String> actual = result.getMaterializedRows().stream() .map(row -> (String) row.getField(0)) .collect(toImmutableList()); assertEquals(actual, expected); }
@Test public void testRenameColumn() { assertUpdate("CREATE TABLE test_rename_column AS SELECT 123 x", 1); assertUpdate("ALTER TABLE test_rename_column RENAME COLUMN x TO y"); MaterializedResult materializedRows = computeActual("SELECT y FROM test_rename_column"); assertEquals(getOnlyElement(materializedRows.getMaterializedRows()).getField(0), 123); assertUpdate("ALTER TABLE test_rename_column RENAME COLUMN y TO Z"); materializedRows = computeActual("SELECT z FROM test_rename_column"); assertEquals(getOnlyElement(materializedRows.getMaterializedRows()).getField(0), 123); assertUpdate("DROP TABLE test_rename_column"); assertFalse(getQueryRunner().tableExists(getSession(), "test_rename_column")); }
@Test public void testGroupByNan() { MaterializedResult actual = computeActual("SELECT * FROM (VALUES nan(), nan(), nan()) GROUP BY 1"); assertTrue(Double.isNaN((Double) actual.getOnlyValue())); }