public static boolean tableExists(Metadata metadata, Session session, String table) { if (!session.getCatalog().isPresent() || !session.getSchema().isPresent()) { return false; } QualifiedObjectName name = new QualifiedObjectName(session.getCatalog().get(), session.getSchema().get(), table); return metadata.getTableHandle(session, name).isPresent(); }
@Test public void testShowSchemas() { MaterializedResult result = computeActual("SHOW SCHEMAS"); assertTrue(result.getOnlyColumnAsSet().containsAll(ImmutableSet.of(getSession().getSchema().get(), INFORMATION_SCHEMA))); }
@Override public String getSchema() { return session.getSchema().orElse(null); }
@Test public void testShowSchemasFrom() { MaterializedResult result = computeActual(format("SHOW SCHEMAS FROM %s", getSession().getCatalog().get())); assertTrue(result.getOnlyColumnAsSet().containsAll(ImmutableSet.of(getSession().getSchema().get(), INFORMATION_SCHEMA))); }
public static QualifiedObjectName createQualifiedObjectName(Session session, Node node, QualifiedName name) { requireNonNull(session, "session is null"); requireNonNull(name, "name is null"); if (name.getParts().size() > 3) { throw new PrestoException(SYNTAX_ERROR, format("Too many dots in table name: %s", name)); } List<String> parts = Lists.reverse(name.getParts()); String objectName = parts.get(0); String schemaName = (parts.size() > 1) ? parts.get(1) : session.getSchema().orElseThrow(() -> new SemanticException(SCHEMA_NOT_SPECIFIED, node, "Schema must be specified when session schema is not set")); String catalogName = (parts.size() > 2) ? parts.get(2) : session.getCatalog().orElseThrow(() -> new SemanticException(CATALOG_NOT_SPECIFIED, node, "Catalog must be specified when session catalog is not set")); return new QualifiedObjectName(catalogName, schemaName, objectName); }
protected final List<Type> getColumnTypes(String tableName, String... columnNames) { checkState(session.getCatalog().isPresent(), "catalog not set"); checkState(session.getSchema().isPresent(), "schema not set"); // look up the table Metadata metadata = localQueryRunner.getMetadata(); QualifiedObjectName qualifiedTableName = new QualifiedObjectName(session.getCatalog().get(), session.getSchema().get(), tableName); TableHandle tableHandle = metadata.getTableHandle(session, qualifiedTableName) .orElseThrow(() -> new IllegalArgumentException(format("Table %s does not exist", qualifiedTableName))); Map<String, ColumnHandle> allColumnHandles = metadata.getColumnHandles(session, tableHandle); return Arrays.stream(columnNames) .map(allColumnHandles::get) .map(columnHandle -> metadata.getColumnMetadata(session, tableHandle, columnHandle).getType()) .collect(toImmutableList()); }
@Test public void testShowTablesFrom() { Set<String> expectedTables = ImmutableSet.copyOf(transform(TpchTable.getTables(), TpchTable::getTableName)); String catalog = getSession().getCatalog().get(); String schema = getSession().getSchema().get(); MaterializedResult result = computeActual("SHOW TABLES FROM " + schema); assertTrue(result.getOnlyColumnAsSet().containsAll(expectedTables)); result = computeActual("SHOW TABLES FROM " + catalog + "." + schema); assertTrue(result.getOnlyColumnAsSet().containsAll(expectedTables)); assertQueryFails("SHOW TABLES FROM UNKNOWN", "line 1:1: Schema 'unknown' does not exist"); assertQueryFails("SHOW TABLES FROM UNKNOWNCATALOG.UNKNOWNSCHEMA", "line 1:1: Catalog 'unknowncatalog' does not exist"); }
@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); }
@Test public void testDescribeOutputNamedAndUnnamed() { Session session = Session.builder(getSession()) .addPreparedStatement("my_query", "SELECT 1, name, regionkey AS my_alias FROM nation") .build(); MaterializedResult actual = computeActual(session, "DESCRIBE OUTPUT my_query"); MaterializedResult expected = resultBuilder(session, VARCHAR, VARCHAR, VARCHAR, VARCHAR, VARCHAR, BIGINT, BOOLEAN) .row("_col0", "", "", "", "integer", 4, false) .row("name", session.getCatalog().get(), session.getSchema().get(), "nation", "varchar(25)", 0, false) .row("my_alias", session.getCatalog().get(), session.getSchema().get(), "nation", "bigint", 8, true) .build(); assertEqualsIgnoreOrder(actual, expected); }
@Test public void testSelectInformationSchemaTables() { String catalog = getSession().getCatalog().get(); String schema = getSession().getSchema().get(); String schemaPattern = schema.replaceAll("^.", "_"); assertQuery("SELECT table_name FROM information_schema.tables WHERE table_schema = '" + schema + "' AND table_name = 'orders'", "VALUES 'orders'"); assertQuery("SELECT table_name FROM information_schema.tables WHERE table_schema LIKE '" + schema + "' AND table_name LIKE '%rders'", "VALUES 'orders'"); assertQuery("SELECT table_name FROM information_schema.tables WHERE table_schema LIKE '" + schemaPattern + "' AND table_name LIKE '%rders'", "VALUES 'orders'"); assertQuery( "SELECT table_name FROM information_schema.tables " + "WHERE table_catalog = '" + catalog + "' AND table_schema LIKE '" + schema + "' AND table_name LIKE '%orders'", "VALUES 'orders'"); assertQuery("SELECT table_name FROM information_schema.tables WHERE table_catalog = 'something_else'", "SELECT '' WHERE false"); }
@Test public void testView() { skipTestUnless(supportsViews()); @Language("SQL") String query = "SELECT orderkey, orderstatus, totalprice / 2 half FROM orders"; assertUpdate("CREATE VIEW test_view AS SELECT 123 x"); assertUpdate("CREATE OR REPLACE VIEW test_view AS " + query); assertQuery("SELECT * FROM test_view", query); assertQuery( "SELECT * FROM test_view a JOIN test_view b on a.orderkey = b.orderkey", format("SELECT * FROM (%s) a JOIN (%s) b ON a.orderkey = b.orderkey", query, query)); assertQuery("WITH orders AS (SELECT * FROM orders LIMIT 0) SELECT * FROM test_view", query); String name = format("%s.%s.test_view", getSession().getCatalog().get(), getSession().getSchema().get()); assertQuery("SELECT * FROM " + name, query); assertUpdate("DROP VIEW test_view"); }
private String getAvroCreateTableSql(String tableName, String schemaFile) { return format("CREATE TABLE %s.%s.%s (\n" + " dummy_col varchar,\n" + " another_dummy_col varchar\n" + ")\n" + "WITH (\n" + " avro_schema_url = '%s',\n" + " format = 'AVRO'\n" + ")", getSession().getCatalog().get(), getSession().getSchema().get(), tableName, schemaFile); }
@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 testCreateOrcTableWithSchemaUrl() throws Exception { @Language("SQL") String createTableSql = format("" + "CREATE TABLE %s.%s.test_orc (\n" + " dummy_col varchar\n" + ")\n" + "WITH (\n" + " avro_schema_url = 'dummy.avsc',\n" + " format = 'ORC'\n" + ")", getSession().getCatalog().get(), getSession().getSchema().get()); assertQueryFails(createTableSql, "Cannot specify avro_schema_url table property for storage format: ORC"); }
@Override public ListenableFuture<?> execute(CreateView statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { Session session = stateMachine.getSession(); QualifiedObjectName name = createQualifiedObjectName(session, statement, statement.getName()); accessControl.checkCanCreateView(session.getRequiredTransactionId(), session.getIdentity(), name); String sql = getFormattedSql(statement.getQuery(), sqlParser, Optional.of(parameters)); Analysis analysis = analyzeStatement(statement, session, metadata, accessControl, parameters, stateMachine.getWarningCollector()); List<ViewColumn> columns = analysis.getOutputDescriptor(statement.getQuery()) .getVisibleFields().stream() .map(field -> new ViewColumn(field.getName().get(), field.getType())) .collect(toImmutableList()); String data = codec.toJson(new ViewDefinition(sql, session.getCatalog(), session.getSchema(), columns, Optional.of(session.getUser()))); metadata.createView(session, name, data, statement.isReplace()); return immediateFuture(null); }
@Test public void testBucketedCatalog() { String bucketedCatalog = bucketedSession.getCatalog().get(); String bucketedSchema = bucketedSession.getSchema().get(); TableMetadata ordersTableMetadata = getTableMetadata(bucketedCatalog, bucketedSchema, "orders"); assertEquals(ordersTableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("custkey")); assertEquals(ordersTableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); TableMetadata customerTableMetadata = getTableMetadata(bucketedCatalog, bucketedSchema, "customer"); assertEquals(customerTableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("custkey")); assertEquals(customerTableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); }
private Session getSession(String user) { return testSessionBuilder() .setCatalog(queryRunner.getDefaultSession().getCatalog().get()) .setSchema(queryRunner.getDefaultSession().getSchema().get()) .setIdentity(new Identity(user, Optional.empty())).build(); } }
private static void assertEqualSessionsWithoutTransactionId(Session actual, Session expected) { assertEquals(actual.getQueryId(), expected.getQueryId()); assertEquals(actual.getIdentity(), expected.getIdentity()); assertEquals(actual.getSource(), expected.getSource()); assertEquals(actual.getCatalog(), expected.getCatalog()); assertEquals(actual.getSchema(), expected.getSchema()); assertEquals(actual.getTimeZoneKey(), expected.getTimeZoneKey()); assertEquals(actual.getLocale(), expected.getLocale()); assertEquals(actual.getRemoteUserAddress(), expected.getRemoteUserAddress()); assertEquals(actual.getUserAgent(), expected.getUserAgent()); assertEquals(actual.getStartTime(), expected.getStartTime()); assertEquals(actual.getSystemProperties(), expected.getSystemProperties()); assertEquals(actual.getConnectorProperties(), expected.getConnectorProperties()); } }
private Session getSession(String user) { return testSessionBuilder() .setCatalog(queryRunner.getDefaultSession().getCatalog().get()) .setSchema(queryRunner.getDefaultSession().getSchema().get()) .setIdentity(new Identity(user, Optional.empty())).build(); } }