public Stream<Object> getOnlyColumn() { checkState(types.size() == 1, "result set must have exactly one column"); return rows.stream() .map(row -> row.getField(0)); }
@Test public void testNonDeterministicProjection() { MaterializedResult materializedResult = computeActual("SELECT r, r + 1 FROM (SELECT rand(100) r FROM orders) LIMIT 10"); assertEquals(materializedResult.getRowCount(), 10); for (MaterializedRow materializedRow : materializedResult) { assertEquals(materializedRow.getFieldCount(), 2); assertEquals(((Number) materializedRow.getField(0)).intValue() + 1, materializedRow.getField(1)); } }
public Object getOnlyValue() { checkState(rows.size() == 1, "result set must have exactly one row"); checkState(types.size() == 1, "result set must have exactly one column"); return rows.get(0).getField(0); }
private static void appendToPage(PageBuilder pageBuilder, MaterializedRow row) { for (int field = 0; field < row.getFieldCount(); field++) { Type type = pageBuilder.getType(field); Object value = row.getField(field); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(field); writeValue(type, blockBuilder, value); } pageBuilder.declarePosition(); }
@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); }
private void assertThatQueryReturnsValue(String sql, Object expected, Session session) { MaterializedResult rows = session == null ? queryRunner.execute(sql) : queryRunner.execute(session, sql); MaterializedRow materializedRow = Iterables.getOnlyElement(rows); int fieldCount = materializedRow.getFieldCount(); assertTrue(fieldCount == 1, format("Expected only one column, but got '%d'", fieldCount)); Object value = materializedRow.getField(0); assertEquals(value, expected); assertTrue(Iterables.getOnlyElement(rows).getFieldCount() == 1); } }
@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); }
private void assertThatQueryReturnsValue(@Language("SQL") String sql, Object expected) { MaterializedResult rows = queryRunner.execute(sql); MaterializedRow materializedRow = Iterables.getOnlyElement(rows); int fieldCount = materializedRow.getFieldCount(); assertTrue(fieldCount == 1, format("Expected only one column, but got '%d'", fieldCount)); Object value = materializedRow.getField(0); assertEquals(value, expected); assertTrue(Iterables.getOnlyElement(rows).getFieldCount() == 1); } }
@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); }
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 testSpecialFloatingPointValues() { MaterializedResult actual = computeActual("SELECT nan(), infinity(), -infinity()"); MaterializedRow row = getOnlyElement(actual.getMaterializedRows()); assertEquals(row.getField(0), Double.NaN); assertEquals(row.getField(1), Double.POSITIVE_INFINITY); assertEquals(row.getField(2), Double.NEGATIVE_INFINITY); }
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)); }
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 testResetSession() { MaterializedResult result = computeActual(getSession(), "RESET SESSION test_string"); assertTrue((Boolean) getOnlyElement(result).getField(0)); assertEquals(result.getResetSessionProperties(), ImmutableSet.of("test_string")); result = computeActual(getSession(), format("RESET SESSION %s.connector_string", TESTING_CATALOG)); assertTrue((Boolean) getOnlyElement(result).getField(0)); assertEquals(result.getResetSessionProperties(), ImmutableSet.of(TESTING_CATALOG + ".connector_string")); }
@Test public void testCountOnInternalTables() { List<MaterializedRow> rows = computeActual("SELECT count(*) FROM system.runtime.nodes").getMaterializedRows(); assertEquals(((Long) rows.get(0).getField(0)).longValue(), getNodeCount()); }
@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 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)); }
@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")); }
public static void copyTable(QueryRunner queryRunner, QualifiedObjectName table, Session session) { long start = System.nanoTime(); log.info("Running import for %s", table.getObjectName()); @Language("SQL") String sql = format("CREATE TABLE %s AS SELECT * FROM %s", table.getObjectName(), table); long rows = (Long) queryRunner.execute(session, sql).getMaterializedRows().get(0).getField(0); log.info("Imported %s rows for %s in %s", rows, table.getObjectName(), nanosSince(start).convertToMostSuccinctTimeUnit()); } }