@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); }
@Test public void testNonDeterministicTableScanPredicatePushdown() { MaterializedResult materializedResult = computeActual("" + "SELECT COUNT(*)\n" + "FROM (\n" + " SELECT *\n" + " FROM lineitem\n" + " LIMIT 1000\n" + ")\n" + "WHERE rand() > 0.5"); MaterializedRow row = getOnlyElement(materializedResult.getMaterializedRows()); assertEquals(row.getFieldCount(), 1); long count = (Long) row.getField(0); // Technically non-deterministic unit test but has essentially a next to impossible chance of a false positive assertTrue(count > 0 && count < 1000); }
private static MaterializedRow convertToTestTypes(MaterializedRow prestoRow) for (int field = 0; field < prestoRow.getFieldCount(); field++) { Object prestoValue = prestoRow.getField(field); Object convertedValue; if (prestoValue instanceof SqlDate) { ZoneOffset zone = toZoneOffset(((SqlTimeWithTimeZone) prestoValue).getTimeZoneKey()); convertedValue = OffsetTime.of( LocalTime.ofNanoOfDay(MILLISECONDS.toNanos(millisUtc) + SECONDS.toNanos(zone.getTotalSeconds())), return new MaterializedRow(prestoRow.getPrecision(), convertedValues);
@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)); } }
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 testGetPartialRecords() throws Exception List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(session, tableHandle).values()); Map<String, Integer> columnIndex = indexColumns(columnHandles); assertEquals(splits.size(), partitionCount); for (ConnectorSplit split : splits) { HiveSplit hiveSplit = (HiveSplit) split; try (ConnectorPageSource pageSource = pageSourceProvider.createPageSource(transaction.getTransactionHandle(), session, hiveSplit, columnHandles)) { assertPageSourceType(pageSource, fileType); MaterializedResult result = materializeSourceDataStream(session, pageSource, getTypes(columnHandles)); for (MaterializedRow row : result) { rowNumber++; assertEquals(row.getField(columnIndex.get("t_double")), 6.2 + rowNumber); assertEquals(row.getField(columnIndex.get("ds")), ds); assertEquals(row.getField(columnIndex.get("file_format")), fileFormat); assertEquals(row.getField(columnIndex.get("dummy")), dummyPartition);
@Test public void testGetRecordsUnpartitioned() throws Exception List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(session, tableHandle).values()); Map<String, Integer> columnIndex = indexColumns(columnHandles); assertEquals(splits.size(), 1); assertEquals(hiveSplit.getPartitionKeys(), ImmutableList.of()); MaterializedResult result = materializeSourceDataStream(session, pageSource, getTypes(columnHandles)); assertNull(row.getField(columnIndex.get("t_string"))); assertEquals(row.getField(columnIndex.get("t_string")), ""); assertEquals(row.getField(columnIndex.get("t_string")), "unpartitioned"); assertEquals(row.getField(columnIndex.get("t_tinyint")), (byte) (1 + rowNumber));
private static final MaterializedResult CREATE_TABLE_PARTITIONED_DATA = new MaterializedResult( CREATE_TABLE_DATA.getMaterializedRows().stream() .map(row -> new MaterializedRow(row.getPrecision(), newArrayList(concat(row.getFields(), ImmutableList.of("2015-07-0" + row.getField(0)))))) assertNull(row.getField(index)); assertEquals(row.getField(index), ((rowNumber % 19) == 1) ? "" : "test"); assertEquals(row.getField(columnIndex.get("t_tinyint")), 1 + rowNumber); assertEquals(row.getField(columnIndex.get("t_smallint")), 2 + rowNumber); assertEquals(row.getField(columnIndex.get("t_int")), 3 + rowNumber); assertNull(row.getField(index)); assertEquals(row.getField(index), 4 + rowNumber); assertEquals((Double) row.getField(columnIndex.get("t_float")), 5.1 + rowNumber, 0.001); assertEquals(row.getField(columnIndex.get("t_double")), 6.2 + rowNumber); assertNull(row.getField(index)); assertEquals(row.getField(index), (rowNumber % 3) != 0); if (index != null) { if ((rowNumber % 17) == 0) { assertNull(row.getField(index)); assertEquals(row.getField(index), expected);
MaterializedResult.Builder expectedResultBuilder = MaterializedResult.resultBuilder(SESSION, CREATE_TABLE_PARTITIONED_DATA.getTypes()); expectedResultBuilder.rows(CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows()); .orElseThrow(() -> new AssertionError("Table does not exist: " + tableName)); assertEqualsIgnoreOrder(partitionNames, CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows().stream() .map(row -> "ds=" + row.getField(CREATE_TABLE_PARTITIONED_DATA.getTypes().size() - 1)) .collect(toList())); assertFalse(filesAfterInsert.isEmpty()); Constraint<ColumnHandle> constraint = new Constraint<>(tupleDomain, convertToPredicate(tupleDomain)); List<ConnectorTableLayoutResult> tableLayoutResults = metadata.getTableLayouts(session, tableHandle, constraint, Optional.empty()); ConnectorTableLayoutHandle tableLayoutHandle = getOnlyElement(tableLayoutResults).getTableLayout().getHandle(); metadata.metadataDelete(session, tableHandle, tableLayoutHandle); 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); ConnectorMetadata metadata = transaction.getMetadata(); ConnectorTableHandle tableHandle = getTableHandle(metadata, tableName); List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(session, tableHandle).values()); assertEqualsIgnoreOrder(actualAfterDelete2.getMaterializedRows(), ImmutableList.of()); assertTrue(filesAfterDelete.isEmpty());
" ) t(col0, col1) "; assertUpdate(session, createTable, 8); assertTrue(getQueryRunner().tableExists(getSession(), "test_path")); List<String> columnNames = ImmutableList.of("col0", "col1", PATH_COLUMN_NAME); List<ColumnMetadata> columnMetadatas = tableMetadata.getColumns(); assertEquals(columnMetadatas.size(), columnNames.size()); if (columnMetadata.getName().equals(PATH_COLUMN_NAME)) { assertTrue(columnMetadata.isHidden()); for (int i = 0; i < results.getRowCount(); i++) { MaterializedRow row = results.getMaterializedRows().get(i); int col0 = (int) row.getField(0); int col1 = (int) row.getField(1); String pathName = (String) row.getField(2); String parentDirectory = new Path(pathName).getParent().toString(); assertTrue(pathName.length() > 0); assertEquals((int) (col0 % 3), col1); if (partitionPathMap.containsKey(col1)) { assertFalse(getQueryRunner().tableExists(session, "test_path"));
assertEqualsIgnoreOrder(partitionNames, CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows().stream() .map(row -> "ds=" + row.getField(CREATE_TABLE_PARTITIONED_DATA.getTypes().size() - 1)) .collect(toList())); assertEquals(partitions.size(), partitionNames.size()); for (String partitionName : partitionNames) { Partition partition = partitions.get(partitionName).get(); assertEquals(partition.getParameters().get(PRESTO_VERSION_NAME), TEST_SERVER_VERSION); assertEquals(partition.getParameters().get(PRESTO_QUERY_ID_NAME), queryId); assertEqualsIgnoreOrder(result.getMaterializedRows(), CREATE_TABLE_PARTITIONED_DATA.getMaterializedRows()); sink.appendPage(CREATE_TABLE_PARTITIONED_DATA_2ND.toPage()); Collection<Slice> fragments = getFutureValue(sink.finish()); metadata.finishInsert(session, insertTableHandle, fragments, ImmutableList.of());
static class HiveTransaction implements Transaction { private final HiveTransactionManager transactionManager; private final ConnectorTransactionHandle transactionHandle; private boolean closed; public HiveTransaction(HiveTransactionManager transactionManager, HiveMetadata hiveMetadata) { this.transactionManager = requireNonNull(transactionManager, "transactionManager is null"); this.transactionHandle = new HiveTransactionHandle(); transactionManager.put(transactionHandle, hiveMetadata); getMetastore().testOnlyThrowOnCleanupFailures(); } @Override public ConnectorMetadata getMetadata() { return transactionManager.get(transactionHandle); } @Override public SemiTransactionalHiveMetastore getMetastore(String schema) { return getMetastore(); } private SemiTransactionalHiveMetastore getMetastore() { return ((HiveMetadata) transactionManager.get(transactionHandle)).getMetastore();
Object value; value = row.getField(columnIndex.get("t_string")); if (rowNumber % 19 == 0) { assertNull(value); assertEquals(value, ""); assertEquals(row.getField(columnIndex.get("t_tinyint")), (byte) (1 + rowNumber)); assertEquals(row.getField(columnIndex.get("t_smallint")), (short) (2 + rowNumber)); assertEquals(row.getField(columnIndex.get("t_int")), 3 + (int) rowNumber); assertNull(row.getField(columnIndex.get("t_bigint"))); assertEquals(row.getField(columnIndex.get("t_bigint")), 4 + rowNumber); assertEquals((Float) row.getField(columnIndex.get("t_float")), 5.1f + rowNumber, 0.001); assertEquals(row.getField(columnIndex.get("t_double")), 6.2 + rowNumber); assertNull(row.getField(columnIndex.get("t_boolean"))); assertEquals(row.getField(columnIndex.get("t_boolean")), rowNumber % 3 != 0); assertEquals(row.getField(columnIndex.get("ds")), ds); assertEquals(row.getField(columnIndex.get("file_format")), fileFormat); assertEquals(row.getField(columnIndex.get("dummy")), dummyPartition);
@SuppressWarnings("ConstantConditions") @Test public void testBucketedTableBigintBoolean() throws Exception List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(session, tableHandle).values()); Map<String, Integer> columnIndex = indexColumns(columnHandles); if (testString.equals(row.getField(columnIndex.get("t_string"))) && testBigint.equals(row.getField(columnIndex.get("t_bigint"))) && testBoolean.equals(row.getField(columnIndex.get("t_boolean")))) { rowFound = true; break; assertTrue(rowFound);
@Test public void testRowNumber() MaterializedResult expected = resultBuilder(TEST_SESSION, INTEGER, VARCHAR, BIGINT) .row(1, "O", 1L) .row(2, "O", 2L) .row(34, "O", 10L) .build(); MaterializedResult expectedWithNulls = resultBuilder(TEST_SESSION, BIGINT, VARCHAR, BIGINT) .row(1L, null, 1L) .row(3L, "F", 2L) assertWindowQuery("row_number() OVER (ORDER BY orderkey)", expected); assertEquals(executeWindowQueryWithNulls("row_number() OVER ()").getMaterializedRows().stream() .map(row -> row.getField(2)) .collect(Collectors.toList()), ImmutableList.of(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L)); assertWindowQueryWithNulls("row_number() OVER (ORDER BY orderkey, orderstatus)", expectedWithNulls);
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 testSelectAllTypes() { createBlackholeAllTypesTable(); MaterializedResult rows = queryRunner.execute("SELECT * FROM blackhole_all_types"); assertEquals(rows.getRowCount(), 1); MaterializedRow row = Iterables.getOnlyElement(rows); assertEquals(row.getFieldCount(), 13); assertEquals(row.getField(0), "**********"); assertEquals(row.getField(1), 0L); assertEquals(row.getField(2), 0); assertEquals(row.getField(3), (short) 0); assertEquals(row.getField(4), (byte) 0); assertEquals(row.getField(5), 0.0f); assertEquals(row.getField(6), 0.0); assertEquals(row.getField(7), false); assertEquals(row.getField(8), LocalDate.ofEpochDay(0)); assertEquals(row.getField(9), LocalDateTime.of(1969, 12, 31, 13, 0, 0)); // TODO #7122 should be 1970-01-01 00:00:00 assertEquals(row.getField(10), "****************".getBytes()); assertEquals(row.getField(11), new BigDecimal("0.00")); assertEquals(row.getField(12), new BigDecimal("00000000000000000000.0000000000")); dropBlackholeAllTypesTable(); }
@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")); }
int rowCount = result.getRowCount(); assertEquals(rowCount, 9); assertEquals(result.getTypes(), ImmutableList.of( createUnboundedVarcharType(), uuidType, createUnboundedVarcharType())); List<MaterializedRow> sortedRows = result.getMaterializedRows().stream() .sorted((o1, o2) -> o1.getField(1).toString().compareTo(o2.getField(1).toString())) .collect(toList()); assertEquals(sortedRows.get(rowNumber - 1), new MaterializedRow(DEFAULT_PRECISION, "key " + rowNumber, String.format("00000000-0000-0000-0000-%012d", rowNumber),
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); } }