Refine search
@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()); }
@Override public void close() { runner.close(); }
@Override public void execute(String sql) { try { queryRunner.execute(queryRunner.getDefaultSession(), sql); } catch (Throwable e) { throw new RuntimeException("Error executing sql:\n" + sql, e); } } }
protected void assertAccessAllowed(Session session, @Language("SQL") String sql, TestingPrivilege... deniedPrivileges) { executeExclusively(() -> { try { queryRunner.getAccessControl().deny(deniedPrivileges); queryRunner.execute(session, sql); } finally { queryRunner.getAccessControl().reset(); } }); }
private static List<OptionalDouble> getEstimatedValues(List<Metric> metrics, String query, QueryRunner runner) { return transaction(runner.getTransactionManager(), runner.getAccessControl()) .singleStatement() .execute(runner.getDefaultSession(), (Session session) -> getEstimatedValuesInternal(metrics, query, runner, session)); }
@Test public void testCharTrailingSpace() throws Exception { execute("CREATE TABLE tpch.char_trailing_space (x char(10))"); assertUpdate("INSERT INTO char_trailing_space VALUES ('test')", 1); assertQuery("SELECT * FROM char_trailing_space WHERE x = char 'test'", "VALUES 'test'"); assertQuery("SELECT * FROM char_trailing_space WHERE x = char 'test '", "VALUES 'test'"); assertQuery("SELECT * FROM char_trailing_space WHERE x = char 'test '", "VALUES 'test'"); assertEquals(getQueryRunner().execute("SELECT * FROM char_trailing_space WHERE x = char ' test'").getRowCount(), 0); Map<String, String> properties = ImmutableMap.of("deprecated.legacy-char-to-varchar-coercion", "true"); Map<String, String> connectorProperties = ImmutableMap.of("connection-url", postgreSqlServer.getJdbcUrl()); try (QueryRunner queryRunner = new DistributedQueryRunner(getSession(), 3, properties);) { queryRunner.installPlugin(new PostgreSqlPlugin()); queryRunner.createCatalog("postgresql", "postgresql", connectorProperties); assertEquals(queryRunner.execute("SELECT * FROM char_trailing_space WHERE x = char 'test'").getRowCount(), 0); assertEquals(queryRunner.execute("SELECT * FROM char_trailing_space WHERE x = char 'test '").getRowCount(), 0); assertEquals(queryRunner.execute("SELECT * FROM char_trailing_space WHERE x = char 'test '").getRowCount(), 0); MaterializedResult result = queryRunner.execute("SELECT * FROM char_trailing_space WHERE x = char 'test '"); assertEquals(result.getRowCount(), 1); assertEquals(result.getMaterializedRows().get(0).getField(0), "test "); } assertUpdate("DROP TABLE char_trailing_space"); }
@Test public void testDropTable() { assertUpdate("CREATE TABLE test_drop AS SELECT 123 x", 1); assertTrue(getQueryRunner().tableExists(getSession(), "test_drop")); assertUpdate("DROP TABLE test_drop"); assertFalse(getQueryRunner().tableExists(getSession(), "test_drop")); }
@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 testRenameTable() { assertUpdate("CREATE TABLE test_rename AS SELECT 123 x", 1); assertUpdate("ALTER TABLE test_rename RENAME TO test_rename_new"); MaterializedResult materializedRows = computeActual("SELECT x FROM test_rename_new"); assertEquals(getOnlyElement(materializedRows.getMaterializedRows()).getField(0), 123); // provide new table name in uppercase assertUpdate("ALTER TABLE test_rename_new RENAME TO TEST_RENAME"); materializedRows = computeActual("SELECT x FROM test_rename"); assertEquals(getOnlyElement(materializedRows.getMaterializedRows()).getField(0), 123); assertUpdate("DROP TABLE test_rename"); assertFalse(getQueryRunner().tableExists(getSession(), "test_rename")); assertFalse(getQueryRunner().tableExists(getSession(), "test_rename_new")); }
private void testPathHiddenColumn(Session session, HiveStorageFormat storageFormat) @Language("SQL") String createTable = "CREATE TABLE test_path " + "WITH (" + "format = '" + storageFormat + "'," + " ) t(col0, col1) "; assertUpdate(session, createTable, 8); assertTrue(getQueryRunner().tableExists(getSession(), "test_path")); 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"));
@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 testViews() throws Exception { execute("CREATE OR REPLACE VIEW tpch.test_view AS SELECT * FROM tpch.orders"); assertTrue(getQueryRunner().tableExists(getSession(), "test_view")); assertQuery("SELECT orderkey FROM test_view", "SELECT orderkey FROM orders"); execute("DROP VIEW IF EXISTS tpch.test_view"); }
@Test public void testCreateSchema() { assertEquals(queryRunner.execute("SHOW SCHEMAS FROM blackhole").getRowCount(), 2); queryRunner.execute("CREATE SCHEMA blackhole.test"); assertEquals(queryRunner.execute("SHOW SCHEMAS FROM blackhole").getRowCount(), 3); }
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 testLegacyLogFunctionEnabled() { try (QueryRunner queryRunner = createQueryRunner(true)) { MaterializedResult result = queryRunner.execute(QUERY); assertEquals(result.getOnlyValue(), 2.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 testMetadataDelete() @Language("SQL") String createTable = "" + "CREATE TABLE test_metadata_delete " + "(" + getQueryRunner().execute("DELETE FROM test_metadata_delete WHERE ORDER_KEY=1"); fail("expected exception"); assertFalse(getQueryRunner().tableExists(getSession(), "test_metadata_delete"));
@Test public void testDropTableIfExists() { assertFalse(getQueryRunner().tableExists(getSession(), "test_drop_if_exists")); assertUpdate("DROP TABLE IF EXISTS test_drop_if_exists"); assertFalse(getQueryRunner().tableExists(getSession(), "test_drop_if_exists")); }
private void doTestCreateTableWithDecimalColumn(TestDec dec) { String tableName = dec.getTableName(); String dropTable = "DROP TABLE IF EXISTS " + tableName; String createTable = "CREATE TABLE " + tableName + " (\n"; createTable += " id INT WITH (primary_key=true),\n"; createTable += " dec DECIMAL(" + dec.precision + "," + dec.scale + ")\n"; createTable += ") WITH (\n" + " partition_by_hash_columns = ARRAY['id'],\n" + " partition_by_hash_buckets = 2\n" + ")"; queryRunner.execute(dropTable); queryRunner.execute(createTable); String fullPrecisionValue = "1234567890.1234567890123456789012345678"; int maxScale = dec.precision - 10; int valuePrecision = dec.precision - maxScale + Math.min(maxScale, dec.scale); String insertValue = fullPrecisionValue.substring(0, valuePrecision + 1); queryRunner.execute("INSERT INTO " + tableName + " VALUES(1, DECIMAL '" + insertValue + "')"); MaterializedResult result = queryRunner.execute("SELECT id, CAST((dec - (DECIMAL '" + insertValue + "')) as DOUBLE) FROM " + tableName); assertEquals(result.getRowCount(), 1); Object obj = result.getMaterializedRows().get(0).getField(1); assertTrue(obj instanceof Double); Double actual = (Double) obj; assertEquals(0, actual, 0.3 * Math.pow(0.1, dec.scale), "p=" + dec.precision + ",s=" + dec.scale + " => " + actual + ",insert = " + insertValue); }