@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(); } }
public <T> T inTransaction(Session session, Function<Session, T> transactionSessionConsumer) { return transaction(transactionManager, accessControl) .singleStatement() .execute(session, transactionSessionConsumer); }
public static TransactionBuilder transaction(TransactionManager transactionManager, AccessControl accessControl) { return new TransactionBuilder(transactionManager, accessControl); }
private void inSetupTransaction(Consumer<Session> consumer) { transaction(transactionManager, accessControl) .singleStatement() .readUncommitted() .execute(SETUP_SESSION, consumer); }
@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 void execute(Consumer<TransactionId> callback) { requireNonNull(callback, "callback is null"); execute(transactionId -> { callback.accept(transactionId); return null; }); }
@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); }); }
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); }); }
public void execute(Session session, Consumer<Session> callback) { requireNonNull(session, "session is null"); requireNonNull(callback, "callback is null"); execute(session, transactionSession -> { callback.accept(transactionSession); return null; }); }
@Override public List<QualifiedObjectName> listTables(Session session, String catalog, String schema) { lock.readLock().lock(); try { return transaction(transactionManager, accessControl) .readOnly() .execute(session, transactionSession -> { return getMetadata().listTables(transactionSession, new QualifiedTablePrefix(catalog, schema)); }); } 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)); }
@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")); }); }
private void inSetupTransaction(Consumer<Session> consumer) { transaction(transactionManager) .singleStatement() .readUncommitted() .execute(SETUP_SESSION, consumer); }
public void execute(Consumer<TransactionId> callback) { requireNonNull(callback, "callback is null"); execute(transactionId -> { callback.accept(transactionId); return null; }); }
public static TransactionBuilder transaction(TransactionManager transactionManager) { return new TransactionBuilder(transactionManager); }
public boolean tableExists(Session session, String table) { return transaction(prestoServer.getTransactionManager(), prestoServer.getAccessControl()) .readOnly() .execute(session, transactionSession -> { return MetadataUtil.tableExists(prestoServer.getMetadata(), transactionSession, table); }); }
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 testSchemaOperations() { TransactionManager transactionManager = createTestTransactionManager(); AccessControlManager accessControlManager = newAccessControlManager(transactionManager, "catalog.json"); transaction(transactionManager, accessControlManager) .execute(transactionId -> { Set<String> aliceSchemas = ImmutableSet.of("schema"); assertEquals(accessControlManager.filterSchemas(transactionId, alice, "alice-catalog", aliceSchemas), aliceSchemas); assertEquals(accessControlManager.filterSchemas(transactionId, bob, "alice-catalog", aliceSchemas), ImmutableSet.of()); accessControlManager.checkCanCreateSchema(transactionId, alice, aliceSchema); accessControlManager.checkCanDropSchema(transactionId, alice, aliceSchema); accessControlManager.checkCanRenameSchema(transactionId, alice, aliceSchema, "new-schema"); accessControlManager.checkCanShowSchemas(transactionId, alice, "alice-catalog"); }); assertThrows(AccessDeniedException.class, () -> transaction(transactionManager, accessControlManager).execute(transactionId -> { accessControlManager.checkCanCreateSchema(transactionId, bob, aliceSchema); })); }
private void analyzeWithoutExperimentalSyntax(@Language("SQL") String query) { transaction(transactionManager) .singleStatement() .readUncommitted() .readOnly() .execute(CLIENT_SESSION, session -> { Analyzer analyzer = createAnalyzer(session, metadata, false); Statement statement = SQL_PARSER.createStatement(query); analyzer.analyze(statement); }); }
public void execute(Session session, Consumer<Session> callback) { requireNonNull(session, "session is null"); requireNonNull(callback, "callback is null"); execute(session, transactionSession -> { callback.accept(transactionSession); return null; }); }