Merge branch 'master' into fix-CoreError-message-parameter-mismatches

Author: brfrn169

core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminTestUtils.java

@@ -90,7 +90,7 @@ private void execute(String sql) throws SQLException {
   @Override
   public boolean tableExists(String namespace, String table) throws Exception {
     String fullTableName = rdbEngine.encloseFullTableName(namespace, table);
-    String sql = rdbEngine.tableExistsInternalTableCheckSql(fullTableName);
+    String sql = rdbEngine.internalTableExistsCheckSql(fullTableName);
     try (Connection connection = dataSource.getConnection();
         Statement statement = connection.createStatement()) {
       statement.execute(sql);

core/src/integration-test/java/com/scalar/db/storage/multistorage/MultiStorageAdminTestUtils.java

@@ -227,7 +227,7 @@ private boolean tableExistsOnCassandra(String namespace, String table) {
 
   private boolean tableExistsOnJdbc(String namespace, String table) throws Exception {
     String fullTableName = rdbEngine.encloseFullTableName(namespace, table);
-    String sql = rdbEngine.tableExistsInternalTableCheckSql(fullTableName);
+    String sql = rdbEngine.internalTableExistsCheckSql(fullTableName);
     try (Connection connection = dataSource.getConnection();
         Statement statement = connection.createStatement()) {
       statement.execute(sql);

core/src/main/java/com/scalar/db/api/AuthAdmin.java

@@ -198,23 +198,23 @@ default void dropRole(String roleName) throws ExecutionException {
   }
 
   /**
-   * Retrieves a list of {@link RoleDetail}s.
+   * Retrieves a list of {@link Role}s.
    *
-   * @return a list of {@link RoleDetail}s
+   * @return a list of {@link Role}s
    * @throws ExecutionException if the operation fails
    */
-  default List<RoleDetail> getRoles() throws ExecutionException {
+  default List<Role> getRoles() throws ExecutionException {
     throw new UnsupportedOperationException(CoreError.AUTH_NOT_ENABLED.buildMessage());
   }
 
   /**
-   * Retrieves a list of {@link UserRoleDetail}s for the given user.
+   * Retrieves a list of {@link RoleForUser}s for the given user.
    *
    * @param username the username
-   * @return a list of {@link UserRoleDetail}s for the given user
+   * @return a list of {@link RoleForUser}s for the given user
    * @throws ExecutionException if the operation fails
    */
-  default List<UserRoleDetail> getRolesForUser(String username) throws ExecutionException {
+  default List<RoleForUser> getRolesForUser(String username) throws ExecutionException {
     throw new UnsupportedOperationException(CoreError.AUTH_NOT_ENABLED.buildMessage());
   }
 
@@ -258,13 +258,13 @@ default void revokeAdminOptionFromUser(String username, String roleName)
   }
 
   /**
-   * Retrieves a list of {@link UserRole}s for the given role.
+   * Retrieves a list of {@link GranteeUserRef}s for the given role.
    *
    * @param roleName the role name
-   * @return a list of {@link UserRole}s for the given role
+   * @return a list of {@link GranteeUserRef}s for the given role
    * @throws ExecutionException if the operation fails
    */
-  default List<UserRole> getUsersForRole(String roleName) throws ExecutionException {
+  default List<GranteeUserRef> getGranteeUsersForRole(String roleName) throws ExecutionException {
     throw new UnsupportedOperationException(CoreError.AUTH_NOT_ENABLED.buildMessage());
   }
 
@@ -399,53 +399,83 @@ default void revokePrivilegeFromRole(
 
   /** Represents a user. */
   interface User {
+    /**
+     * Returns the username.
+     *
+     * @return the username
+     */
     String getName();
 
+    /**
+     * Returns whether the user is a superuser.
+     *
+     * @return whether the user is a superuser
+     */
     boolean isSuperuser();
   }
 
-  /** Represents a role. */
+  /** Represents a role, including its granted roles. */
   interface Role {
+    /**
+     * Returns the role name.
+     *
+     * @return the role name
+     */
     String getName();
-  }
-
-  /** Represents a role with its hierarchy information. */
-  interface RoleDetail {
-    Role getRole();
 
-    List<RoleHierarchy> getRoleHierarchies();
+    /**
+     * Returns the roles granted to the role.
+     *
+     * @return the roles granted to the role
+     */
+    List<GrantedRoleRef> getGrantedRoles();
   }
 
   /**
-   * Represents a role detail for a specific user, including whether the user has admin option for
+   * Represents a role granted to a specific user, including whether the user has admin option for
    * this role.
    */
-  interface UserRoleDetail extends RoleDetail {
+  interface RoleForUser extends Role {
     /**
      * Returns whether the user has admin option for this role. This is distinct from the admin
      * option in role hierarchies, which applies to role-to-role grants.
+     *
+     * @return whether the user has admin option for this role
      */
     boolean hasAdminOptionOnUser();
   }
 
-  /** Represents a user-role assignment. */
-  interface UserRole {
-    String getUsername();
-
-    String getRoleName();
+  /** A reference to a grantee user of a role. */
+  interface GranteeUserRef {
+    /**
+     * Returns the username.
+     *
+     * @return the username
+     */
+    String getName();
 
+    /**
+     * Returns whether admin option is granted for this assignment.
+     *
+     * @return whether admin option is granted for this assignment
+     */
     boolean hasAdminOption();
   }
 
-  /** Represents a role hierarchy (role-to-role assignment). */
-  interface RoleHierarchy {
-    /** Returns the role name. */
-    String getRoleName();
-
-    /** Returns the member role name granted to the role. */
-    String getMemberRoleName();
+  /** A reference to a granted role. */
+  interface GrantedRoleRef {
+    /**
+     * Returns the granted role name.
+     *
+     * @return the granted role name
+     */
+    String getName();
 
-    /** Returns whether admin option is granted for this hierarchy. */
+    /**
+     * Returns whether admin option is granted for this role grant.
+     *
+     * @return whether admin option is granted for this role grant
+     */
     boolean hasAdminOption();
   }
 

core/src/main/java/com/scalar/db/common/DecoratedDistributedTransactionAdmin.java

@@ -394,12 +394,12 @@ public void dropRole(String roleName) throws ExecutionException {
   }
 
   @Override
-  public List<RoleDetail> getRoles() throws ExecutionException {
+  public List<Role> getRoles() throws ExecutionException {
     return distributedTransactionAdmin.getRoles();
   }
 
   @Override
-  public List<UserRoleDetail> getRolesForUser(String username) throws ExecutionException {
+  public List<RoleForUser> getRolesForUser(String username) throws ExecutionException {
     return distributedTransactionAdmin.getRolesForUser(username);
   }
 
@@ -421,8 +421,8 @@ public void revokeAdminOptionFromUser(String username, String roleName)
   }
 
   @Override
-  public List<UserRole> getUsersForRole(String roleName) throws ExecutionException {
-    return distributedTransactionAdmin.getUsersForRole(roleName);
+  public List<GranteeUserRef> getGranteeUsersForRole(String roleName) throws ExecutionException {
+    return distributedTransactionAdmin.getGranteeUsersForRole(roleName);
   }
 
   @Override

core/src/main/java/com/scalar/db/storage/dynamo/DynamoAdmin.java

@@ -304,7 +304,7 @@ private void createTableInternal(
     requestBuilder.tableName(getFullTableName(namespace, table));
 
     try {
-      if (!(ifNotExists && tableExistsInternal(namespace, table))) {
+      if (!(ifNotExists && internalTableExists(namespace, table))) {
         client.createTable(requestBuilder.build());
         waitForTableCreation(namespace, table);
       }
@@ -543,14 +543,14 @@ private void createMetadataTableIfNotExists(boolean noBackup) throws ExecutionEx
   }
 
   private boolean metadataTableExists() throws ExecutionException {
-    return tableExistsInternal(Namespace.of(metadataNamespace), METADATA_TABLE);
+    return internalTableExists(Namespace.of(metadataNamespace), METADATA_TABLE);
   }
 
   private boolean namespacesTableExists() throws ExecutionException {
-    return tableExistsInternal(Namespace.of(metadataNamespace), NAMESPACES_TABLE);
+    return internalTableExists(Namespace.of(metadataNamespace), NAMESPACES_TABLE);
   }
 
-  private boolean tableExistsInternal(Namespace namespace, String table) throws ExecutionException {
+  private boolean internalTableExists(Namespace namespace, String table) throws ExecutionException {
     try {
       client.describeTable(
           DescribeTableRequest.builder().tableName(getFullTableName(namespace, table)).build());

core/src/main/java/com/scalar/db/storage/jdbc/JdbcAdmin.java

@@ -59,6 +59,7 @@ public class JdbcAdmin implements DistributedStorageAdmin {
 
   private final RdbEngineStrategy rdbEngine;
   private final BasicDataSource dataSource;
+  private final String metadataSchema;
   private final TableMetadataService tableMetadataService;
   private final NamespaceMetadataService namespaceMetadataService;
 
@@ -67,16 +68,18 @@ public JdbcAdmin(DatabaseConfig databaseConfig) {
     JdbcConfig config = new JdbcConfig(databaseConfig);
     rdbEngine = RdbEngineFactory.create(config);
     dataSource = JdbcUtils.initDataSourceForAdmin(config, rdbEngine);
-    tableMetadataService = new TableMetadataService(config.getMetadataSchema(), rdbEngine);
-    namespaceMetadataService = new NamespaceMetadataService(config.getMetadataSchema(), rdbEngine);
+    metadataSchema = config.getMetadataSchema();
+    tableMetadataService = new TableMetadataService(metadataSchema, rdbEngine);
+    namespaceMetadataService = new NamespaceMetadataService(metadataSchema, rdbEngine);
   }
 
   @SuppressFBWarnings("EI_EXPOSE_REP2")
   public JdbcAdmin(BasicDataSource dataSource, JdbcConfig config) {
     rdbEngine = RdbEngineFactory.create(config);
     this.dataSource = dataSource;
-    tableMetadataService = new TableMetadataService(config.getMetadataSchema(), rdbEngine);
-    namespaceMetadataService = new NamespaceMetadataService(config.getMetadataSchema(), rdbEngine);
+    metadataSchema = config.getMetadataSchema();
+    tableMetadataService = new TableMetadataService(metadataSchema, rdbEngine);
+    namespaceMetadataService = new NamespaceMetadataService(metadataSchema, rdbEngine);
   }
 
   private static boolean hasDescClusteringOrder(TableMetadata metadata) {
@@ -105,6 +108,7 @@ public void createNamespace(String namespace, Map<String, String> options)
 
     try (Connection connection = dataSource.getConnection()) {
       execute(connection, rdbEngine.createSchemaSqls(namespace));
+      createMetadataSchemaIfNotExists(connection);
       createNamespacesTableIfNotExists(connection);
       namespaceMetadataService.insertIntoNamespacesTable(connection, namespace);
     } catch (SQLException e) {
@@ -117,6 +121,7 @@ public void createTable(
       String namespace, String table, TableMetadata metadata, Map<String, String> options)
       throws ExecutionException {
     try (Connection connection = dataSource.getConnection()) {
+      createMetadataSchemaIfNotExists(connection);
       createTableInternal(connection, namespace, table, metadata, false);
       addTableMetadata(connection, namespace, table, metadata, true, false);
     } catch (SQLException e) {
@@ -221,6 +226,7 @@ public void dropNamespace(String namespace) throws ExecutionException {
       execute(connection, rdbEngine.dropNamespaceSql(namespace));
       namespaceMetadataService.deleteFromNamespacesTable(connection, namespace);
       namespaceMetadataService.deleteNamespacesTableIfEmpty(connection);
+      deleteMetadataSchemaIfEmpty(connection);
     } catch (SQLException e) {
       rdbEngine.dropNamespaceTranslateSQLException(e, namespace);
     }
@@ -282,7 +288,7 @@ TableMetadata getImportTableMetadata(
       String catalogName = rdbEngine.getCatalogName(namespace);
       String schemaName = rdbEngine.getSchemaName(namespace);
 
-      if (!tableExistsInternal(connection, namespace, table)) {
+      if (!internalTableExists(connection, namespace, table)) {
         throw new IllegalArgumentException(
             CoreError.TABLE_NOT_FOUND.buildMessage(getFullTableName(namespace, table)));
       }
@@ -337,6 +343,7 @@ public void importTable(
 
     try (Connection connection = dataSource.getConnection()) {
       TableMetadata tableMetadata = getImportTableMetadata(namespace, table, overrideColumnsType);
+      createMetadataSchemaIfNotExists(connection);
       createNamespacesTableIfNotExists(connection);
       upsertIntoNamespacesTable(connection, namespace);
       addTableMetadata(connection, namespace, table, tableMetadata, true, false);
@@ -473,6 +480,7 @@ public void repairNamespace(String namespace, Map<String, String> options)
 
     try (Connection connection = dataSource.getConnection()) {
       createSchemaIfNotExists(connection, namespace);
+      createMetadataSchemaIfNotExists(connection);
       createNamespacesTableIfNotExists(connection);
       upsertIntoNamespacesTable(connection, namespace);
     } catch (SQLException e) {
@@ -485,6 +493,7 @@ public void repairTable(
       String namespace, String table, TableMetadata metadata, Map<String, String> options)
       throws ExecutionException {
     try (Connection connection = dataSource.getConnection()) {
+      createMetadataSchemaIfNotExists(connection);
       createTableInternal(connection, namespace, table, metadata, true);
       addTableMetadata(connection, namespace, table, metadata, true, true);
     } catch (SQLException e) {
@@ -720,6 +729,7 @@ public void upgrade(Map<String, String> options) throws ExecutionException {
         return;
       }
 
+      createMetadataSchemaIfNotExists(connection);
       createNamespacesTableIfNotExists(connection);
       for (String namespace : namespaceNamesOfExistingTables) {
         upsertIntoNamespacesTable(connection, namespace);
@@ -762,6 +772,20 @@ void upsertIntoNamespacesTable(Connection connection, String namespace) throws S
     namespaceMetadataService.upsertIntoNamespacesTable(connection, namespace);
   }
 
+  private void createMetadataSchemaIfNotExists(Connection connection) throws SQLException {
+    createSchemaIfNotExists(connection, metadataSchema);
+  }
+
+  private void deleteMetadataSchemaIfEmpty(Connection connection) throws SQLException {
+    Set<String> internalTableNames = getInternalTableNames(connection, metadataSchema);
+    if (!internalTableNames.isEmpty()) {
+      return;
+    }
+
+    String sql = rdbEngine.deleteMetadataSchemaSql(metadataSchema);
+    execute(connection, sql);
+  }
+
   private void createTable(Connection connection, String createTableStatement, boolean ifNotExists)
       throws SQLException {
     String stmt = createTableStatement;
@@ -778,10 +802,10 @@ private void createTable(Connection connection, String createTableStatement, boo
     }
   }
 
-  private boolean tableExistsInternal(Connection connection, String namespace, String table)
+  private boolean internalTableExists(Connection connection, String namespace, String table)
       throws ExecutionException {
     String fullTableName = encloseFullTableName(namespace, table);
-    String sql = rdbEngine.tableExistsInternalTableCheckSql(fullTableName);
+    String sql = rdbEngine.internalTableExistsCheckSql(fullTableName);
     try {
       execute(connection, sql);
       return true;