public <T> T inTransaction(Session session, Function<Session, T> transactionSessionConsumer) { return transaction(transactionManager, accessControl) .singleStatement() .execute(session, transactionSessionConsumer); }
@Override public boolean tableExists(Session session, String table) { lock.readLock().lock(); try { return transaction(transactionManager, accessControl) .readOnly() .execute(session, transactionSession -> { return MetadataUtil.tableExists(getMetadata(), transactionSession, table); }); } finally { lock.readLock().unlock(); } }
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)); }
public boolean tableExists(Session session, String table) { return transaction(prestoServer.getTransactionManager(), prestoServer.getAccessControl()) .readOnly() .execute(session, transactionSession -> { return MetadataUtil.tableExists(prestoServer.getMetadata(), transactionSession, table); }); }
private <T> T inTransaction(Function<Session, T> transactionSessionConsumer) { return transaction(transactionManager, accessControl) .singleStatement() .execute(session, session -> { // metadata.getCatalogHandle() registers the catalog for the transaction session.getCatalog().ifPresent(catalog -> metadata.getCatalogHandle(session, catalog)); return transactionSessionConsumer.apply(session); }); }
public String getGraphvizExplainPlan(String query, ExplainType.Type planType) { QueryExplainer explainer = getQueryExplainer(); return transaction(queryRunner.getTransactionManager(), queryRunner.getAccessControl()) .singleStatement() .execute(queryRunner.getDefaultSession(), session -> { return explainer.getGraphvizPlan(session, sqlParser.createStatement(query, createParsingOptions(session)), planType, emptyList(), WarningCollector.NOOP); }); }
@Test public void testCatalogOperations() { TransactionManager transactionManager = createTestTransactionManager(); AccessControlManager accessControlManager = newAccessControlManager(transactionManager, "catalog.json"); transaction(transactionManager, accessControlManager) .execute(transactionId -> { assertEquals(accessControlManager.filterCatalogs(admin, allCatalogs), allCatalogs); Set<String> aliceCatalogs = ImmutableSet.of("open-to-all", "alice-catalog", "all-allowed"); assertEquals(accessControlManager.filterCatalogs(alice, allCatalogs), aliceCatalogs); Set<String> bobCatalogs = ImmutableSet.of("open-to-all", "all-allowed"); assertEquals(accessControlManager.filterCatalogs(bob, allCatalogs), bobCatalogs); Set<String> nonAsciiUserCatalogs = ImmutableSet.of("open-to-all", "all-allowed", "\u0200\u0200\u0200"); assertEquals(accessControlManager.filterCatalogs(nonAsciiUser, allCatalogs), nonAsciiUserCatalogs); }); }
public String getExplainPlan(String query, ExplainType.Type planType) { QueryExplainer explainer = getQueryExplainer(); return transaction(queryRunner.getTransactionManager(), queryRunner.getAccessControl()) .singleStatement() .execute(queryRunner.getDefaultSession(), session -> { return explainer.getPlan(session, sqlParser.createStatement(query, createParsingOptions(session)), planType, emptyList(), WarningCollector.NOOP); }); }
@Test public void testUpperCaseSchemaIsChangedToLowerCase() { TransactionBuilder.transaction(queryRunner.getTransactionManager(), queryRunner.getAccessControl()) .execute( TEST_SESSION, transactionSession -> { List<String> expectedSchemas = ImmutableList.of("information_schema", "upper_case_schema"); assertEquals(queryRunner.getMetadata().listSchemaNames(transactionSession, "upper_case_schema_catalog"), expectedSchemas); return null; }); } }
public List<QualifiedObjectName> listTables(Session session, String catalog, String schema) { return transaction(prestoServer.getTransactionManager(), prestoServer.getAccessControl()) .readOnly() .execute(session, transactionSession -> { return prestoServer.getMetadata().listTables(transactionSession, new QualifiedTablePrefix(catalog, schema)); }); }
private void inSetupTransaction(Consumer<Session> consumer) { transaction(transactionManager, accessControl) .singleStatement() .readUncommitted() .execute(SETUP_SESSION, consumer); }
private <T> T inTransaction(Function<Session, T> transactionSessionConsumer) { return transaction(transactionManager, new AllowAllAccessControl()) .singleStatement() .execute(session, session -> { // metadata.getCatalogHandle() registers the catalog for the transaction session.getCatalog().ifPresent(catalog -> metadata.getCatalogHandle(session, catalog)); return transactionSessionConsumer.apply(session); }); } }
@Test public void testNoCatalogAccessControl() { TransactionManager transactionManager = createTestTransactionManager(); AccessControlManager accessControlManager = new AccessControlManager(transactionManager); TestSystemAccessControlFactory accessControlFactory = new TestSystemAccessControlFactory("test"); accessControlManager.addSystemAccessControlFactory(accessControlFactory); accessControlManager.setSystemAccessControl("test", ImmutableMap.of()); transaction(transactionManager, accessControlManager) .execute(transactionId -> { accessControlManager.checkCanSelectFromColumns(transactionId, new Identity(USER_NAME, Optional.of(PRINCIPAL)), new QualifiedObjectName("catalog", "schema", "table"), ImmutableSet.of("column")); }); }
@Test public void testTopicExists() { QualifiedObjectName name = new QualifiedObjectName("kafka", "default", topicName); transaction(queryRunner.getTransactionManager(), new AllowAllAccessControl()) .singleStatement() .execute(SESSION, session -> { Optional<TableHandle> handle = queryRunner.getServer().getMetadata().getTableHandle(session, name); assertTrue(handle.isPresent()); }); }
@Test public void testTableExists() { QualifiedObjectName name = new QualifiedObjectName("redis", "default", tableName); transaction(queryRunner.getTransactionManager(), new AllowAllAccessControl()) .singleStatement() .execute(SESSION, session -> { Optional<TableHandle> handle = queryRunner.getServer().getMetadata().getTableHandle(session, name); assertTrue(handle.isPresent()); }); }
private Object getHiveTableProperty(String tableName, Function<HiveTableLayoutHandle, Object> propertyGetter) { Session session = getSession(); Metadata metadata = ((DistributedQueryRunner) getQueryRunner()).getCoordinator().getMetadata(); return transaction(getQueryRunner().getTransactionManager(), getQueryRunner().getAccessControl()) .readOnly() .execute(session, transactionSession -> { Optional<TableHandle> tableHandle = metadata.getTableHandle(transactionSession, new QualifiedObjectName(catalog, TPCH_SCHEMA, tableName)); assertTrue(tableHandle.isPresent()); List<TableLayoutResult> layouts = metadata.getLayouts(transactionSession, tableHandle.get(), Constraint.alwaysTrue(), Optional.empty()); TableLayout layout = getOnlyElement(layouts).getLayout(); return propertyGetter.apply((HiveTableLayoutHandle) layout.getHandle().getConnectorHandle()); }); }
private TableMetadata getTableMetadata(String catalog, String schema, String tableName) { Session session = getSession(); Metadata metadata = ((DistributedQueryRunner) getQueryRunner()).getCoordinator().getMetadata(); return transaction(getQueryRunner().getTransactionManager(), getQueryRunner().getAccessControl()) .readOnly() .execute(session, transactionSession -> { Optional<TableHandle> tableHandle = metadata.getTableHandle(transactionSession, new QualifiedObjectName(catalog, schema, tableName)); assertTrue(tableHandle.isPresent()); return metadata.getTableMetadata(transactionSession, tableHandle.get()); }); }
private HiveInsertTableHandle getHiveInsertTableHandle(Session session, String tableName) { Metadata metadata = ((DistributedQueryRunner) getQueryRunner()).getCoordinator().getMetadata(); return transaction(getQueryRunner().getTransactionManager(), getQueryRunner().getAccessControl()) .execute(session, transactionSession -> { QualifiedObjectName objectName = new QualifiedObjectName(catalog, TPCH_SCHEMA, tableName); Optional<TableHandle> handle = metadata.getTableHandle(transactionSession, objectName); InsertTableHandle insertTableHandle = metadata.beginInsert(transactionSession, handle.get()); HiveInsertTableHandle hiveInsertTableHandle = (HiveInsertTableHandle) insertTableHandle.getConnectorHandle(); metadata.finishInsert(transactionSession, insertTableHandle, ImmutableList.of(), ImmutableList.of()); return hiveInsertTableHandle; }); }
@Test(expectedExceptions = PrestoException.class, expectedExceptionsMessageRegExp = "Access Denied: Cannot select from table secured_catalog.schema.table") public void testDenySystemAccessControl() { CatalogManager catalogManager = new CatalogManager(); TransactionManager transactionManager = createTestTransactionManager(catalogManager); AccessControlManager accessControlManager = new AccessControlManager(transactionManager); TestSystemAccessControlFactory accessControlFactory = new TestSystemAccessControlFactory("test"); accessControlManager.addSystemAccessControlFactory(accessControlFactory); accessControlManager.setSystemAccessControl("test", ImmutableMap.of()); registerBogusConnector(catalogManager, transactionManager, accessControlManager, "connector"); accessControlManager.addCatalogAccessControl(new ConnectorId("connector"), new DenyConnectorAccessControl()); transaction(transactionManager, accessControlManager) .execute(transactionId -> { accessControlManager.checkCanSelectFromColumns(transactionId, new Identity(USER_NAME, Optional.of(PRINCIPAL)), new QualifiedObjectName("secured_catalog", "schema", "table"), ImmutableSet.of("column")); }); }
private void analyze(Session clientSession, @Language("SQL") String query) { transaction(transactionManager, accessControl) .singleStatement() .readUncommitted() .readOnly() .execute(clientSession, session -> { Analyzer analyzer = createAnalyzer(session, metadata); Statement statement = SQL_PARSER.createStatement(query); analyzer.analyze(statement); }); }