@Override public Optional<ConnectorId> getCatalogHandle(Session session, String catalogName) { return transactionManager.getOptionalCatalogMetadata(session.getRequiredTransactionId(), catalogName).map(CatalogMetadata::getConnectorId); }
@Override public Map<String, ConnectorId> getCatalogNames(Session session) { return transactionManager.getCatalogNames(session.getRequiredTransactionId()); }
private Optional<CatalogMetadata> getOptionalCatalogMetadata(Session session, String catalogName) { return transactionManager.getOptionalCatalogMetadata(session.getRequiredTransactionId(), catalogName); }
private CatalogMetadata getCatalogMetadataForWrite(Session session, ConnectorId connectorId) { return transactionManager.getCatalogMetadataForWrite(session.getRequiredTransactionId(), connectorId); }
private CatalogMetadata getCatalogMetadata(Session session, ConnectorId connectorId) { return transactionManager.getCatalogMetadata(session.getRequiredTransactionId(), connectorId); }
private CatalogMetadata getCatalogMetadataForWrite(Session session, String catalogName) { return transactionManager.getCatalogMetadataForWrite(session.getRequiredTransactionId(), catalogName); }
public static SortedSet<String> listSchemas(Session session, Metadata metadata, AccessControl accessControl, String catalogName) { Set<String> schemaNames = ImmutableSet.copyOf(metadata.listSchemaNames(session, catalogName)); return ImmutableSortedSet.copyOf(accessControl.filterSchemas(session.getRequiredTransactionId(), session.getIdentity(), catalogName, schemaNames)); }
public static Set<GrantInfo> listTablePrivileges(Session session, Metadata metadata, AccessControl accessControl, QualifiedTablePrefix prefix) { List<GrantInfo> grants = metadata.listTablePrivileges(session, prefix); Set<SchemaTableName> allowedTables = accessControl.filterTables( session.getRequiredTransactionId(), session.getIdentity(), prefix.getCatalogName(), grants.stream().map(GrantInfo::getSchemaTableName).collect(toImmutableSet())); return grants.stream() .filter(grantInfo -> allowedTables.contains(grantInfo.getSchemaTableName())) .collect(toImmutableSet()); }
public static Map<SchemaTableName, List<ColumnMetadata>> listTableColumns(Session session, Metadata metadata, AccessControl accessControl, QualifiedTablePrefix prefix) { Map<SchemaTableName, List<ColumnMetadata>> tableColumns = metadata.listTableColumns(session, prefix).entrySet().stream() .collect(toImmutableMap(entry -> entry.getKey().asSchemaTableName(), Entry::getValue)); Set<SchemaTableName> allowedTables = accessControl.filterTables( session.getRequiredTransactionId(), session.getIdentity(), prefix.getCatalogName(), tableColumns.keySet()); ImmutableMap.Builder<SchemaTableName, List<ColumnMetadata>> result = ImmutableMap.builder(); for (Entry<SchemaTableName, List<ColumnMetadata>> entry : tableColumns.entrySet()) { if (allowedTables.contains(entry.getKey())) { result.put(entry); } } return result.build(); } }
public static Set<SchemaTableName> listViews(Session session, Metadata metadata, AccessControl accessControl, QualifiedTablePrefix prefix) { Set<SchemaTableName> tableNames = metadata.listViews(session, prefix).stream() .map(QualifiedObjectName::asSchemaTableName) .collect(toImmutableSet()); return accessControl.filterTables(session.getRequiredTransactionId(), session.getIdentity(), prefix.getCatalogName(), tableNames); }
public static Set<SchemaTableName> listTables(Session session, Metadata metadata, AccessControl accessControl, QualifiedTablePrefix prefix) { Set<SchemaTableName> tableNames = metadata.listTables(session, prefix).stream() .map(QualifiedObjectName::asSchemaTableName) .collect(toImmutableSet()); return accessControl.filterTables(session.getRequiredTransactionId(), session.getIdentity(), prefix.getCatalogName(), tableNames); }
@Override protected void tearDown() { localQueryRunner.getTransactionManager().asyncAbort(session.getRequiredTransactionId()); super.tearDown(); }
@Override public ListenableFuture<?> execute(DropTable statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { Session session = stateMachine.getSession(); QualifiedObjectName tableName = createQualifiedObjectName(session, statement, statement.getTableName()); Optional<TableHandle> tableHandle = metadata.getTableHandle(session, tableName); if (!tableHandle.isPresent()) { if (!statement.isExists()) { throw new SemanticException(MISSING_TABLE, statement, "Table '%s' does not exist", tableName); } return immediateFuture(null); } accessControl.checkCanDropTable(session.getRequiredTransactionId(), session.getIdentity(), tableName); metadata.dropTable(session, tableHandle.get()); return immediateFuture(null); } }
public Analysis analyze(Statement statement, boolean isDescribe) { Statement rewrittenStatement = StatementRewrite.rewrite(session, metadata, sqlParser, queryExplainer, statement, parameters, accessControl, warningCollector); Analysis analysis = new Analysis(rewrittenStatement, parameters, isDescribe); StatementAnalyzer analyzer = new StatementAnalyzer(analysis, metadata, sqlParser, accessControl, session, warningCollector); analyzer.analyze(rewrittenStatement, Optional.empty()); // check column access permissions for each table analysis.getTableColumnReferences().forEach((accessControlInfo, tableColumnReferences) -> tableColumnReferences.forEach((tableName, columns) -> accessControlInfo.getAccessControl().checkCanSelectFromColumns( session.getRequiredTransactionId(), accessControlInfo.getIdentity(), tableName, columns))); return analysis; }
@Override public ListenableFuture<?> execute(DropView statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { Session session = stateMachine.getSession(); QualifiedObjectName name = createQualifiedObjectName(session, statement, statement.getName()); Optional<ViewDefinition> view = metadata.getView(session, name); if (!view.isPresent()) { if (!statement.isExists()) { throw new SemanticException(MISSING_TABLE, statement, "View '%s' does not exist", name); } return immediateFuture(null); } accessControl.checkCanDropView(session.getRequiredTransactionId(), session.getIdentity(), name); metadata.dropView(session, name); return immediateFuture(null); } }
@Override public ListenableFuture<?> execute(DropSchema statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { if (statement.isCascade()) { throw new PrestoException(NOT_SUPPORTED, "CASCADE is not yet supported for DROP SCHEMA"); } Session session = stateMachine.getSession(); CatalogSchemaName schema = createCatalogSchemaName(session, statement, Optional.of(statement.getSchemaName())); if (!metadata.schemaExists(session, schema)) { if (!statement.isExists()) { throw new SemanticException(MISSING_SCHEMA, statement, "Schema '%s' does not exist", schema); } return immediateFuture(null); } accessControl.checkCanDropSchema(session.getRequiredTransactionId(), session.getIdentity(), schema); metadata.dropSchema(session, schema); return immediateFuture(null); } }
@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); }
accessControl.checkCanDropColumn(session.getRequiredTransactionId(), session.getIdentity(), tableName);
@Override protected Scope visitCreateView(CreateView node, Optional<Scope> scope) { analysis.setUpdateType("CREATE VIEW"); QualifiedObjectName viewName = createQualifiedObjectName(session, node, node.getName()); // analyze the query that creates the view StatementAnalyzer analyzer = new StatementAnalyzer(analysis, metadata, sqlParser, accessControl, session, WarningCollector.NOOP); Scope queryScope = analyzer.analyze(node.getQuery(), scope); accessControl.checkCanCreateView(session.getRequiredTransactionId(), session.getIdentity(), viewName); validateColumns(node, queryScope.getRelationType()); return createAndAssignScope(node, scope); }
@Override public ListenableFuture<?> execute(RenameSchema statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters) { Session session = stateMachine.getSession(); CatalogSchemaName source = createCatalogSchemaName(session, statement, Optional.of(statement.getSource())); CatalogSchemaName target = new CatalogSchemaName(source.getCatalogName(), statement.getTarget().getValue()); if (!metadata.schemaExists(session, source)) { throw new SemanticException(MISSING_SCHEMA, statement, "Schema '%s' does not exist", source); } if (metadata.schemaExists(session, target)) { throw new SemanticException(SCHEMA_ALREADY_EXISTS, statement, "Target schema '%s' already exists", target); } accessControl.checkCanRenameSchema(session.getRequiredTransactionId(), session.getIdentity(), source, statement.getTarget().getValue()); metadata.renameSchema(session, source, statement.getTarget().getValue()); return immediateFuture(null); } }