@Test public void testTransactionsTable() { List<MaterializedRow> result = computeActual("SELECT * FROM system.runtime.transactions").getMaterializedRows(); assertTrue(result.size() >= 1); // At least one row for the current transaction. }
@Test public void testP4ApproxSetVarchar() { MaterializedResult actual = computeActual("SELECT cardinality(cast(approx_set(CAST(custkey AS VARCHAR)) AS P4HYPERLOGLOG)) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), BIGINT) .row(1024L) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testNodeRoster() { List<MaterializedRow> result = computeActual("SELECT * FROM system.runtime.nodes").getMaterializedRows(); assertEquals(result.size(), getNodeCount()); }
@Test public void testRowNumberMultipleFilters() { MaterializedResult actual = computeActual("" + "SELECT * FROM (" + " SELECT a, row_number() OVER (PARTITION BY a ORDER BY a) rn\n" + " FROM (VALUES (1), (1), (1), (2), (2), (3)) t (a)) t " + "WHERE rn < 3 AND rn % 2 = 0 AND a = 2 LIMIT 2"); MaterializedResult expected = resultBuilder(getSession(), BIGINT, BIGINT) .row(2, 2L) .build(); assertEqualsIgnoreOrder(actual.getMaterializedRows(), expected.getMaterializedRows()); }
MaterializedResult.Builder resultBuilder = MaterializedResult.resultBuilder(SESSION, CREATE_TABLE_PARTITIONED_DATA.getTypes()); for (int i = 0; i < 3; i++) { assertEqualsIgnoreOrder(partitionNames, CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows().stream() .map(row -> "ds=" + row.getField(CREATE_TABLE_PARTITIONED_DATA.getTypes().size() - 1)) .collect(toList())); resultBuilder.rows(CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows()); MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.of(storageFormat)); assertEqualsIgnoreOrder(result.getMaterializedRows(), resultBuilder.build().getMaterializedRows()); assertEqualsIgnoreOrder(result.getMaterializedRows(), resultBuilder.build().getMaterializedRows());
private void verifyPartitionedBucketedTableAsFewRows(HiveStorageFormat storageFormat, String tableName) { TableMetadata tableMetadata = getTableMetadata(catalog, TPCH_SCHEMA, tableName); assertEquals(tableMetadata.getMetadata().getProperties().get(STORAGE_FORMAT_PROPERTY), storageFormat); assertEquals(tableMetadata.getMetadata().getProperties().get(PARTITIONED_BY_PROPERTY), ImmutableList.of("partition_key")); assertEquals(tableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("bucket_key")); assertEquals(tableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); List<?> partitions = getPartitions(tableName); assertEquals(partitions.size(), 3); MaterializedResult actual = computeActual("SELECT * from " + tableName); MaterializedResult expected = resultBuilder(getSession(), canonicalizeType(createUnboundedVarcharType()), canonicalizeType(createUnboundedVarcharType()), canonicalizeType(createUnboundedVarcharType())) .row("a", "b", "c") .row("aa", "bb", "cc") .row("aaa", "bbb", "ccc") .build(); assertEqualsIgnoreOrder(actual.getMaterializedRows(), expected.getMaterializedRows()); }
private void assertOneNotNullResult(@Language("SQL") 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 testMergeHyperLogLog() { MaterializedResult actual = computeActual("SELECT cardinality(merge(create_hll(custkey))) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), BIGINT) .row(1002L) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@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)); }
@Test public void testApproximateCountDistinctGroupBy() { MaterializedResult actual = computeActual("SELECT orderstatus, approx_distinct(custkey) FROM orders GROUP BY orderstatus"); MaterializedResult expected = resultBuilder(getSession(), actual.getTypes()) .row("O", 990L) .row("F", 990L) .row("P", 303L) .build(); assertEqualsIgnoreOrder(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@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); }
MaterializedResult.Builder expectedResultBuilder = MaterializedResult.resultBuilder(SESSION, CREATE_TABLE_PARTITIONED_DATA.getTypes()); expectedResultBuilder.rows(CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows()); assertEqualsIgnoreOrder(partitionNames, CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows().stream() .map(row -> "ds=" + row.getField(CREATE_TABLE_PARTITIONED_DATA.getTypes().size() - 1)) .collect(toList())); List<ColumnHandle> columnHandles = filterNonHiddenColumnHandles(metadata.getColumnHandles(session, tableHandle).values()); MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.of(storageFormat)); assertEqualsIgnoreOrder(result.getMaterializedRows(), expectedResultBuilder.build().getMaterializedRows()); ImmutableList<MaterializedRow> expectedRows = expectedResultBuilder.build().getMaterializedRows().stream() .filter(row -> !"2015-07-03".equals(row.getField(dsColumnOrdinalPosition))) .collect(toImmutableList()); MaterializedResult actualAfterDelete = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.of(storageFormat)); assertEqualsIgnoreOrder(actualAfterDelete.getMaterializedRows(), expectedRows); assertEqualsIgnoreOrder(actualAfterDelete2.getMaterializedRows(), ImmutableList.of());
private void assertQueryResult(@Language("SQL") String sql, Object... expected) { MaterializedResult rows = computeActual(sql); assertEquals(rows.getRowCount(), expected.length); for (int i = 0; i < expected.length; i++) { MaterializedRow materializedRow = rows.getMaterializedRows().get(i); int fieldCount = materializedRow.getFieldCount(); assertTrue(fieldCount == 1, format("Expected only one column, but got '%d'", fieldCount)); Object value = materializedRow.getField(0); assertEquals(value, expected[i]); assertTrue(materializedRow.getFieldCount() == 1); } } }
@Test public void testP4ApproxSetBigint() { MaterializedResult actual = computeActual("SELECT cardinality(cast(approx_set(custkey) AS P4HYPERLOGLOG)) FROM orders"); MaterializedResult expected = resultBuilder(getSession(), BIGINT) .row(1002L) .build(); assertEquals(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testValuesWithTimestamp() { MaterializedResult actual = computeActual("VALUES (current_timestamp, now())"); List<MaterializedRow> rows = actual.getMaterializedRows(); assertEquals(rows.size(), 1); MaterializedRow row = rows.get(0); assertEquals(row.getField(0), row.getField(1)); }
@Test public void testApproximateCountDistinctGroupByWithStandardError() { MaterializedResult actual = computeActual("SELECT orderstatus, approx_distinct(custkey, 0.023) FROM orders GROUP BY orderstatus"); MaterializedResult expected = resultBuilder(getSession(), actual.getTypes()) .row("O", 990L) .row("F", 990L) .row("P", 303L) .build(); assertEqualsIgnoreOrder(actual.getMaterializedRows(), expected.getMaterializedRows()); }
@Test public void testGroupByNanRow() { MaterializedResult actual = computeActual("SELECT a, b, c FROM (VALUES ROW(nan(), 1, 2), ROW(nan(), 1, 2)) t(a, b, c) GROUP BY 1, 2, 3"); List<MaterializedRow> actualRows = actual.getMaterializedRows(); assertEquals(actualRows.size(), 1); assertTrue(Double.isNaN((Double) actualRows.get(0).getField(0))); assertEquals(actualRows.get(0).getField(1), 1); assertEquals(actualRows.get(0).getField(2), 2); }
MaterializedResult.Builder resultBuilder = MaterializedResult.resultBuilder(SESSION, CREATE_TABLE_DATA.getTypes()); for (int i = 0; i < 3; i++) { insertData(tableName, CREATE_TABLE_DATA); resultBuilder.rows(CREATE_TABLE_DATA.getMaterializedRows()); MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.empty()); assertEqualsIgnoreOrder(result.getMaterializedRows(), resultBuilder.build().getMaterializedRows()); List<ColumnHandle> columnHandles = filterNonHiddenColumnHandles(metadata.getColumnHandles(session, tableHandle).values()); MaterializedResult result = readTable(transaction, tableHandle, columnHandles, session, TupleDomain.all(), OptionalInt.empty(), Optional.empty()); assertEqualsIgnoreOrder(result.getMaterializedRows(), resultBuilder.build().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 testValuesWithNonTrivialType() { MaterializedResult actual = computeActual("VALUES (0E0/0E0, 1E0/0E0, -1E0/0E0)"); List<MaterializedRow> rows = actual.getMaterializedRows(); assertEquals(rows.size(), 1); MaterializedRow row = rows.get(0); assertTrue(((Double) row.getField(0)).isNaN()); assertEquals(row.getField(1), Double.POSITIVE_INFINITY); assertEquals(row.getField(2), Double.NEGATIVE_INFINITY); }