diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminTestUtils.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminTestUtils.java
index 578eed34a6..9fa499b2df 100644
--- a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminTestUtils.java
+++ b/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);
diff --git a/core/src/integration-test/java/com/scalar/db/storage/multistorage/MultiStorageAdminTestUtils.java b/core/src/integration-test/java/com/scalar/db/storage/multistorage/MultiStorageAdminTestUtils.java
index 8ef82c5025..fd9c414617 100644
--- a/core/src/integration-test/java/com/scalar/db/storage/multistorage/MultiStorageAdminTestUtils.java
+++ b/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);
diff --git a/core/src/main/java/com/scalar/db/storage/dynamo/DynamoAdmin.java b/core/src/main/java/com/scalar/db/storage/dynamo/DynamoAdmin.java
index c7656f137f..6027821912 100644
--- a/core/src/main/java/com/scalar/db/storage/dynamo/DynamoAdmin.java
+++ b/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());
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/JdbcAdmin.java b/core/src/main/java/com/scalar/db/storage/jdbc/JdbcAdmin.java
index d9d729070a..acc4770d05 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/JdbcAdmin.java
+++ b/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;
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/NamespaceMetadataService.java b/core/src/main/java/com/scalar/db/storage/jdbc/NamespaceMetadataService.java
index 25ff95223d..486e14ec7b 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/NamespaceMetadataService.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/NamespaceMetadataService.java
@@ -27,11 +27,10 @@ public class NamespaceMetadataService {
   }
 
   void createNamespacesTableIfNotExists(Connection connection) throws SQLException {
-    if (tableExistsInternal(connection, metadataSchema, TABLE_NAME)) {
+    if (internalTableExists(connection, metadataSchema, TABLE_NAME)) {
       return;
     }
 
-    createSchemaIfNotExists(connection, metadataSchema);
     String createTableStatement =
         "CREATE TABLE "
             + encloseFullTableName(metadataSchema, TABLE_NAME)
@@ -52,7 +51,6 @@ void createNamespacesTableIfNotExists(Connection connection) throws SQLException
   void deleteNamespacesTableIfEmpty(Connection connection) throws SQLException {
     if (isNamespacesTableEmpty(connection)) {
       deleteTable(connection, encloseFullTableName(metadataSchema, TABLE_NAME));
-      deleteMetadataSchema(connection);
     }
   }
 
@@ -75,11 +73,6 @@ private boolean isNamespacesTableEmpty(Connection connection) throws SQLExceptio
     return namespaces.size() == 1 && namespaces.contains(metadataSchema);
   }
 
-  private void deleteMetadataSchema(Connection connection) throws SQLException {
-    String sql = rdbEngine.deleteMetadataSchemaSql(metadataSchema);
-    execute(connection, sql);
-  }
-
   void insertIntoNamespacesTable(Connection connection, String namespaceName) throws SQLException {
     String insertStatement =
         "INSERT INTO " + encloseFullTableName(metadataSchema, TABLE_NAME) + " VALUES (?)";
@@ -178,10 +171,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 SQLException {
     String fullTableName = encloseFullTableName(namespace, table);
-    String sql = rdbEngine.tableExistsInternalTableCheckSql(fullTableName);
+    String sql = rdbEngine.internalTableExistsCheckSql(fullTableName);
     try {
       execute(connection, sql);
       return true;
@@ -201,18 +194,6 @@ private void deleteTable(Connection connection, String fullTableName) throws SQL
     execute(connection, dropTableStatement);
   }
 
-  private void createSchemaIfNotExists(Connection connection, String schema) throws SQLException {
-    String[] sqls = rdbEngine.createSchemaIfNotExistsSqls(schema);
-    try {
-      execute(connection, sqls);
-    } catch (SQLException e) {
-      // Suppress exceptions indicating the duplicate metadata schema
-      if (!rdbEngine.isCreateMetadataSchemaDuplicateSchemaError(e)) {
-        throw e;
-      }
-    }
-  }
-
   private String enclose(String name) {
     return rdbEngine.enclose(name);
   }
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java
index f914228a85..3eb0ac10f7 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java
@@ -283,7 +283,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT 1 FROM " + fullTableName + " LIMIT 1";
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineMysql.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineMysql.java
index 74363ecc37..2e96583c1b 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineMysql.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineMysql.java
@@ -153,7 +153,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT 1 FROM " + fullTableName + " LIMIT 1";
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineOracle.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineOracle.java
index 60f0cf14f5..ba8e00060c 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineOracle.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineOracle.java
@@ -159,7 +159,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT 1 FROM " + fullTableName + " FETCH FIRST 1 ROWS ONLY";
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEnginePostgresql.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEnginePostgresql.java
index 0815be9def..33ba3bed7c 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEnginePostgresql.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEnginePostgresql.java
@@ -133,7 +133,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT 1 FROM " + fullTableName + " LIMIT 1";
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlServer.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlServer.java
index c833c25817..4a38abeca1 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlServer.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlServer.java
@@ -140,7 +140,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT TOP 1 1 FROM " + fullTableName;
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlite.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlite.java
index 0c906fa7a0..75a1328a96 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlite.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineSqlite.java
@@ -277,7 +277,7 @@ public String[] alterColumnTypeSql(
   }
 
   @Override
-  public String tableExistsInternalTableCheckSql(String fullTableName) {
+  public String internalTableExistsCheckSql(String fullTableName) {
     return "SELECT 1 FROM " + fullTableName + " LIMIT 1";
   }
 
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineStrategy.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineStrategy.java
index 38bb3469e0..8d7992f529 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineStrategy.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineStrategy.java
@@ -129,7 +129,7 @@ default String renameColumnSql(
 
   String[] alterColumnTypeSql(String namespace, String table, String columnName, String columnType);
 
-  String tableExistsInternalTableCheckSql(String fullTableName);
+  String internalTableExistsCheckSql(String fullTableName);
 
   default String createIndexSql(
       String schema, String table, String indexName, String indexedColumn) {
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/TableMetadataService.java b/core/src/main/java/com/scalar/db/storage/jdbc/TableMetadataService.java
index ba8c32643e..75cb23f406 100644
--- a/core/src/main/java/com/scalar/db/storage/jdbc/TableMetadataService.java
+++ b/core/src/main/java/com/scalar/db/storage/jdbc/TableMetadataService.java
@@ -334,7 +334,7 @@ Set<String> getNamespaceTableNames(Connection connection, String namespace) thro
   }
 
   Set<String> getNamespaceNamesOfExistingTables(Connection connection) throws SQLException {
-    if (!tableExistsInternal(connection, metadataSchema, TABLE_NAME)) {
+    if (!internalTableExists(connection, metadataSchema, TABLE_NAME)) {
       return Collections.emptySet();
     }
 
@@ -383,10 +383,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 SQLException {
     String fullTableName = encloseFullTableName(namespace, table);
-    String sql = rdbEngine.tableExistsInternalTableCheckSql(fullTableName);
+    String sql = rdbEngine.internalTableExistsCheckSql(fullTableName);
     try {
       execute(connection, sql);
       return true;
diff --git a/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java b/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java
index 7e2d4d0801..7477fe942b 100644
--- a/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java
+++ b/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java
@@ -351,8 +351,8 @@ public void createNamespace_forMysql_shouldExecuteCreateNamespaceStatement()
     createNamespace_forX_shouldExecuteCreateNamespaceStatement(
         RdbEngine.MYSQL,
         Collections.singletonList("CREATE SCHEMA `my_ns`"),
-        "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`namespaces` LIMIT 1",
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS `" + METADATA_SCHEMA + "`"),
+        "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`namespaces` LIMIT 1",
         "CREATE TABLE IF NOT EXISTS `"
             + METADATA_SCHEMA
             + "`.`namespaces`(`namespace_name` VARCHAR(128), PRIMARY KEY (`namespace_name`))",
@@ -365,8 +365,8 @@ public void createNamespace_forPostgresql_shouldExecuteCreateNamespaceStatement(
     createNamespace_forX_shouldExecuteCreateNamespaceStatement(
         RdbEngine.POSTGRESQL,
         Collections.singletonList("CREATE SCHEMA \"my_ns\""),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128), PRIMARY KEY (\"namespace_name\"))",
@@ -379,8 +379,8 @@ public void createNamespace_forSqlServer_shouldExecuteCreateNamespaceStatement()
     createNamespace_forX_shouldExecuteCreateNamespaceStatement(
         RdbEngine.SQL_SERVER,
         Collections.singletonList("CREATE SCHEMA [my_ns]"),
-        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         Collections.singletonList("CREATE SCHEMA [" + METADATA_SCHEMA + "]"),
+        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         "CREATE TABLE ["
             + METADATA_SCHEMA
             + "].[namespaces]([namespace_name] VARCHAR(128), PRIMARY KEY ([namespace_name]))",
@@ -395,10 +395,10 @@ public void createNamespace_forOracle_shouldExecuteCreateNamespaceStatement()
         Arrays.asList(
             "CREATE USER \"my_ns\" IDENTIFIED BY \"Oracle1234!@#$\"",
             "ALTER USER \"my_ns\" quota unlimited on USERS"),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         Arrays.asList(
             "CREATE USER \"" + METADATA_SCHEMA + "\" IDENTIFIED BY \"Oracle1234!@#$\"",
             "ALTER USER \"" + METADATA_SCHEMA + "\" quota unlimited on USERS"),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         "CREATE TABLE \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR2(128), PRIMARY KEY (\"namespace_name\"))",
@@ -411,8 +411,8 @@ public void createNamespace_forSqlite_shouldExecuteCreateNamespaceStatement()
     createNamespace_forX_shouldExecuteCreateNamespaceStatement(
         RdbEngine.SQLITE,
         Collections.emptyList(),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         Collections.emptyList(),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "$namespaces\"(\"namespace_name\" TEXT, PRIMARY KEY (\"namespace_name\"))",
@@ -425,8 +425,8 @@ public void createNamespace_forDb2_shouldExecuteCreateNamespaceStatement()
     createNamespace_forX_shouldExecuteCreateNamespaceStatement(
         RdbEngine.DB2,
         Collections.singletonList("CREATE SCHEMA \"my_ns\""),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         Collections.singletonList("CREATE SCHEMA \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128) NOT NULL, PRIMARY KEY (\"namespace_name\"))",
@@ -436,8 +436,8 @@ public void createNamespace_forDb2_shouldExecuteCreateNamespaceStatement()
   private void createNamespace_forX_shouldExecuteCreateNamespaceStatement(
       RdbEngine rdbEngine,
       List<String> createSchemaSqls,
-      String namespacesTableExistsSql,
       List<String> createMetadataSchemaSqls,
+      String namespacesTableExistsSql,
       String createNamespacesTableSql,
       String insertNamespaceSql)
       throws SQLException, ExecutionException {
@@ -466,8 +466,8 @@ private void createNamespace_forX_shouldExecuteCreateNamespaceStatement(
     List<Statement> statementsMock =
         ImmutableList.<Statement>builder()
             .addAll(mockedCreateSchemaStatements)
-            .add(mockedNamespacesTableExistsStatement)
             .addAll(mockedCreateMetadataSchemaStatements)
+            .add(mockedNamespacesTableExistsStatement)
             .add(mockedCreateNamespacesTableStatement)
             .build();
     when(connection.createStatement())
@@ -489,10 +489,10 @@ private void createNamespace_forX_shouldExecuteCreateNamespaceStatement(
     for (int i = 0; i < createSchemaSqls.size(); i++) {
       verify(mockedCreateSchemaStatements.get(i)).execute(createSchemaSqls.get(i));
     }
-    verify(mockedNamespacesTableExistsStatement).execute(namespacesTableExistsSql);
     for (int i = 0; i < createMetadataSchemaSqls.size(); i++) {
       verify(mockedCreateMetadataSchemaStatements.get(i)).execute(createMetadataSchemaSqls.get(i));
     }
+    verify(mockedNamespacesTableExistsStatement).execute(namespacesTableExistsSql);
     verify(mockedCreateNamespacesTableStatement).execute(createNamespacesTableSql);
     verify(mockedInsertNamespaceStatement1).setString(1, METADATA_SCHEMA);
     verify(mockedInsertNamespaceStatement2).setString(1, namespace);
@@ -1980,6 +1980,7 @@ private void dropNamespace_WithOnlyNamespaceSchemaLeftForX_shouldDropSchemaAndNa
     Statement dropNamespaceStmt = mock(Statement.class);
     PreparedStatement isNamespaceEmptyStatementMock = mock(PreparedStatement.class);
     PreparedStatement deleteFromNamespaceTablePrepStmt = mock(PreparedStatement.class);
+    PreparedStatement getInternalTableNamesStatementMock = mock(PreparedStatement.class);
     Statement selectAllFromNamespaceTablePrepStmt = mock(Statement.class);
     Statement dropNamespaceTableStmt = mock(Statement.class);
     Statement dropMetadataSchemaStmt = mock(Statement.class);
@@ -1994,8 +1995,17 @@ private void dropNamespace_WithOnlyNamespaceSchemaLeftForX_shouldDropSchemaAndNa
     ResultSet emptyResultSet = mock(ResultSet.class);
     when(emptyResultSet.next()).thenReturn(false);
     when(isNamespaceEmptyStatementMock.executeQuery()).thenReturn(emptyResultSet);
+    // Mock for getInternalTableNames() check - returns empty ResultSet (no tables in metadata
+    // schema)
+    ResultSet emptyInternalTablesResultSet = mock(ResultSet.class);
+    when(emptyInternalTablesResultSet.next()).thenReturn(false);
+    when(getInternalTableNamesStatementMock.executeQuery())
+        .thenReturn(emptyInternalTablesResultSet);
     when(connection.prepareStatement(anyString()))
-        .thenReturn(isNamespaceEmptyStatementMock, deleteFromNamespaceTablePrepStmt);
+        .thenReturn(
+            isNamespaceEmptyStatementMock,
+            deleteFromNamespaceTablePrepStmt,
+            getInternalTableNamesStatementMock);
     when(dataSource.getConnection()).thenReturn(connection);
     // Only the metadata schema is left
     ResultSet resultSet =
@@ -2092,13 +2102,24 @@ private void dropNamespace_WithOtherNamespaceLeftForX_shouldOnlyDropNamespace(
     Statement selectNamespaceStatementMock = mock(Statement.class);
     if (rdbEngine != RdbEngine.SQLITE) {
       PreparedStatement getTableNamesPrepStmt = mock(PreparedStatement.class);
+      PreparedStatement getInternalTableNamesStatementMock = mock(PreparedStatement.class);
       when(connection.createStatement())
           .thenReturn(dropNamespaceStatementMock, selectNamespaceStatementMock);
       ResultSet emptyResultSet = mock(ResultSet.class);
       when(emptyResultSet.next()).thenReturn(false);
       when(getTableNamesPrepStmt.executeQuery()).thenReturn(emptyResultSet);
+      // Mock for getInternalTableNames() check - returns non-empty ResultSet (namespaces table
+      // exists)
+      ResultSet nonEmptyInternalTablesResultSet = mock(ResultSet.class);
+      when(nonEmptyInternalTablesResultSet.next()).thenReturn(true, false);
+      when(nonEmptyInternalTablesResultSet.getString(1)).thenReturn("namespaces");
+      when(getInternalTableNamesStatementMock.executeQuery())
+          .thenReturn(nonEmptyInternalTablesResultSet);
       when(connection.prepareStatement(anyString()))
-          .thenReturn(getTableNamesPrepStmt, deleteFromNamespaceTableMock);
+          .thenReturn(
+              getTableNamesPrepStmt,
+              deleteFromNamespaceTableMock,
+              getInternalTableNamesStatementMock);
     } else {
       when(connection.createStatement()).thenReturn(selectNamespaceStatementMock);
       when(connection.prepareStatement(anyString())).thenReturn(deleteFromNamespaceTableMock);
@@ -3933,6 +3954,8 @@ public void importTable_ForXBesidesSqlite_ShouldWorkProperly(RdbEngine rdbEngine
     JdbcAdmin adminSpy = spy(createJdbcAdminFor(rdbEngine));
 
     when(dataSource.getConnection()).thenReturn(connection);
+    Statement mockStatement = mock(Statement.class);
+    when(connection.createStatement()).thenReturn(mockStatement);
     TableMetadata importedTableMetadata = mock(TableMetadata.class);
     doReturn(importedTableMetadata)
         .when(adminSpy)
@@ -4002,8 +4025,8 @@ public void repairNamespace_forMysql_shouldCreateNamespaceIfNotExistsAndUpsertMe
     repairNamespace_forX_shouldWorkProperly(
         RdbEngine.MYSQL,
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS `my_ns`"),
-        "SELECT 1 FROM `scalardb`.`namespaces` LIMIT 1",
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS `" + METADATA_SCHEMA + "`"),
+        "SELECT 1 FROM `scalardb`.`namespaces` LIMIT 1",
         "CREATE TABLE IF NOT EXISTS `"
             + METADATA_SCHEMA
             + "`.`namespaces`(`namespace_name` VARCHAR(128), PRIMARY KEY (`namespace_name`))",
@@ -4016,8 +4039,8 @@ public void repairNamespace_forPostgresql_shouldCreateNamespaceIfNotExistsAndUps
     repairNamespace_forX_shouldWorkProperly(
         RdbEngine.POSTGRESQL,
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS \"my_ns\""),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         Collections.singletonList("CREATE SCHEMA IF NOT EXISTS \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4030,8 +4053,8 @@ public void repairNamespace_forSqlServer_shouldCreateNamespaceIfNotExistsAndUpse
     repairNamespace_forX_shouldWorkProperly(
         RdbEngine.SQL_SERVER,
         Collections.singletonList("CREATE SCHEMA [my_ns]"),
-        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         Collections.singletonList("CREATE SCHEMA [" + METADATA_SCHEMA + "]"),
+        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         "CREATE TABLE ["
             + METADATA_SCHEMA
             + "].[namespaces]([namespace_name] VARCHAR(128), PRIMARY KEY ([namespace_name]))",
@@ -4046,10 +4069,10 @@ public void repairNamespace_forOracle_shouldCreateNamespaceIfNotExistsAndUpsertM
         Arrays.asList(
             "CREATE USER \"my_ns\" IDENTIFIED BY \"Oracle1234!@#$\"",
             "ALTER USER \"my_ns\" quota unlimited on USERS"),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         Arrays.asList(
             "CREATE USER \"" + METADATA_SCHEMA + "\" IDENTIFIED BY \"Oracle1234!@#$\"",
             "ALTER USER \"" + METADATA_SCHEMA + "\" quota unlimited on USERS"),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         "CREATE TABLE \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR2(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4062,8 +4085,8 @@ public void repairNamespace_forDb2_shouldCreateNamespaceIfNotExistsAndUpsertMeta
     repairNamespace_forX_shouldWorkProperly(
         RdbEngine.DB2,
         Collections.singletonList("CREATE SCHEMA \"my_ns\""),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         Collections.singletonList("CREATE SCHEMA \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128) NOT NULL, PRIMARY KEY (\"namespace_name\"))",
@@ -4076,8 +4099,8 @@ public void repairNamespace_forSqlite_shouldUpsertNamespaceMetadata()
     repairNamespace_forX_shouldWorkProperly(
         RdbEngine.SQLITE,
         Collections.emptyList(),
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         Collections.emptyList(),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "$namespaces\"(\"namespace_name\" TEXT, PRIMARY KEY (\"namespace_name\"))",
@@ -4087,8 +4110,8 @@ public void repairNamespace_forSqlite_shouldUpsertNamespaceMetadata()
   private void repairNamespace_forX_shouldWorkProperly(
       RdbEngine rdbEngine,
       List<String> createSchemaIfNotExistsSqls,
-      String namespacesTableExistsSql,
       List<String> createMetadataSchemaSqls,
+      String namespacesTableExistsSql,
       String createNamespacesTableSql,
       String insertNamespaceSql)
       throws SQLException, ExecutionException {
@@ -4117,8 +4140,8 @@ private void repairNamespace_forX_shouldWorkProperly(
     List<Statement> statementsMock =
         ImmutableList.<Statement>builder()
             .addAll(mockedCreateSchemaIfNotExistsStatements)
-            .add(mockedNamespacesTableExistsStatement)
             .addAll(mockedCreateMetadataSchemaStatements)
+            .add(mockedNamespacesTableExistsStatement)
             .add(mockedCreateNamespacesTableStatement)
             .build();
 
@@ -4141,10 +4164,10 @@ private void repairNamespace_forX_shouldWorkProperly(
       verify(mockedCreateSchemaIfNotExistsStatements.get(i))
           .execute(createSchemaIfNotExistsSqls.get(i));
     }
-    verify(mockedNamespacesTableExistsStatement).execute(namespacesTableExistsSql);
     for (int i = 0; i < createMetadataSchemaSqls.size(); i++) {
       verify(mockedCreateMetadataSchemaStatements.get(i)).execute(createMetadataSchemaSqls.get(i));
     }
+    verify(mockedNamespacesTableExistsStatement).execute(namespacesTableExistsSql);
     verify(mockedCreateNamespacesTableStatement).execute(createNamespacesTableSql);
     verify(mockedInsertNamespaceStatement1).setString(1, METADATA_SCHEMA);
     verify(mockedInsertNamespaceStatement2).setString(1, namespace);
@@ -4172,8 +4195,8 @@ public void upgrade_ForMysql_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.MYSQL,
         "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`metadata` LIMIT 1",
         "SELECT DISTINCT `full_table_name` FROM `" + METADATA_SCHEMA + "`.`metadata`",
-        "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`namespaces` LIMIT 1",
         ImmutableList.of("CREATE SCHEMA IF NOT EXISTS `" + METADATA_SCHEMA + "`"),
+        "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`namespaces` LIMIT 1",
         "CREATE TABLE IF NOT EXISTS `"
             + METADATA_SCHEMA
             + "`.`namespaces`(`namespace_name` VARCHAR(128), PRIMARY KEY (`namespace_name`))",
@@ -4187,8 +4210,8 @@ public void upgrade_ForPosgresql_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.POSTGRESQL,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"metadata\" LIMIT 1",
         "SELECT DISTINCT \"full_table_name\" FROM \"" + METADATA_SCHEMA + "\".\"metadata\"",
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         ImmutableList.of("CREATE SCHEMA IF NOT EXISTS \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4202,10 +4225,10 @@ public void upgrade_ForOracle_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.ORACLE,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"metadata\" FETCH FIRST 1 ROWS ONLY",
         "SELECT DISTINCT \"full_table_name\" FROM \"" + METADATA_SCHEMA + "\".\"metadata\"",
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         ImmutableList.of(
             "CREATE USER \"" + METADATA_SCHEMA + "\" IDENTIFIED BY \"Oracle1234!@#$\"",
             "ALTER USER \"" + METADATA_SCHEMA + "\" quota unlimited on USERS"),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
         "CREATE TABLE \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR2(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4219,8 +4242,8 @@ public void upgrade_ForSqlServer_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.SQL_SERVER,
         "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[metadata]",
         "SELECT DISTINCT [full_table_name] FROM [" + METADATA_SCHEMA + "].[metadata]",
-        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         ImmutableList.of("CREATE SCHEMA [" + METADATA_SCHEMA + "]"),
+        "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
         "CREATE TABLE ["
             + METADATA_SCHEMA
             + "].[namespaces]([namespace_name] VARCHAR(128), PRIMARY KEY ([namespace_name]))",
@@ -4234,8 +4257,8 @@ public void upgrade_ForSqlite_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.SQLITE,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "$metadata\" LIMIT 1",
         "SELECT DISTINCT \"full_table_name\" FROM \"" + METADATA_SCHEMA + "$metadata\"",
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         Collections.emptyList(),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "$namespaces\"(\"namespace_name\" TEXT, PRIMARY KEY (\"namespace_name\"))",
@@ -4249,8 +4272,8 @@ public void upgrade_ForDb2_ShouldInsertAllNamespacesFromMetadataTable()
         RdbEngine.DB2,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"metadata\" LIMIT 1",
         "SELECT DISTINCT \"full_table_name\" FROM \"" + METADATA_SCHEMA + "\".\"metadata\"",
-        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         ImmutableList.of("CREATE SCHEMA \"" + METADATA_SCHEMA + "\""),
+        "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128) NOT NULL, PRIMARY KEY (\"namespace_name\"))",
@@ -4261,8 +4284,8 @@ private void upgrade_ForX_ShouldInsertAllNamespacesFromMetadataTable(
       RdbEngine rdbEngine,
       String tableMetadataExistStatement,
       String getTableMetadataNamespacesStatement,
-      String namespacesTableExistsStatement,
       List<String> createMetadataNamespaceStatements,
+      String namespacesTableExistsStatement,
       String createNamespaceTableStatement,
       String insertNamespaceStatement)
       throws SQLException, ExecutionException {
@@ -4284,8 +4307,8 @@ private void upgrade_ForX_ShouldInsertAllNamespacesFromMetadataTable(
         ImmutableList.<Statement>builder()
             .add(tableMetadataExistsStatementMock)
             .add(getTableMetadataNamespacesStatementMock)
-            .add(namespacesTableExistsStatementMock)
             .addAll(createMetadataNamespaceStatementsMock)
+            .add(namespacesTableExistsStatementMock)
             .add(createNamespaceTableStatementMock)
             .build();
 
@@ -4316,11 +4339,11 @@ private void upgrade_ForX_ShouldInsertAllNamespacesFromMetadataTable(
     verify(tableMetadataExistsStatementMock).execute(tableMetadataExistStatement);
     verify(getTableMetadataNamespacesStatementMock)
         .executeQuery(getTableMetadataNamespacesStatement);
-    verify(namespacesTableExistsStatementMock).execute(namespacesTableExistsStatement);
     for (int i = 0; i < createMetadataNamespaceStatementsMock.size(); i++) {
       verify(createMetadataNamespaceStatementsMock.get(i))
           .execute(createMetadataNamespaceStatements.get(i));
     }
+    verify(namespacesTableExistsStatementMock).execute(namespacesTableExistsStatement);
     verify(createNamespaceTableStatementMock).execute(createNamespaceTableStatement);
     verify(connection, times(3)).prepareStatement(insertNamespaceStatement);
     verify(insertNamespacePrepStmt1).setString(1, METADATA_SCHEMA);
@@ -4396,7 +4419,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.MYSQL,
         "SELECT 1 FROM `" + METADATA_SCHEMA + "`.`namespaces` LIMIT 1",
-        Collections.singletonList("CREATE SCHEMA IF NOT EXISTS `" + METADATA_SCHEMA + "`"),
         "CREATE TABLE IF NOT EXISTS `"
             + METADATA_SCHEMA
             + "`.`namespaces`(`namespace_name` VARCHAR(128), PRIMARY KEY (`namespace_name`))",
@@ -4410,7 +4432,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.POSTGRESQL,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
-        Collections.singletonList("CREATE SCHEMA IF NOT EXISTS \"" + METADATA_SCHEMA + "\""),
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4424,7 +4445,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.SQL_SERVER,
         "SELECT TOP 1 1 FROM [" + METADATA_SCHEMA + "].[namespaces]",
-        Collections.singletonList("CREATE SCHEMA [" + METADATA_SCHEMA + "]"),
         "CREATE TABLE ["
             + METADATA_SCHEMA
             + "].[namespaces]([namespace_name] VARCHAR(128), PRIMARY KEY ([namespace_name]))",
@@ -4438,9 +4458,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.ORACLE,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" FETCH FIRST 1 ROWS ONLY",
-        Arrays.asList(
-            "CREATE USER \"" + METADATA_SCHEMA + "\" IDENTIFIED BY \"Oracle1234!@#$\"",
-            "ALTER USER \"" + METADATA_SCHEMA + "\" quota unlimited on USERS"),
         "CREATE TABLE \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR2(128), PRIMARY KEY (\"namespace_name\"))",
@@ -4454,7 +4471,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.SQLITE,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "$namespaces\" LIMIT 1",
-        Collections.emptyList(),
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "$namespaces\"(\"namespace_name\" TEXT, PRIMARY KEY (\"namespace_name\"))",
@@ -4468,7 +4484,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
         RdbEngine.DB2,
         "SELECT 1 FROM \"" + METADATA_SCHEMA + "\".\"namespaces\" LIMIT 1",
-        Collections.singletonList("CREATE SCHEMA \"" + METADATA_SCHEMA + "\""),
         "CREATE TABLE IF NOT EXISTS \""
             + METADATA_SCHEMA
             + "\".\"namespaces\"(\"namespace_name\" VARCHAR(128) NOT NULL, PRIMARY KEY (\"namespace_name\"))",
@@ -4479,7 +4494,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
       createNamespaceTableIfNotExists_forX_shouldCreateMetadataSchemaAndNamespacesTableIfNotExists(
           RdbEngine rdbEngine,
           String namespacesTableExistsSql,
-          List<String> createMetadataSchemaSqls,
           String createNamespacesTableSql,
           String insertNamespaceSql)
           throws SQLException, ExecutionException {
@@ -4492,38 +4506,10 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
     when(mockedNamespacesTableExistsStatement.execute(namespacesTableExistsSql))
         .thenThrow(sqlException);
 
-    List<Statement> mockedCreateMetadataSchemaStatements = new ArrayList<>();
-    for (int i = 0; i < createMetadataSchemaSqls.size(); i++) {
-      mockedCreateMetadataSchemaStatements.add(mock(Statement.class));
-    }
-
     Statement mockedCreateNamespacesTableStatement = mock(Statement.class);
 
-    if (!mockedCreateMetadataSchemaStatements.isEmpty()) {
-      when(connection.createStatement())
-          .thenReturn(mockedNamespacesTableExistsStatement)
-          .thenReturn(
-              mockedCreateMetadataSchemaStatements.get(0),
-              mockedCreateMetadataSchemaStatements
-                  .subList(1, mockedCreateMetadataSchemaStatements.size())
-                  .toArray(new Statement[0]))
-          .thenReturn(mockedCreateNamespacesTableStatement);
-    } else {
-      when(connection.createStatement())
-          .thenReturn(mockedNamespacesTableExistsStatement)
-          .thenReturn(mockedCreateNamespacesTableStatement);
-    }
-
-    List<Statement> statementsMock =
-        ImmutableList.<Statement>builder()
-            .add(mockedNamespacesTableExistsStatement)
-            .addAll(mockedCreateMetadataSchemaStatements)
-            .add(mockedCreateNamespacesTableStatement)
-            .build();
     when(connection.createStatement())
-        .thenReturn(
-            statementsMock.get(0),
-            statementsMock.subList(1, statementsMock.size()).toArray(new Statement[0]));
+        .thenReturn(mockedNamespacesTableExistsStatement, mockedCreateNamespacesTableStatement);
 
     PreparedStatement mockedInsertNamespaceStatement = mock(PreparedStatement.class);
     when(connection.prepareStatement(insertNamespaceSql))
@@ -4534,9 +4520,6 @@ public void upsertIntoNamespacesTable_ForExistingNamespace_ShouldNotThrowExcepti
 
     // Assert
     verify(mockedNamespacesTableExistsStatement).execute(namespacesTableExistsSql);
-    for (int i = 0; i < createMetadataSchemaSqls.size(); i++) {
-      verify(mockedCreateMetadataSchemaStatements.get(i)).execute(createMetadataSchemaSqls.get(i));
-    }
     verify(mockedCreateNamespacesTableStatement).execute(createNamespacesTableSql);
     verify(mockedInsertNamespaceStatement).setString(1, METADATA_SCHEMA);
     verify(mockedInsertNamespaceStatement).execute();