diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ConstantFoldingRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ConstantFoldingRule.java
index 3b39d7c..256d481 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ConstantFoldingRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ConstantFoldingRule.java
@@ -148,7 +148,7 @@
     private static final IOperatorSchema[] _emptySchemas = new IOperatorSchema[] {};
 
     public ConstantFoldingRule(ICcApplicationContext appCtx) {
-        MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         jobGenCtx = new JobGenContext(null, metadataProvider, appCtx, SerializerDeserializerProvider.INSTANCE,
                 BinaryHashFunctionFactoryProvider.INSTANCE, BinaryHashFunctionFamilyProvider.INSTANCE,
                 BinaryComparatorFactoryProvider.INSTANCE, TypeTraitProvider.INSTANCE, BinaryBooleanInspector.FACTORY,
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FullTextContainsParameterCheckAndSetRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FullTextContainsParameterCheckAndSetRule.java
index 91c15df..531bd8a 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FullTextContainsParameterCheckAndSetRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FullTextContainsParameterCheckAndSetRule.java
@@ -24,8 +24,8 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.metadata.declared.MetadataProvider;
-import org.apache.asterix.metadata.entities.Dataverse;
 import org.apache.asterix.metadata.utils.FullTextUtil;
 import org.apache.asterix.om.base.ARecord;
 import org.apache.asterix.om.base.AString;
@@ -186,9 +186,9 @@
                 }
 
                 MetadataProvider metadataProvider = (MetadataProvider) context.getMetadataProvider();
-                Dataverse defaultDataverse = metadataProvider.getDefaultDataverse();
-                String database = defaultDataverse.getDatabaseName();
-                DataverseName dataverseName = defaultDataverse.getDataverseName();
+                Namespace defaultNamespace = metadataProvider.getDefaultNamespace();
+                String database = defaultNamespace.getDatabaseName();
+                DataverseName dataverseName = defaultNamespace.getDataverseName();
                 funcExpr.setOpaqueParameters(
                         new Object[] { FullTextUtil.fetchFilterAndCreateConfigEvaluator(metadataProvider, database,
                                 dataverseName, ftConfigName) });
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java
index 64b0a71..0a0685d 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java
@@ -40,6 +40,7 @@
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.MetadataConstants;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.statement.AnalyzeDropStatement;
 import org.apache.asterix.lang.common.statement.AnalyzeStatement;
@@ -64,7 +65,6 @@
 import org.apache.asterix.lang.common.statement.TypeDropStatement;
 import org.apache.asterix.lang.common.statement.UpsertStatement;
 import org.apache.asterix.metadata.dataset.hints.DatasetHints;
-import org.apache.asterix.metadata.entities.Dataverse;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
 import org.apache.hyracks.algebricks.common.utils.Pair;
@@ -89,7 +89,7 @@
     protected static final String BAD_DATAVERSE_OBJECT_DDL_MESSAGE =
             "Cannot %s a %s belonging to the " + dataverse() + ": %s";
 
-    public void validateOperation(ICcApplicationContext appCtx, Dataverse defaultDataverse, Statement stmt)
+    public void validateOperation(ICcApplicationContext appCtx, Namespace namespace, Statement stmt)
             throws AlgebricksException {
 
         final IClusterStateManager clusterStateManager = appCtx.getClusterStateManager();
@@ -148,7 +148,7 @@
 
         boolean invalidOperation = false;
         String message = null;
-        DataverseName dataverseName = defaultDataverse != null ? defaultDataverse.getDataverseName() : null;
+        DataverseName dataverseName = namespace != null ? namespace.getDataverseName() : null;
         switch (stmt.getKind()) {
             case LOAD:
                 LoadStatement loadStmt = (LoadStatement) stmt;
@@ -227,6 +227,7 @@
                 break;
 
             case DATAVERSE_DROP:
+                //TODO(DB): check it's not System database for all cases
                 DataverseDropStatement dvDropStmt = (DataverseDropStatement) stmt;
                 dataverseName = dvDropStmt.getDataverseName();
                 invalidOperation = isMetadataDataverse(dataverseName) || isDefaultDataverse(dataverseName);
@@ -236,6 +237,7 @@
                 break;
 
             case DATASET_DECL:
+                //TODO(DB): check it's not System database for all cases
                 DatasetDecl dsCreateStmt = (DatasetDecl) stmt;
                 if (dsCreateStmt.getDataverse() != null) {
                     dataverseName = dsCreateStmt.getDataverse();
@@ -268,6 +270,7 @@
                 break;
 
             case DATASET_DROP:
+                //TODO(DB): check it's not System database for all cases
                 DropDatasetStatement dsDropStmt = (DropDatasetStatement) stmt;
                 if (dsDropStmt.getDataverseName() != null) {
                     dataverseName = dsDropStmt.getDataverseName();
@@ -279,6 +282,7 @@
                 break;
 
             case INDEX_DROP:
+                //TODO(DB): check it's not System database for all cases
                 IndexDropStatement idxDropStmt = (IndexDropStatement) stmt;
                 if (idxDropStmt.getDataverseName() != null) {
                     dataverseName = idxDropStmt.getDataverseName();
@@ -290,6 +294,7 @@
                 break;
 
             case TYPE_DECL:
+                //TODO(DB): check it's not System database for all cases
                 TypeDecl typeCreateStmt = (TypeDecl) stmt;
                 if (typeCreateStmt.getDataverseName() != null) {
                     dataverseName = typeCreateStmt.getDataverseName();
@@ -301,6 +306,7 @@
                 break;
 
             case TYPE_DROP:
+                //TODO(DB): check it's not System database for all cases
                 TypeDropStatement typeDropStmt = (TypeDropStatement) stmt;
                 if (typeDropStmt.getDataverseName() != null) {
                     dataverseName = typeDropStmt.getDataverseName();
@@ -312,6 +318,7 @@
                 break;
 
             case CREATE_SYNONYM:
+                //TODO(DB): check it's not System database for all cases
                 CreateSynonymStatement synCreateStmt = (CreateSynonymStatement) stmt;
                 if (synCreateStmt.getDataverseName() != null) {
                     dataverseName = synCreateStmt.getDataverseName();
@@ -323,6 +330,7 @@
                 break;
 
             case FUNCTION_DECL:
+                //TODO(DB): check it's not System database for all cases
                 FunctionDecl fnDeclStmt = (FunctionDecl) stmt;
                 FunctionSignature fnDeclSignature = fnDeclStmt.getSignature();
                 if (fnDeclSignature.getDataverseName() != null) {
@@ -335,6 +343,7 @@
                 break;
 
             case CREATE_FUNCTION:
+                //TODO(DB): check it's not System database for all cases
                 CreateFunctionStatement fnCreateStmt = (CreateFunctionStatement) stmt;
                 FunctionSignature fnCreateSignature = fnCreateStmt.getFunctionSignature();
                 if (fnCreateSignature.getDataverseName() != null) {
@@ -347,6 +356,7 @@
                 break;
 
             case CREATE_LIBRARY:
+                //TODO(DB): check it's not System database for all cases
                 CreateLibraryStatement libCreateStmt = (CreateLibraryStatement) stmt;
                 if (libCreateStmt.getDataverseName() != null) {
                     dataverseName = libCreateStmt.getDataverseName();
@@ -358,6 +368,7 @@
                 break;
 
             case CREATE_ADAPTER:
+                //TODO(DB): check it's not System database for all cases
                 CreateAdapterStatement adCreateStmt = (CreateAdapterStatement) stmt;
                 if (adCreateStmt.getDataverseName() != null) {
                     dataverseName = adCreateStmt.getDataverseName();
@@ -369,6 +380,7 @@
                 break;
 
             case CREATE_VIEW:
+                //TODO(DB): check it's not System database for all cases
                 CreateViewStatement viewCreateStmt = (CreateViewStatement) stmt;
                 if (viewCreateStmt.getDataverseName() != null) {
                     dataverseName = viewCreateStmt.getDataverseName();
@@ -380,6 +392,7 @@
                 break;
 
             case CREATE_FEED:
+                //TODO(DB): check it's not System database for all cases
                 CreateFeedStatement feedCreateStmt = (CreateFeedStatement) stmt;
                 if (feedCreateStmt.getDataverseName() != null) {
                     dataverseName = feedCreateStmt.getDataverseName();
@@ -391,6 +404,7 @@
                 break;
 
             case CREATE_FEED_POLICY:
+                //TODO(DB): check it's not System database for all cases
                 invalidOperation = isMetadataDataverse(dataverseName);
                 if (invalidOperation) {
                     message = String.format(BAD_DATAVERSE_OBJECT_DDL_MESSAGE, "create", "ingestion policy",
@@ -399,6 +413,7 @@
                 break;
 
             case ANALYZE:
+                //TODO(DB): check it's not System database for all cases
                 AnalyzeStatement analyzeStmt = (AnalyzeStatement) stmt;
                 if (analyzeStmt.getDataverseName() != null) {
                     dataverseName = analyzeStmt.getDataverseName();
@@ -409,6 +424,7 @@
                 }
                 break;
             case ANALYZE_DROP:
+                //TODO(DB): check it's not System database for all cases
                 AnalyzeDropStatement analyzeDropStmt = (AnalyzeDropStatement) stmt;
                 if (analyzeDropStmt.getDataverseName() != null) {
                     dataverseName = analyzeDropStmt.getDataverseName();
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java
index 3733970..012df01 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java
@@ -191,6 +191,8 @@
 
     public interface ICompiledDmlStatement extends ICompiledStatement {
 
+        String getDatabaseName();
+
         DataverseName getDataverseName();
 
         String getDatasetName();
@@ -218,6 +220,11 @@
             return index.getDataverseName();
         }
 
+        @Override
+        public String getDatabaseName() {
+            return index.getDatabaseName();
+        }
+
         public Index getIndex() {
             return index;
         }
@@ -239,14 +246,17 @@
 
     public static class CompiledLoadFromFileStatement extends AbstractCompiledStatement
             implements ICompiledDmlStatement {
+
+        private final String databaseName;
         private final DataverseName dataverseName;
         private final String datasetName;
         private final boolean alreadySorted;
         private final String adapter;
         private final Map<String, String> properties;
 
-        public CompiledLoadFromFileStatement(DataverseName dataverseName, String datasetName, String adapter,
-                Map<String, String> properties, boolean alreadySorted) {
+        public CompiledLoadFromFileStatement(String databaseName, DataverseName dataverseName, String datasetName,
+                String adapter, Map<String, String> properties, boolean alreadySorted) {
+            this.databaseName = databaseName;
             this.dataverseName = dataverseName;
             this.datasetName = datasetName;
             this.alreadySorted = alreadySorted;
@@ -255,6 +265,11 @@
         }
 
         @Override
+        public String getDatabaseName() {
+            return databaseName;
+        }
+
+        @Override
         public DataverseName getDataverseName() {
             return dataverseName;
         }
@@ -289,14 +304,17 @@
 
     public static class CompiledCopyFromFileStatement extends AbstractCompiledStatement
             implements ICompiledDmlStatement {
+
+        private final String databaseName;
         private final DataverseName dataverseName;
         private final String datasetName;
         private final Datatype itemType;
         private final String adapter;
         private final Map<String, String> properties;
 
-        public CompiledCopyFromFileStatement(DataverseName dataverseName, String datasetName, Datatype itemType,
-                String adapter, Map<String, String> properties) {
+        public CompiledCopyFromFileStatement(String databaseName, DataverseName dataverseName, String datasetName,
+                Datatype itemType, String adapter, Map<String, String> properties) {
+            this.databaseName = databaseName;
             this.dataverseName = dataverseName;
             this.datasetName = datasetName;
             this.itemType = itemType;
@@ -305,6 +323,11 @@
         }
 
         @Override
+        public String getDatabaseName() {
+            return databaseName;
+        }
+
+        @Override
         public DataverseName getDataverseName() {
             return dataverseName;
         }
@@ -338,6 +361,8 @@
     }
 
     public static class CompiledInsertStatement extends AbstractCompiledStatement implements ICompiledDmlStatement {
+
+        private final String databaseName;
         private final DataverseName dataverseName;
         private final String datasetName;
         private final Query query;
@@ -345,8 +370,9 @@
         private final VariableExpr var;
         private final Expression returnExpression;
 
-        public CompiledInsertStatement(DataverseName dataverseName, String datasetName, Query query, int varCounter,
-                VariableExpr var, Expression returnExpression) {
+        public CompiledInsertStatement(String databaseName, DataverseName dataverseName, String datasetName,
+                Query query, int varCounter, VariableExpr var, Expression returnExpression) {
+            this.databaseName = databaseName;
             this.dataverseName = dataverseName;
             this.datasetName = datasetName;
             this.query = query;
@@ -356,6 +382,11 @@
         }
 
         @Override
+        public String getDatabaseName() {
+            return databaseName;
+        }
+
+        @Override
         public DataverseName getDataverseName() {
             return dataverseName;
         }
@@ -394,9 +425,9 @@
 
     public static class CompiledUpsertStatement extends CompiledInsertStatement {
 
-        public CompiledUpsertStatement(DataverseName dataverseName, String datasetName, Query query, int varCounter,
-                VariableExpr var, Expression returnExpression) {
-            super(dataverseName, datasetName, query, varCounter, var, returnExpression);
+        public CompiledUpsertStatement(String databaseName, DataverseName dataverseName, String datasetName,
+                Query query, int varCounter, VariableExpr var, Expression returnExpression) {
+            super(databaseName, dataverseName, datasetName, query, varCounter, var, returnExpression);
         }
 
         @Override
@@ -408,7 +439,7 @@
     public static class CompiledSubscribeFeedStatement extends AbstractCompiledStatement
             implements ICompiledDmlStatement {
 
-        private FeedConnectionRequest request;
+        private final FeedConnectionRequest request;
         private final int varCounter;
 
         public CompiledSubscribeFeedStatement(FeedConnectionRequest request, int varCounter) {
@@ -417,6 +448,11 @@
         }
 
         @Override
+        public String getDatabaseName() {
+            return request.getReceivingFeedId().getDatabaseName();
+        }
+
+        @Override
         public DataverseName getDataverseName() {
             return request.getReceivingFeedId().getDataverseName();
         }
@@ -446,14 +482,17 @@
     }
 
     public static class CompiledDeleteStatement extends AbstractCompiledStatement implements ICompiledDmlStatement {
+
+        private final String databaseName;
         private final DataverseName dataverseName;
         private final String datasetName;
         private final Expression condition;
         private final int varCounter;
         private final Query query;
 
-        public CompiledDeleteStatement(VariableExpr var, DataverseName dataverseName, String datasetName,
-                Expression condition, int varCounter, Query query) {
+        public CompiledDeleteStatement(VariableExpr var, String databaseName, DataverseName dataverseName,
+                String datasetName, Expression condition, int varCounter, Query query) {
+            this.databaseName = databaseName;
             this.dataverseName = dataverseName;
             this.datasetName = datasetName;
             this.condition = condition;
@@ -462,6 +501,11 @@
         }
 
         @Override
+        public String getDatabaseName() {
+            return databaseName;
+        }
+
+        @Override
         public String getDatasetName() {
             return datasetName;
         }
@@ -495,14 +539,21 @@
     }
 
     public static class CompiledCompactStatement extends AbstractCompiledStatement {
+
+        private final String databaseName;
         private final DataverseName dataverseName;
         private final String datasetName;
 
-        public CompiledCompactStatement(DataverseName dataverseName, String datasetName) {
+        public CompiledCompactStatement(String databaseName, DataverseName dataverseName, String datasetName) {
+            this.databaseName = databaseName;
             this.dataverseName = dataverseName;
             this.datasetName = datasetName;
         }
 
+        public String getDatabaseName() {
+            return databaseName;
+        }
+
         public DataverseName getDataverseName() {
             return dataverseName;
         }
@@ -518,11 +569,11 @@
     }
 
     public static class CompiledIndexCompactStatement extends CompiledCompactStatement {
-        private Dataset dataset;
-        private Index index;
+        private final Dataset dataset;
+        private final Index index;
 
         public CompiledIndexCompactStatement(Dataset dataset, Index index) {
-            super(dataset.getDataverseName(), dataset.getDatasetName());
+            super(dataset.getDatabaseName(), dataset.getDataverseName(), dataset.getDatasetName());
             this.dataset = dataset;
             this.index = index;
         }
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutor.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutor.java
index b47d45d..0c9ce42 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutor.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutor.java
@@ -35,7 +35,7 @@
 import org.apache.asterix.common.api.IResponsePrinter;
 import org.apache.asterix.common.exceptions.ACIDException;
 import org.apache.asterix.common.exceptions.AsterixException;
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.statement.Query;
 import org.apache.asterix.metadata.declared.MetadataProvider;
@@ -290,15 +290,7 @@
             Query query, ICompiledDmlStatement dmlStatement, Map<String, IAObject> statementParameters,
             IRequestParameters requestParameters) throws RemoteException, AlgebricksException, ACIDException;
 
-    /**
-     * returns the active dataverse for an entity or a statement
-     *
-     * @param dataverseName:
-     *            the entity or statement dataverse
-     * @return
-     *         returns the passed dataverse if not null, the active dataverse otherwise
-     */
-    DataverseName getActiveDataverseName(DataverseName dataverseName);
+    Namespace getActiveNamespace(Namespace namespace);
 
     /**
      * Gets the execution plans that are generated during query compilation
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/LangExpressionToPlanTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/LangExpressionToPlanTranslator.java
index f0dff9d..d156b25 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/LangExpressionToPlanTranslator.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/LangExpressionToPlanTranslator.java
@@ -40,7 +40,6 @@
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
-import org.apache.asterix.common.metadata.MetadataUtil;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Expression.Kind;
 import org.apache.asterix.lang.common.base.ILangExpression;
@@ -198,8 +197,8 @@
 
     public ILogicalPlan translateCopyOrLoad(ICompiledDmlStatement stmt) throws AlgebricksException {
         SourceLocation sourceLoc = stmt.getSourceLocation();
-        String database = MetadataUtil.resolveDatabase(null, stmt.getDataverseName());
-        Dataset dataset = metadataProvider.findDataset(database, stmt.getDataverseName(), stmt.getDatasetName());
+        Dataset dataset =
+                metadataProvider.findDataset(stmt.getDatabaseName(), stmt.getDataverseName(), stmt.getDatasetName());
         if (dataset == null) {
             // This would never happen since we check for this in AqlTranslator
             throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, stmt.getDatasetName(),
@@ -211,8 +210,8 @@
                 dataset.getMetaItemTypeDataverseName(), dataset.getMetaItemTypeName());
         itemType = metadataProvider.findTypeForDatasetWithoutType(itemType, metaItemType, dataset);
 
-        DatasetDataSource targetDatasource = validateDatasetInfo(metadataProvider, database, stmt.getDataverseName(),
-                stmt.getDatasetName(), sourceLoc);
+        DatasetDataSource targetDatasource = validateDatasetInfo(metadataProvider, stmt.getDatabaseName(),
+                stmt.getDataverseName(), stmt.getDatasetName(), sourceLoc);
         List<List<String>> partitionKeys = targetDatasource.getDataset().getPrimaryKeys();
         if (dataset.hasMetaPart()) {
             throw new CompilationException(ErrorCode.ILLEGAL_DML_OPERATION, sourceLoc, dataset.getDatasetName(),
@@ -415,8 +414,7 @@
             ProjectOperator projectOperator = (ProjectOperator) topOp;
             projectOperator.getVariables().set(0, seqVar);
 
-            String databaseName = MetadataUtil.resolveDatabase(null, stmt.getDataverseName());
-            DatasetDataSource targetDatasource = validateDatasetInfo(metadataProvider, databaseName,
+            DatasetDataSource targetDatasource = validateDatasetInfo(metadataProvider, stmt.getDatabaseName(),
                     stmt.getDataverseName(), stmt.getDatasetName(), sourceLoc);
             List<Integer> keySourceIndicator =
                     ((InternalDatasetDetails) targetDatasource.getDataset().getDatasetDetails())
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/TypeTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/TypeTranslator.java
index c45013d..ce30325 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/TypeTranslator.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/TypeTranslator.java
@@ -32,7 +32,7 @@
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.MetadataConstants;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.expression.OrderedListTypeDefinition;
 import org.apache.asterix.lang.common.expression.RecordTypeDefinition;
 import org.apache.asterix.lang.common.expression.RecordTypeDefinition.RecordKind;
@@ -63,24 +63,25 @@
     private TypeTranslator() {
     }
 
-    public static Map<TypeSignature, IAType> computeTypes(DataverseName typeDataverse, String typeName,
-            TypeExpression typeExpr, DataverseName defaultDataverse, MetadataTransactionContext mdTxnCtx)
-            throws AlgebricksException {
+    public static Map<TypeSignature, IAType> computeTypes(String typeDatabase, DataverseName typeDataverse,
+            String typeName, TypeExpression typeExpr, String defaultDatabase, DataverseName defaultDataverse,
+            MetadataTransactionContext mdTxnCtx) throws AlgebricksException {
         Map<TypeSignature, IAType> typeMap = new HashMap<>();
-        computeTypes(typeDataverse, typeName, typeExpr, defaultDataverse, mdTxnCtx, typeMap);
+        computeTypes(typeDatabase, typeDataverse, typeName, typeExpr, defaultDatabase, defaultDataverse, mdTxnCtx,
+                typeMap);
         return typeMap;
     }
 
-    public static void computeTypes(DataverseName typeDataverse, String typeName, TypeExpression typeExpr,
-            DataverseName defaultDataverse, MetadataTransactionContext mdTxnCtx, Map<TypeSignature, IAType> outTypeMap)
-            throws AlgebricksException {
+    public static void computeTypes(String typeDatabase, DataverseName typeDataverse, String typeName,
+            TypeExpression typeExpr, String defaultDatabase, DataverseName defaultDataverse,
+            MetadataTransactionContext mdTxnCtx, Map<TypeSignature, IAType> outTypeMap) throws AlgebricksException {
         Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes = new HashMap<>();
         Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes = new HashMap<>();
         Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences = new HashMap<>();
-        firstPass(typeDataverse, typeName, typeExpr, outTypeMap, incompleteFieldTypes, incompleteItemTypes,
-                incompleteTopLevelTypeReferences, typeDataverse);
+        firstPass(typeDatabase, typeDataverse, typeName, typeExpr, outTypeMap, incompleteFieldTypes,
+                incompleteItemTypes, incompleteTopLevelTypeReferences, typeDatabase, typeDataverse);
         secondPass(mdTxnCtx, outTypeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences,
-                typeDataverse, typeExpr.getSourceLocation());
+                typeDatabase, typeDataverse, typeExpr.getSourceLocation());
 
         for (IAType type : outTypeMap.values()) {
             if (type.getTypeTag().isDerivedType()) {
@@ -89,21 +90,22 @@
         }
     }
 
-    private static void firstPass(DataverseName typeDataverse, String typeName, TypeExpression typeExpr,
-            Map<TypeSignature, IAType> outTypeMap, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
+    private static void firstPass(String typeDatabase, DataverseName typeDataverse, String typeName,
+            TypeExpression typeExpr, Map<TypeSignature, IAType> outTypeMap,
+            Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
             Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
-            Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, DataverseName defaultDataverse)
-            throws AlgebricksException {
+            Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String defaultDatabase,
+            DataverseName defaultDataverse) throws AlgebricksException {
 
         if (BuiltinTypeMap.getBuiltinType(typeName) != null) {
             throw new CompilationException(ErrorCode.COMPILATION_ERROR, typeExpr.getSourceLocation(),
                     "Cannot redefine builtin type " + typeName);
         }
-        TypeSignature typeSignature = new TypeSignature(typeDataverse, typeName);
+        TypeSignature typeSignature = new TypeSignature(typeDatabase, typeDataverse, typeName);
         switch (typeExpr.getTypeKind()) {
             case TYPEREFERENCE: {
                 TypeReferenceExpression tre = (TypeReferenceExpression) typeExpr;
-                TypeSignature treSignature = createTypeSignature(tre, defaultDataverse);
+                TypeSignature treSignature = createTypeSignature(tre, defaultDatabase, defaultDataverse);
                 IAType t = solveTypeReference(treSignature, outTypeMap);
                 if (t != null) {
                     outTypeMap.put(typeSignature, t);
@@ -115,21 +117,21 @@
             case RECORD: {
                 RecordTypeDefinition rtd = (RecordTypeDefinition) typeExpr;
                 ARecordType recType = computeRecordType(typeSignature, rtd, outTypeMap, incompleteFieldTypes,
-                        incompleteItemTypes, typeDataverse);
+                        incompleteItemTypes, typeDatabase, typeDataverse);
                 outTypeMap.put(typeSignature, recType);
                 break;
             }
             case ORDEREDLIST: {
                 OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) typeExpr;
                 AOrderedListType olType = computeOrderedListType(typeSignature, oltd, outTypeMap, incompleteItemTypes,
-                        incompleteFieldTypes, typeDataverse);
+                        incompleteFieldTypes, typeDatabase, typeDataverse);
                 outTypeMap.put(typeSignature, olType);
                 break;
             }
             case UNORDEREDLIST: {
                 UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) typeExpr;
                 AUnorderedListType ulType = computeUnorderedListType(typeSignature, ultd, outTypeMap,
-                        incompleteItemTypes, incompleteFieldTypes, typeDataverse);
+                        incompleteItemTypes, incompleteFieldTypes, typeDatabase, typeDataverse);
                 outTypeMap.put(typeSignature, ulType);
                 break;
             }
@@ -142,8 +144,8 @@
     private static void secondPass(MetadataTransactionContext mdTxnCtx, Map<TypeSignature, IAType> typeMap,
             Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
             Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
-            Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, DataverseName typeDataverse,
-            SourceLocation sourceLoc) throws AlgebricksException {
+            Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String typeDatabase,
+            DataverseName typeDataverse, SourceLocation sourceLoc) throws AlgebricksException {
         // solve remaining top level references
         for (TypeSignature typeSignature : incompleteTopLevelTypeReferences.keySet()) {
             IAType t;
@@ -161,7 +163,6 @@
         // solve remaining field type references
         for (String trefName : incompleteFieldTypes.keySet()) {
             IAType t;
-            String typeDatabase = MetadataUtil.resolveDatabase(null, typeDataverse);
             Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeDatabase, typeDataverse, trefName);
             if (dt == null) {
                 dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, MetadataConstants.SYSTEM_DATABASE,
@@ -209,61 +210,64 @@
 
     private static AOrderedListType computeOrderedListType(TypeSignature typeSignature, OrderedListTypeDefinition oltd,
             Map<TypeSignature, IAType> typeMap, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
-            Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, DataverseName defaultDataverse)
-            throws AlgebricksException {
+            Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaultDatabase,
+            DataverseName defaultDataverse) throws AlgebricksException {
         TypeExpression tExpr = oltd.getItemTypeExpression();
         String typeName = typeSignature != null ? typeSignature.getName() : null;
         AOrderedListType aolt = new AOrderedListType(ANY, typeName);
-        setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, aolt, defaultDataverse);
+        setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, aolt, defaultDatabase,
+                defaultDataverse);
         return aolt;
     }
 
     private static AUnorderedListType computeUnorderedListType(TypeSignature typeSignature,
             UnorderedListTypeDefinition ultd, Map<TypeSignature, IAType> typeMap,
             Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
-            Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, DataverseName defaulDataverse)
-            throws AlgebricksException {
+            Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaultDatabase,
+            DataverseName defaultDataverse) throws AlgebricksException {
         TypeExpression tExpr = ultd.getItemTypeExpression();
         String typeName = typeSignature != null ? typeSignature.getName() : null;
         AUnorderedListType ault = new AUnorderedListType(ANY, typeName);
-        setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, ault, defaulDataverse);
+        setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, ault, defaultDatabase,
+                defaultDataverse);
         return ault;
     }
 
     private static void setCollectionItemType(TypeExpression tExpr, Map<TypeSignature, IAType> typeMap,
             Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
             Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, AbstractCollectionType act,
-            DataverseName defaultDataverse) throws AlgebricksException {
+            String defaultDatabase, DataverseName defaultDataverse) throws AlgebricksException {
         switch (tExpr.getTypeKind()) {
             case ORDEREDLIST: {
                 OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) tExpr;
                 IAType t = computeOrderedListType(null, oltd, typeMap, incompleteItemTypes, incompleteFieldTypes,
-                        defaultDataverse);
+                        defaultDatabase, defaultDataverse);
                 act.setItemType(t);
                 break;
             }
             case UNORDEREDLIST: {
                 UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) tExpr;
                 IAType t = computeUnorderedListType(null, ultd, typeMap, incompleteItemTypes, incompleteFieldTypes,
-                        defaultDataverse);
+                        defaultDatabase, defaultDataverse);
                 act.setItemType(t);
                 break;
             }
             case RECORD: {
                 RecordTypeDefinition rtd = (RecordTypeDefinition) tExpr;
                 IAType t = computeRecordType(null, rtd, typeMap, incompleteFieldTypes, incompleteItemTypes,
-                        defaultDataverse);
+                        defaultDatabase, defaultDataverse);
                 act.setItemType(t);
                 break;
             }
             case TYPEREFERENCE: {
                 TypeReferenceExpression tre = (TypeReferenceExpression) tExpr;
-                TypeSignature treSignature = createTypeSignature(tre, defaultDataverse);
+                TypeSignature treSignature = createTypeSignature(tre, defaultDatabase, defaultDataverse);
                 IAType tref = solveTypeReference(treSignature, typeMap);
                 if (tref != null) {
                     act.setItemType(tref);
                 } else {
-                    addIncompleteCollectionTypeReference(act, tre, incompleteItemTypes, defaultDataverse);
+                    addIncompleteCollectionTypeReference(act, tre, incompleteItemTypes, defaultDatabase,
+                            defaultDataverse);
                 }
                 break;
             }
@@ -275,8 +279,8 @@
 
     private static void addIncompleteCollectionTypeReference(AbstractCollectionType collType,
             TypeReferenceExpression tre, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
-            DataverseName defaultDataverse) {
-        TypeSignature typeSignature = createTypeSignature(tre, defaultDataverse);
+            String defaultDatabase, DataverseName defaultDataverse) {
+        TypeSignature typeSignature = createTypeSignature(tre, defaultDatabase, defaultDataverse);
         List<AbstractCollectionType> typeList =
                 incompleteItemTypes.computeIfAbsent(typeSignature, k -> new ArrayList<>());
         typeList.add(collType);
@@ -308,8 +312,8 @@
 
     private static ARecordType computeRecordType(TypeSignature typeSignature, RecordTypeDefinition rtd,
             Map<TypeSignature, IAType> typeMap, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
-            Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, DataverseName defaultDataverse)
-            throws AlgebricksException {
+            Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, String defaultDatabase,
+            DataverseName defaultDataverse) throws AlgebricksException {
         List<String> names = rtd.getFieldNames();
         int n = names.size();
         String[] fldNames = new String[n];
@@ -338,7 +342,7 @@
             switch (texpr.getTypeKind()) {
                 case TYPEREFERENCE: {
                     TypeReferenceExpression tre = (TypeReferenceExpression) texpr;
-                    TypeSignature signature = createTypeSignature(tre, defaultDataverse);
+                    TypeSignature signature = createTypeSignature(tre, defaultDatabase, defaultDataverse);
                     type = solveTypeReference(signature, typeMap);
                     if (type == null) {
                         addIncompleteFieldTypeReference(recType, j, tre, incompleteFieldTypes);
@@ -348,19 +352,19 @@
                 case RECORD: {
                     RecordTypeDefinition recTypeDef2 = (RecordTypeDefinition) texpr;
                     type = computeRecordType(null, recTypeDef2, typeMap, incompleteFieldTypes, incompleteItemTypes,
-                            defaultDataverse);
+                            defaultDatabase, defaultDataverse);
                     break;
                 }
                 case ORDEREDLIST: {
                     OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) texpr;
                     type = computeOrderedListType(null, oltd, typeMap, incompleteItemTypes, incompleteFieldTypes,
-                            defaultDataverse);
+                            defaultDatabase, defaultDataverse);
                     break;
                 }
                 case UNORDEREDLIST: {
                     UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) texpr;
                     type = computeUnorderedListType(null, ultd, typeMap, incompleteItemTypes, incompleteFieldTypes,
-                            defaultDataverse);
+                            defaultDatabase, defaultDataverse);
                     break;
                 }
                 default: {
@@ -376,9 +380,18 @@
         return recType;
     }
 
-    private static TypeSignature createTypeSignature(TypeReferenceExpression tre, DataverseName defaultDataverse) {
-        Pair<DataverseName, Identifier> treTypeName = tre.getIdent();
-        DataverseName activeDataverse = treTypeName.first == null ? defaultDataverse : treTypeName.first;
-        return new TypeSignature(activeDataverse, treTypeName.second.getValue());
+    private static TypeSignature createTypeSignature(TypeReferenceExpression tre, String defaultDatabase,
+            DataverseName defaultDataverse) {
+        Pair<Namespace, Identifier> treTypeName = tre.getIdent();
+        DataverseName activeDataverse;
+        String activeDatabase;
+        if (treTypeName.first == null) {
+            activeDataverse = defaultDataverse;
+            activeDatabase = defaultDatabase;
+        } else {
+            activeDataverse = treTypeName.first.getDataverseName();
+            activeDatabase = treTypeName.first.getDatabaseName();
+        }
+        return new TypeSignature(activeDatabase, activeDataverse, treTypeName.second.getValue());
     }
 }
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/AbstractNCUdfServlet.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/AbstractNCUdfServlet.java
index 9c8cc5e..8c5a93b 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/AbstractNCUdfServlet.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/AbstractNCUdfServlet.java
@@ -34,7 +34,7 @@
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.exceptions.RuntimeDataException;
 import org.apache.asterix.common.functions.ExternalFunctionLanguage;
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
@@ -142,16 +142,17 @@
         return field == null || !field.getHttpDataType().equals(InterfaceHttpData.HttpDataType.Attribute);
     }
 
-    protected Pair<DataverseName, String> decodeDvAndLibFromLocalPath(String localPath)
+    protected Pair<Namespace, String> decodeDvAndLibFromLocalPath(String localPath)
             throws RuntimeDataException, AlgebricksException {
         String[] pathSegments = StringUtils.split(localPath, '/');
         if (pathSegments.length != 2) {
             throw RuntimeDataException.create(ErrorCode.PARAMETERS_REQUIRED,
                     "The URL-encoded " + getDataverseKey() + " name and library name in the request path");
         }
-        DataverseName dvName = DataverseName.createFromCanonicalForm(ServletUtil.decodeUriSegment(pathSegments[0]));
+        String namespaceStr = ServletUtil.decodeUriSegment(pathSegments[0]);
+        Namespace namespace = plainAppCtx.getNamespaceResolver().resolve(namespaceStr);
         String libName = ServletUtil.decodeUriSegment(pathSegments[1]);
-        return new Pair<>(dvName, libName);
+        return new Pair<>(namespace, libName);
     }
 
     protected LibraryUploadData decodeMultiPartLibraryOptions(HttpPostRequestDecoder requestDecoder)
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ConnectorApiServlet.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ConnectorApiServlet.java
index 1163716..df27ff4 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ConnectorApiServlet.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ConnectorApiServlet.java
@@ -30,7 +30,7 @@
 
 import org.apache.asterix.common.dataflow.ICcApplicationContext;
 import org.apache.asterix.common.metadata.DataverseName;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.metadata.MetadataManager;
 import org.apache.asterix.metadata.MetadataTransactionContext;
 import org.apache.asterix.metadata.declared.MetadataProvider;
@@ -63,7 +63,7 @@
  */
 public class ConnectorApiServlet extends AbstractServlet {
     private static final Logger LOGGER = LogManager.getLogger();
-    private ICcApplicationContext appCtx;
+    private final ICcApplicationContext appCtx;
 
     public ConnectorApiServlet(ConcurrentMap<String, Object> ctx, String[] paths, ICcApplicationContext appCtx) {
         super(ctx, paths);
@@ -84,24 +84,25 @@
         PrintWriter out = response.writer();
         try {
             ObjectNode jsonResponse = OBJECT_MAPPER.createObjectNode();
-            DataverseName dataverseName = ServletUtil.getDataverseName(request, "dataverseName");
+            Namespace namespace = ServletUtil.getNamespace(appCtx, request, "dataverseName");
             String datasetName = request.getParameter("datasetName");
-            if (dataverseName == null || datasetName == null) {
+            if (namespace == null || datasetName == null) {
                 jsonResponse.put("error", "Parameter dataverseName or datasetName is null,");
                 out.write(jsonResponse.toString());
                 return;
             }
 
-            String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            String databaseName = namespace.getDatabaseName();
+            DataverseName dataverseName = namespace.getDataverseName();
             IHyracksClientConnection hcc = (IHyracksClientConnection) ctx.get(HYRACKS_CONNECTION_ATTR);
             // Metadata transaction begins.
             MetadataManager.INSTANCE.init();
             MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
             // Retrieves file splits of the dataset.
-            MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+            MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
             try {
                 metadataProvider.setMetadataTxnContext(mdTxnCtx);
-                Dataset dataset = metadataProvider.findDataset(database, dataverseName, datasetName);
+                Dataset dataset = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
                 if (dataset == null) {
                     jsonResponse.put("error", StringUtils.capitalize(dataset()) + " " + datasetName
                             + " does not exist in " + dataverse() + " " + dataverseName);
@@ -126,7 +127,7 @@
                         hcc.getNodeControllerInfos());
 
                 // Flush the cached contents of the dataset to file system.
-                FlushDatasetUtil.flushDataset(hcc, metadataProvider, database, dataverseName, datasetName);
+                FlushDatasetUtil.flushDataset(hcc, metadataProvider, databaseName, dataverseName, datasetName);
 
                 // Metadata transaction commits.
                 MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/NCUdfApiServlet.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/NCUdfApiServlet.java
index 47685d8..9698f3b 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/NCUdfApiServlet.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/NCUdfApiServlet.java
@@ -54,6 +54,7 @@
 import org.apache.asterix.common.messaging.api.INCMessageBroker;
 import org.apache.asterix.common.messaging.api.MessageFuture;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.external.util.ExternalLibraryUtils;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.FilenameUtils;
@@ -131,24 +132,23 @@
         return Collections.emptyMap();
     }
 
-    private void doCreate(DataverseName dataverseName, String libraryName, ExternalFunctionLanguage language,
-            String hash, URI downloadURI, boolean replaceIfExists, String sysAuthHeader,
-            IRequestReference requestReference, IServletRequest request) throws Exception {
+    private void doCreate(Namespace libNamespace, String libraryName, ExternalFunctionLanguage language, String hash,
+            URI downloadURI, boolean replaceIfExists, String sysAuthHeader, IRequestReference requestReference,
+            IServletRequest request) throws Exception {
         INCMessageBroker ncMb = (INCMessageBroker) srvCtx.getMessageBroker();
         MessageFuture responseFuture = ncMb.registerMessageFuture();
         CreateLibraryRequestMessage req = new CreateLibraryRequestMessage(srvCtx.getNodeId(),
-                responseFuture.getFutureId(), dataverseName, libraryName, language, hash, downloadURI, replaceIfExists,
+                responseFuture.getFutureId(), libNamespace, libraryName, language, hash, downloadURI, replaceIfExists,
                 sysAuthHeader, requestReference, additionalHttpHeadersFromRequest(request));
         sendMessage(req, responseFuture);
     }
 
-    private void doDrop(DataverseName dataverseName, String libraryName, boolean replaceIfExists,
+    private void doDrop(Namespace namespace, String libraryName, boolean replaceIfExists,
             IRequestReference requestReference, IServletRequest request) throws Exception {
         INCMessageBroker ncMb = (INCMessageBroker) srvCtx.getMessageBroker();
         MessageFuture responseFuture = ncMb.registerMessageFuture();
-        DropLibraryRequestMessage req =
-                new DropLibraryRequestMessage(srvCtx.getNodeId(), responseFuture.getFutureId(), dataverseName,
-                        libraryName, replaceIfExists, requestReference, additionalHttpHeadersFromRequest(request));
+        DropLibraryRequestMessage req = new DropLibraryRequestMessage(srvCtx.getNodeId(), responseFuture.getFutureId(),
+                namespace, libraryName, replaceIfExists, requestReference, additionalHttpHeadersFromRequest(request));
         sendMessage(req, responseFuture);
     }
 
@@ -230,7 +230,10 @@
         HttpPostRequestDecoder requestDecoder = null;
         String localPath = localPath(request);
         try {
-            Pair<DataverseName, String> dvAndName = decodeDvAndLibFromLocalPath(localPath);
+            Pair<Namespace, String> namespaceAndName = decodeDvAndLibFromLocalPath(localPath);
+            String libName = namespaceAndName.second;
+            Namespace libNamespace = namespaceAndName.first;
+            DataverseName libDv = libNamespace.getDataverseName();
             IRequestReference requestReference = receptionist.welcome(request);
             if (op == LibraryOperation.UPSERT) {
                 requestDecoder = new HttpPostRequestDecoder(httpRequest);
@@ -240,7 +243,7 @@
                 libraryTempFile = Files.createTempFile(workingDir, "lib_", '.' + fileExt);
                 if (LOGGER.isDebugEnabled()) {
                     LOGGER.debug("Created temporary file " + libraryTempFile + " for library "
-                            + dvAndName.getFirst().getCanonicalForm() + "." + dvAndName.getSecond());
+                            + libDv.getCanonicalForm() + "." + libName);
                 }
                 MessageDigest digest = MessageDigest.getInstance("MD5");
                 libTmpOut = new FileOutputStream(libraryTempFile.toFile());
@@ -249,12 +252,11 @@
                     IOUtils.copyLarge(ui, os);
                 }
                 URI downloadURI = createDownloadURI(libraryTempFile);
-                doCreate(dvAndName.getFirst(), dvAndName.getSecond(), language,
-                        ExternalLibraryUtils.digestToHexString(digest), downloadURI, true, getSysAuthHeader(),
-                        requestReference, request);
+                doCreate(libNamespace, libName, language, ExternalLibraryUtils.digestToHexString(digest), downloadURI,
+                        true, getSysAuthHeader(), requestReference, request);
             } else if (op == LibraryOperation.DELETE) {
                 //DELETE semantics imply ifExists
-                doDrop(dvAndName.getFirst(), dvAndName.getSecond(), false, requestReference, request);
+                doDrop(libNamespace, libName, false, requestReference, request);
             }
             response.setStatus(HttpResponseStatus.OK);
             PrintWriter responseWriter = response.writer();
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/RebalanceApiServlet.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/RebalanceApiServlet.java
index bfc8208..c730dd0 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/RebalanceApiServlet.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/RebalanceApiServlet.java
@@ -41,7 +41,7 @@
 import org.apache.asterix.common.dataflow.ICcApplicationContext;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.MetadataConstants;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.metadata.MetadataManager;
 import org.apache.asterix.metadata.MetadataTransactionContext;
 import org.apache.asterix.metadata.declared.MetadataProvider;
@@ -110,9 +110,9 @@
     protected void post(IServletRequest request, IServletResponse response) {
         try {
             // Gets dataverse, dataset, and target nodes for rebalance.
-            DataverseName dataverseName;
+            Namespace namespace;
             try {
-                dataverseName = ServletUtil.getDataverseName(request, "dataverseName");
+                namespace = ServletUtil.getNamespace(appCtx, request, "dataverseName");
             } catch (AlgebricksException e) {
                 sendResponse(response, HttpResponseStatus.BAD_REQUEST, e.getMessage());
                 return;
@@ -131,21 +131,27 @@
             }
 
             // If a user gives parameter datasetName, she should give dataverseName as well.
-            if (dataverseName == null && datasetName != null) {
+            if (namespace == null && datasetName != null) {
                 sendResponse(response, HttpResponseStatus.BAD_REQUEST,
                         "to rebalance a particular " + dataset() + ", the parameter dataverseName must be given");
                 return;
             }
 
+            DataverseName dataverseName = null;
+            String databaseName = null;
+            if (namespace != null) {
+                dataverseName = namespace.getDataverseName();
+                databaseName = namespace.getDatabaseName();
+            }
+            //TODO(DB): also check System database
             // Does not allow rebalancing a metadata dataset.
             if (MetadataConstants.METADATA_DATAVERSE_NAME.equals(dataverseName)) {
                 sendResponse(response, HttpResponseStatus.BAD_REQUEST, "cannot rebalance a metadata " + dataset());
                 return;
             }
             // Schedules a rebalance task and wait for its completion.
-            String database = MetadataUtil.resolveDatabase(null, dataverseName);
             CountDownLatch terminated =
-                    scheduleRebalance(database, dataverseName, datasetName, targetNodes, response, forceRebalance);
+                    scheduleRebalance(databaseName, dataverseName, datasetName, targetNodes, response, forceRebalance);
             terminated.await();
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
@@ -263,7 +269,7 @@
     private void rebalanceDataset(String database, DataverseName dataverseName, String datasetName,
             Set<String> targetNodes, boolean force) throws Exception {
         IHyracksClientConnection hcc = (IHyracksClientConnection) ctx.get(HYRACKS_CONNECTION_ATTR);
-        MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         try {
             ActiveNotificationHandler activeNotificationHandler =
                     (ActiveNotificationHandler) appCtx.getActiveNotificationHandler();
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ServletUtil.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ServletUtil.java
index 8d5e4db..a272fbd 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ServletUtil.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/api/http/server/ServletUtil.java
@@ -26,6 +26,7 @@
 
 import org.apache.asterix.common.api.IApplicationContext;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.net.URLCodec;
 import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
@@ -53,6 +54,12 @@
         return !values.isEmpty() ? DataverseName.create(values) : null;
     }
 
+    public static Namespace getNamespace(IApplicationContext appCtx, IServletRequest request,
+            String dataverseParameterName) throws AlgebricksException {
+        List<String> values = request.getParameterValues(dataverseParameterName);
+        return !values.isEmpty() ? appCtx.getNamespaceResolver().resolve(values) : null;
+    }
+
     public static String decodeUriSegment(String uriSegment) {
         try {
             return new String(URLCodec.decodeUrl(uriSegment.getBytes(StandardCharsets.US_ASCII)),
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/ActiveEntityEventsListener.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/ActiveEntityEventsListener.java
index 9b87fc9..8ef756f 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/ActiveEntityEventsListener.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/ActiveEntityEventsListener.java
@@ -119,7 +119,7 @@
         this.statementExecutor = statementExecutor;
         this.appCtx = appCtx;
         this.clusterStateManager = appCtx.getClusterStateManager();
-        this.metadataProvider = MetadataProvider.create(appCtx, null);
+        this.metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         this.hcc = hcc;
         this.entityId = entityId;
         this.datasets = new HashSet<>(datasets);
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/FeedEventsListener.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/FeedEventsListener.java
index a18cd45..3a81c09 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/FeedEventsListener.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/FeedEventsListener.java
@@ -67,7 +67,8 @@
     @Override
     public synchronized boolean remove(Dataset dataset) throws HyracksDataException {
         super.remove(dataset);
-        feedConnections.removeIf(o -> o.getDataverseName().equals(dataset.getDataverseName())
+        feedConnections.removeIf(o -> o.getDatabaseName().equals(dataset.getDatabaseName())
+                && o.getDataverseName().equals(dataset.getDataverseName())
                 && o.getDatasetName().equals(dataset.getDatasetName()));
         return false;
     }
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/RecoveryTask.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/RecoveryTask.java
index f63cc9f..d0a2e74 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/RecoveryTask.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/active/RecoveryTask.java
@@ -55,7 +55,7 @@
             IRetryPolicyFactory retryPolicyFactory) {
         this.listener = listener;
         this.retryPolicyFactory = retryPolicyFactory;
-        this.metadataProvider = MetadataProvider.create(appCtx, null);
+        this.metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         this.clusterStateManager = appCtx.getClusterStateManager();
     }
 
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/CreateLibraryRequestMessage.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/CreateLibraryRequestMessage.java
index f23b6e4..1556b86 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/CreateLibraryRequestMessage.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/CreateLibraryRequestMessage.java
@@ -23,26 +23,26 @@
 
 import org.apache.asterix.common.api.IRequestReference;
 import org.apache.asterix.common.functions.ExternalFunctionLanguage;
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.statement.CreateLibraryStatement;
 
 public final class CreateLibraryRequestMessage extends AbstractInternalRequestMessage {
 
-    final DataverseName dataverseName;
+    final Namespace namespace;
     final String libraryName;
     final ExternalFunctionLanguage lang;
     final String hash;
     final URI location;
     final boolean replaceIfExists;
     final String authToken;
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 2L;
 
-    public CreateLibraryRequestMessage(String nodeRequestId, long requestMessageId, DataverseName dataverseName,
+    public CreateLibraryRequestMessage(String nodeRequestId, long requestMessageId, Namespace namespace,
             String libraryName, ExternalFunctionLanguage lang, String hash, URI location, boolean replaceIfExists,
             String authToken, IRequestReference requestReference, Map<String, String> additionalParams) {
         super(nodeRequestId, requestMessageId, requestReference, additionalParams);
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.libraryName = libraryName;
         this.lang = lang;
         this.hash = hash;
@@ -52,6 +52,6 @@
     }
 
     protected Statement produceStatement() {
-        return new CreateLibraryStatement(dataverseName, libraryName, lang, hash, location, replaceIfExists, authToken);
+        return new CreateLibraryStatement(namespace, libraryName, lang, hash, location, replaceIfExists, authToken);
     }
 }
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/DropLibraryRequestMessage.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/DropLibraryRequestMessage.java
index e7e8931..4fb81c3 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/DropLibraryRequestMessage.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/message/DropLibraryRequestMessage.java
@@ -21,28 +21,28 @@
 import java.util.Map;
 
 import org.apache.asterix.common.api.IRequestReference;
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.statement.LibraryDropStatement;
 
 public final class DropLibraryRequestMessage extends AbstractInternalRequestMessage {
 
-    final DataverseName dataverseName;
+    final Namespace namespace;
     final String libraryName;
     final boolean ifExists;
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 2L;
 
-    public DropLibraryRequestMessage(String nodeRequestId, long requestMessageId, DataverseName dataverseName,
+    public DropLibraryRequestMessage(String nodeRequestId, long requestMessageId, Namespace namespace,
             String libraryName, boolean ifExists, IRequestReference requestReference,
             Map<String, String> additionalParams) {
         super(nodeRequestId, requestMessageId, requestReference, additionalParams);
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.libraryName = libraryName;
         this.ifExists = ifExists;
     }
 
     @Override
     protected Statement produceStatement() {
-        return new LibraryDropStatement(dataverseName, libraryName, ifExists);
+        return new LibraryDropStatement(namespace, libraryName, ifExists);
     }
 }
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java
index 455567d..4b19200 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java
@@ -289,7 +289,7 @@
     protected final ICcApplicationContext appCtx;
     protected final SessionOutput sessionOutput;
     protected final SessionConfig sessionConfig;
-    protected Dataverse activeDataverse;
+    protected Namespace activeNamespace;
     protected final List<FunctionDecl> declaredFunctions;
     protected final ILangCompilationProvider compilationProvider;
     protected final APIFramework apiFramework;
@@ -317,7 +317,7 @@
         declaredFunctions = new ArrayList<>();
         apiFramework = new APIFramework(compilationProvider);
         rewriterFactory = compilationProvider.getRewriterFactory();
-        activeDataverse = MetadataBuiltinEntities.DEFAULT_DATAVERSE;
+        activeNamespace = MetadataBuiltinEntities.DEFAULT_NAMESPACE;
         this.executorService = executorService;
         this.responsePrinter = responsePrinter;
         this.warningCollector = new WarningCollector();
@@ -360,8 +360,8 @@
                 if (sessionConfig.is(SessionConfig.FORMAT_HTML)) {
                     sessionOutput.out().println(ApiServlet.HTML_STATEMENT_SEPARATOR);
                 }
-                validateOperation(appCtx, activeDataverse, stmt);
-                MetadataProvider metadataProvider = MetadataProvider.create(appCtx, activeDataverse);
+                validateOperation(appCtx, activeNamespace, stmt);
+                MetadataProvider metadataProvider = MetadataProvider.create(appCtx, activeNamespace);
                 configureMetadataProvider(metadataProvider, config, resultSetIdCounter, outputFile, requestParameters,
                         stmt);
                 IStatementRewriter stmtRewriter = rewriterFactory.createStatementRewriter();
@@ -373,7 +373,7 @@
                         handleSetStatement(stmt, config);
                         break;
                     case DATAVERSE_DECL:
-                        activeDataverse = handleUseDataverseStatement(metadataProvider, stmt);
+                        activeNamespace = handleUseDataverseStatement(metadataProvider, stmt);
                         break;
                     case CREATE_DATABASE:
                         handleCreateDatabaseStatement(metadataProvider, stmt, requestParameters);
@@ -588,7 +588,7 @@
                 varCounter);
     }
 
-    protected Dataverse handleUseDataverseStatement(MetadataProvider metadataProvider, Statement stmt)
+    protected Namespace handleUseDataverseStatement(MetadataProvider metadataProvider, Statement stmt)
             throws Exception {
         DataverseDecl dvd = (DataverseDecl) stmt;
         DataverseName dvName = dvd.getDataverseName();
@@ -603,15 +603,15 @@
         }
     }
 
-    protected Dataverse doUseDataverseStatement(MetadataProvider metadataProvider, DataverseDecl stmtUseDataverse)
+    protected Namespace doUseDataverseStatement(MetadataProvider metadataProvider, DataverseDecl stmtUseDataverse)
             throws Exception {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
             DataverseName dvName = stmtUseDataverse.getDataverseName();
-            String database = stmtUseDataverse.getDatabaseName();
+            String dbName = stmtUseDataverse.getDatabaseName();
             Dataverse dv =
-                    MetadataManager.INSTANCE.getDataverse(metadataProvider.getMetadataTxnContext(), database, dvName);
+                    MetadataManager.INSTANCE.getDataverse(metadataProvider.getMetadataTxnContext(), dbName, dvName);
             if (dv == null) {
                 if (stmtUseDataverse.getIfExists()) {
                     if (warningCollector.shouldWarn()) {
@@ -619,14 +619,15 @@
                                 Warning.of(stmtUseDataverse.getSourceLocation(), ErrorCode.UNKNOWN_DATAVERSE, dvName));
                     }
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
-                    return activeDataverse;
+                    return activeNamespace;
                 } else {
                     throw new MetadataException(ErrorCode.UNKNOWN_DATAVERSE, stmtUseDataverse.getSourceLocation(),
                             dvName);
                 }
             }
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
-            return dv;
+            //TODO(DB): should the stmt namespace be used?
+            return new Namespace(dv.getDatabaseName(), dv.getDataverseName());
         } catch (Exception e) {
             abort(e, e, mdTxnCtx);
             throw e;
@@ -681,12 +682,12 @@
             IRequestParameters requestParameters) throws Exception {
         CreateDataverseStatement stmtCreateDataverse = (CreateDataverseStatement) stmt;
         DataverseName dvName = stmtCreateDataverse.getDataverseName();
-        String database = MetadataUtil.resolveDatabase(null, dvName);
+        String dbName = stmtCreateDataverse.getDatabaseName();
         metadataProvider.validateDataverseName(dvName, stmtCreateDataverse.getSourceLocation());
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createDataverseBegin(lockManager, metadataProvider.getLocks(), database, dvName);
+        lockUtil.createDataverseBegin(lockManager, metadataProvider.getLocks(), dbName, dvName);
         try {
             doCreateDataverseStatement(metadataProvider, stmtCreateDataverse, requestParameters);
         } finally {
@@ -701,9 +702,9 @@
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
             DataverseName dvName = stmtCreateDataverse.getDataverseName();
-            String database = MetadataUtil.resolveDatabase(null, dvName);
+            String dbName = stmtCreateDataverse.getDatabaseName();
             Dataverse dv =
-                    MetadataManager.INSTANCE.getDataverse(metadataProvider.getMetadataTxnContext(), database, dvName);
+                    MetadataManager.INSTANCE.getDataverse(metadataProvider.getMetadataTxnContext(), dbName, dvName);
             if (dv != null) {
                 if (stmtCreateDataverse.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -714,7 +715,7 @@
                 }
             }
             MetadataManager.INSTANCE.addDataverse(metadataProvider.getMetadataTxnContext(),
-                    new Dataverse(database, dvName, stmtCreateDataverse.getFormat(), MetadataUtil.PENDING_NO_OP));
+                    new Dataverse(dbName, dvName, stmtCreateDataverse.getFormat(), MetadataUtil.PENDING_NO_OP));
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return true;
         } catch (Exception e) {
@@ -765,22 +766,31 @@
         DatasetDecl dd = (DatasetDecl) stmt;
         String datasetName = dd.getName().getValue();
         metadataProvider.validateDatabaseObjectName(dd.getDataverse(), datasetName, stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(dd.getDataverse());
+        Namespace stmtActiveNamespace = getActiveNamespace(dd.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         TypeExpression itemTypeExpr = dd.getItemType();
-        Triple<DataverseName, String, Boolean> itemTypeQualifiedName =
-                extractDatasetItemTypeName(dataverseName, datasetName, itemTypeExpr, false, stmt.getSourceLocation());
-        DataverseName itemTypeDataverseName = itemTypeQualifiedName.first;
+        Triple<Namespace, String, Boolean> itemTypeQualifiedName = extractDatasetItemTypeName(stmtActiveNamespace,
+                datasetName, itemTypeExpr, false, stmt.getSourceLocation());
+        Namespace itemTypeNamespace = itemTypeQualifiedName.first;
+        DataverseName itemTypeDataverseName = itemTypeNamespace.getDataverseName();
+        String itemTypeDatabase = itemTypeNamespace.getDatabaseName();
+
         String itemTypeName = itemTypeQualifiedName.second;
         boolean itemTypeAnonymous = itemTypeQualifiedName.third;
 
         TypeExpression metaItemTypeExpr = dd.getMetaItemType();
+        Namespace metaItemTypeNamespace = null;
         DataverseName metaItemTypeDataverseName = null;
+        String metaItemTypeDatabase = null;
         String metaItemTypeName = null;
         boolean metaItemTypeAnonymous;
         if (metaItemTypeExpr != null) {
-            Triple<DataverseName, String, Boolean> metaItemTypeQualifiedName = extractDatasetItemTypeName(dataverseName,
-                    datasetName, metaItemTypeExpr, true, stmt.getSourceLocation());
-            metaItemTypeDataverseName = metaItemTypeQualifiedName.first;
+            Triple<Namespace, String, Boolean> metaItemTypeQualifiedName = extractDatasetItemTypeName(
+                    stmtActiveNamespace, datasetName, metaItemTypeExpr, true, stmt.getSourceLocation());
+            metaItemTypeNamespace = metaItemTypeQualifiedName.first;
+            metaItemTypeDataverseName = metaItemTypeNamespace.getDataverseName();
+            metaItemTypeDatabase = metaItemTypeNamespace.getDatabaseName();
             metaItemTypeName = metaItemTypeQualifiedName.second;
             metaItemTypeAnonymous = metaItemTypeQualifiedName.third;
         } else {
@@ -794,16 +804,14 @@
         if (isCompileOnly()) {
             return;
         }
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
-        String itemTypeDatabase = MetadataUtil.resolveDatabase(null, itemTypeDataverseName);
-        String metaItemTypeDatabase = MetadataUtil.resolveDatabase(null, metaItemTypeDataverseName);
-        lockUtil.createDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName,
+
+        lockUtil.createDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName,
                 itemTypeDatabase, itemTypeDataverseName, itemTypeName, itemTypeAnonymous, metaItemTypeDatabase,
                 metaItemTypeDataverseName, metaItemTypeName, metaItemTypeAnonymous, nodegroupName, compactionPolicy,
                 defaultCompactionPolicy, dd.getDatasetType(), dd.getDatasetDetailsDecl());
         try {
-            doCreateDatasetStatement(metadataProvider, dd, dataverseName, datasetName, itemTypeDataverseName,
-                    itemTypeExpr, itemTypeName, metaItemTypeExpr, metaItemTypeDataverseName, metaItemTypeName, hcc,
+            doCreateDatasetStatement(metadataProvider, dd, stmtActiveNamespace, datasetName, itemTypeNamespace,
+                    itemTypeExpr, itemTypeName, metaItemTypeExpr, metaItemTypeNamespace, metaItemTypeName, hcc,
                     requestParameters);
             if (dd.getQuery() != null) {
                 final IResultSet resultSet = requestParameters.getResultSet();
@@ -813,7 +821,7 @@
                 final ResultMetadata outMetadata = requestParameters.getOutMetadata();
                 final Map<String, IAObject> stmtParams = requestParameters.getStatementParameters();
                 UpsertStatement upsertStmt =
-                        new UpsertStatement(dataverseName, datasetName, dd.getQuery(), -1, null, null);
+                        new UpsertStatement(stmtActiveNamespace, datasetName, dd.getQuery(), -1, null, null);
                 handleInsertUpsertStatement(metadataProvider, upsertStmt, hcc, resultSet, resultDelivery, outMetadata,
                         stats, requestParameters, stmtParams, stmtRewriter);
             }
@@ -824,13 +832,27 @@
     }
 
     protected Optional<? extends Dataset> doCreateDatasetStatement(MetadataProvider metadataProvider, DatasetDecl dd,
-            DataverseName dataverseName, String datasetName, DataverseName itemTypeDataverseName,
-            TypeExpression itemTypeExpr, String itemTypeName, TypeExpression metaItemTypeExpr,
-            DataverseName metaItemTypeDataverseName, String metaItemTypeName, IHyracksClientConnection hcc,
-            IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
-        String itemTypeDatabase = MetadataUtil.resolveDatabase(null, itemTypeDataverseName);
-        String metaItemDatabase = MetadataUtil.resolveDatabase(null, metaItemTypeDataverseName);
+            Namespace namespace, String datasetName, Namespace itemTypeNamespace, TypeExpression itemTypeExpr,
+            String itemTypeName, TypeExpression metaItemTypeExpr, Namespace metaItemTypeNamespace,
+            String metaItemTypeName, IHyracksClientConnection hcc, IRequestParameters requestParameters)
+            throws Exception {
+        DataverseName dataverseName = namespace.getDataverseName();
+        String databaseName = namespace.getDatabaseName();
+
+        DataverseName itemTypeDataverseName = null;
+        String itemTypeDatabaseName = null;
+        if (itemTypeNamespace != null) {
+            itemTypeDataverseName = itemTypeNamespace.getDataverseName();
+            itemTypeDatabaseName = itemTypeNamespace.getDatabaseName();
+        }
+
+        DataverseName metaItemTypeDataverseName = null;
+        String metaItemTypeDatabaseName = null;
+        if (metaItemTypeNamespace != null) {
+            metaItemTypeDataverseName = metaItemTypeNamespace.getDataverseName();
+            metaItemTypeDatabaseName = metaItemTypeNamespace.getDatabaseName();
+        }
+
         MutableObject<ProgressState> progress = new MutableObject<>(ProgressState.NO_PROGRESS);
         SourceLocation sourceLoc = dd.getSourceLocation();
         DatasetType dsType = dd.getDatasetType();
@@ -851,13 +873,13 @@
                 storageProperties.getColumnMaxTupleCount(), storageProperties.getColumnFreeSpaceTolerance());
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
 
             IDatasetDetails datasetDetails;
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName, true);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName, true);
             if (ds != null) {
                 if (ds.getDatasetType() == DatasetType.VIEW) {
                     throw new CompilationException(ErrorCode.VIEW_EXISTS, sourceLoc,
@@ -871,15 +893,15 @@
                 }
             }
 
-            Pair<Datatype, Boolean> itemTypePair = fetchDatasetItemType(mdTxnCtx, dsType, itemTypeDataverseName,
-                    itemTypeName, itemTypeExpr, false, metadataProvider, sourceLoc);
+            Pair<Datatype, Boolean> itemTypePair = fetchDatasetItemType(mdTxnCtx, dsType, itemTypeDatabaseName,
+                    itemTypeDataverseName, itemTypeName, itemTypeExpr, false, metadataProvider, sourceLoc);
             itemTypeEntity = itemTypePair.first;
             IAType itemType = itemTypeEntity.getDatatype();
             boolean itemTypeIsInline = itemTypePair.second;
 
             String ngName = ngNameId != null ? ngNameId
-                    : configureNodegroupForDataset(appCtx, dd.getHints(), dataverseName, datasetName, metadataProvider,
-                            sourceLoc);
+                    : configureNodegroupForDataset(appCtx, dd.getHints(), databaseName, dataverseName, datasetName,
+                            metadataProvider, sourceLoc);
 
             if (compactionPolicy == null) {
                 compactionPolicy = StorageConstants.DEFAULT_COMPACTION_POLICY_NAME;
@@ -893,9 +915,9 @@
             switch (dsType) {
                 case INTERNAL:
                     if (metaItemTypeExpr != null) {
-                        Pair<Datatype, Boolean> metaItemTypePair =
-                                fetchDatasetItemType(mdTxnCtx, dsType, metaItemTypeDataverseName, metaItemTypeName,
-                                        metaItemTypeExpr, true, metadataProvider, sourceLoc);
+                        Pair<Datatype, Boolean> metaItemTypePair = fetchDatasetItemType(mdTxnCtx, dsType,
+                                metaItemTypeDatabaseName, metaItemTypeDataverseName, metaItemTypeName, metaItemTypeExpr,
+                                true, metadataProvider, sourceLoc);
                         metaItemTypeEntity = metaItemTypePair.first;
                         metaItemType = metaItemTypeEntity.getDatatype();
                         metaItemTypeIsInline = metaItemTypePair.second;
@@ -938,8 +960,8 @@
                     break;
                 case EXTERNAL:
                     ExternalDetailsDecl externalDetails = (ExternalDetailsDecl) dd.getDatasetDetailsDecl();
-                    Map<String, String> properties = createExternalDatasetProperties(dataverseName, dd, itemTypeEntity,
-                            metadataProvider, mdTxnCtx);
+                    Map<String, String> properties = createExternalDatasetProperties(databaseName, dataverseName, dd,
+                            itemTypeEntity, metadataProvider, mdTxnCtx);
                     ExternalDataUtils.normalize(properties);
                     ExternalDataUtils.validate(properties);
                     validateExternalDatasetProperties(externalDetails, properties, dd.getSourceLocation(), mdTxnCtx,
@@ -958,10 +980,10 @@
             }
 
             // #. add a new dataset with PendingAddOp
-            dataset = (Dataset) createDataset(dd, database, dataverseName, datasetName, itemTypeDatabase,
-                    itemTypeDataverseName, itemTypeName, metaItemDatabase, metaItemTypeDataverseName, metaItemTypeName,
-                    dsType, compactionPolicy, compactionPolicyProperties, compressionScheme, datasetFormatInfo,
-                    datasetDetails, ngName);
+            dataset = (Dataset) createDataset(dd, databaseName, dataverseName, datasetName, itemTypeDatabaseName,
+                    itemTypeDataverseName, itemTypeName, metaItemTypeDatabaseName, metaItemTypeDataverseName,
+                    metaItemTypeName, dsType, compactionPolicy, compactionPolicyProperties, compressionScheme,
+                    datasetFormatInfo, datasetDetails, ngName);
             MetadataManager.INSTANCE.addDataset(metadataProvider.getMetadataTxnContext(), dataset);
 
             if (itemTypeIsInline) {
@@ -992,7 +1014,7 @@
 
             // #. add a new dataset with PendingNoOp after deleting the dataset with
             // PendingAddOp
-            MetadataManager.INSTANCE.dropDataset(metadataProvider.getMetadataTxnContext(), database, dataverseName,
+            MetadataManager.INSTANCE.dropDataset(metadataProvider.getMetadataTxnContext(), databaseName, dataverseName,
                     datasetName, requestParameters.isForceDropDataset());
             dataset.setPendingOp(MetadataUtil.PENDING_NO_OP);
             MetadataManager.INSTANCE.addDataset(metadataProvider.getMetadataTxnContext(), dataset);
@@ -1030,7 +1052,7 @@
                 mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
                 metadataProvider.setMetadataTxnContext(mdTxnCtx);
                 try {
-                    MetadataManager.INSTANCE.dropDataset(mdTxnCtx, database, dataverseName, datasetName,
+                    MetadataManager.INSTANCE.dropDataset(mdTxnCtx, databaseName, dataverseName, datasetName,
                             requestParameters.isForceDropDataset());
                     if (itemTypeAdded) {
                         MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, itemTypeEntity.getDatabaseName(),
@@ -1065,20 +1087,19 @@
                 MetadataUtil.PENDING_ADD_OP, compressionScheme, datasetFormatInfo);
     }
 
-    protected Triple<DataverseName, String, Boolean> extractDatasetItemTypeName(DataverseName datasetDataverseName,
+    protected Triple<Namespace, String, Boolean> extractDatasetItemTypeName(Namespace datasetNamespace,
             String datasetName, TypeExpression itemTypeExpr, boolean isMetaItemType, SourceLocation sourceLoc)
             throws CompilationException {
         switch (itemTypeExpr.getTypeKind()) {
             case TYPEREFERENCE:
                 TypeReferenceExpression itemTypeRefExpr = (TypeReferenceExpression) itemTypeExpr;
-                Pair<DataverseName, Identifier> itemTypeIdent = itemTypeRefExpr.getIdent();
-                DataverseName typeDataverseName =
-                        itemTypeIdent.first != null ? itemTypeIdent.first : datasetDataverseName;
+                Pair<Namespace, Identifier> itemTypeIdent = itemTypeRefExpr.getIdent();
+                Namespace typeNamespace = itemTypeIdent.first != null ? itemTypeIdent.first : datasetNamespace;
                 String typeName = itemTypeRefExpr.getIdent().second.getValue();
-                return new Triple<>(typeDataverseName, typeName, false);
+                return new Triple<>(typeNamespace, typeName, false);
             case RECORD:
                 String inlineTypeName = TypeUtil.createDatasetInlineTypeName(datasetName, isMetaItemType);
-                return new Triple<>(datasetDataverseName, inlineTypeName, true);
+                return new Triple<>(datasetNamespace, inlineTypeName, true);
             default:
                 throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc,
                         String.valueOf(itemTypeExpr.getTypeKind()));
@@ -1086,14 +1107,13 @@
     }
 
     protected Pair<Datatype, Boolean> fetchDatasetItemType(MetadataTransactionContext mdTxnCtx, DatasetType datasetType,
-            DataverseName itemTypeDataverseName, String itemTypeName, TypeExpression itemTypeExpr,
-            boolean isMetaItemType, MetadataProvider metadataProvider, SourceLocation sourceLoc)
-            throws AlgebricksException {
-        String itemTypeDatabase = MetadataUtil.resolveDatabase(null, itemTypeDataverseName);
+            String itemTypeDatabaseName, DataverseName itemTypeDataverseName, String itemTypeName,
+            TypeExpression itemTypeExpr, boolean isMetaItemType, MetadataProvider metadataProvider,
+            SourceLocation sourceLoc) throws AlgebricksException {
         switch (itemTypeExpr.getTypeKind()) {
             case TYPEREFERENCE:
                 Datatype itemTypeEntity =
-                        metadataProvider.findTypeEntity(itemTypeDatabase, itemTypeDataverseName, itemTypeName);
+                        metadataProvider.findTypeEntity(itemTypeDatabaseName, itemTypeDataverseName, itemTypeName);
                 if (itemTypeEntity == null || itemTypeEntity.getIsAnonymous()) {
                     // anonymous types cannot be referred from CREATE DATASET/VIEW
                     throw new AsterixException(ErrorCode.UNKNOWN_TYPE, sourceLoc,
@@ -1103,9 +1123,11 @@
                 validateDatasetItemType(datasetType, itemType, isMetaItemType, sourceLoc);
                 return new Pair<>(itemTypeEntity, false);
             case RECORD:
-                itemType = translateType(itemTypeDataverseName, itemTypeName, itemTypeExpr, mdTxnCtx);
+                itemType = translateType(itemTypeDatabaseName, itemTypeDataverseName, itemTypeName, itemTypeExpr,
+                        mdTxnCtx);
                 validateDatasetItemType(datasetType, itemType, isMetaItemType, sourceLoc);
-                itemTypeEntity = new Datatype(itemTypeDatabase, itemTypeDataverseName, itemTypeName, itemType, true);
+                itemTypeEntity =
+                        new Datatype(itemTypeDatabaseName, itemTypeDataverseName, itemTypeName, itemType, true);
                 return new Pair<>(itemTypeEntity, true);
             default:
                 throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc,
@@ -1126,8 +1148,8 @@
         }
     }
 
-    protected Map<String, String> createExternalDatasetProperties(DataverseName dataverseName, DatasetDecl dd,
-            Datatype itemType, MetadataProvider metadataProvider, MetadataTransactionContext mdTxnCtx)
+    protected Map<String, String> createExternalDatasetProperties(String databaseName, DataverseName dataverseName,
+            DatasetDecl dd, Datatype itemType, MetadataProvider metadataProvider, MetadataTransactionContext mdTxnCtx)
             throws AlgebricksException {
         ExternalDetailsDecl externalDetails = (ExternalDetailsDecl) dd.getDatasetDetailsDecl();
         Map<String, String> properties = externalDetails.getProperties();
@@ -1149,7 +1171,7 @@
     }
 
     protected static String configureNodegroupForDataset(ICcApplicationContext appCtx, Map<String, String> hints,
-            DataverseName dataverseName, String datasetName, MetadataProvider metadataProvider,
+            String databaseName, DataverseName dataverseName, String datasetName, MetadataProvider metadataProvider,
             SourceLocation sourceLoc) throws Exception {
         IClusterStateManager csm = appCtx.getClusterStateManager();
         Set<String> allNodes = csm.getParticipantNodes(true);
@@ -1172,6 +1194,7 @@
             Collections.shuffle(allNodeList);
             selectedNodes.addAll(allNodeList.subList(0, nodegroupCardinality));
         }
+        //TODO(DB): node groups with database
         // Creates the associated node group for the dataset.
         return DatasetUtil.createNodeGroupForNewDataset(dataverseName, datasetName, selectedNodes, metadataProvider);
     }
@@ -1184,36 +1207,37 @@
         String fullTextConfigName = stmtCreateIndex.getFullTextConfigName();
         metadataProvider.validateDatabaseObjectName(stmtCreateIndex.getDataverseName(), indexName,
                 stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtCreateIndex.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtCreateIndex.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createIndexBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName,
+        lockUtil.createIndexBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName,
                 fullTextConfigName);
         try {
-            doCreateIndex(metadataProvider, stmtCreateIndex, dataverseName, datasetName, hcc, requestParameters);
+            doCreateIndex(metadataProvider, stmtCreateIndex, databaseName, dataverseName, datasetName, hcc,
+                    requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected void doCreateIndex(MetadataProvider metadataProvider, CreateIndexStatement stmtCreateIndex,
-            DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
+            String databaseName, DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
             IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         SourceLocation sourceLoc = stmtCreateIndex.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
 
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
@@ -1227,7 +1251,7 @@
             validateIndexType(datasetType, indexType, isSecondaryPrimary, sourceLoc);
 
             String indexName = stmtCreateIndex.getIndexName().getValue();
-            Index index = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(), database,
+            Index index = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(), databaseName,
                     dataverseName, datasetName, indexName);
             if (index != null) {
                 if (stmtCreateIndex.getIfNotExists()) {
@@ -1238,9 +1262,8 @@
                 }
             }
 
-            String itemTypeDatabase = MetadataUtil.resolveDatabase(null, ds.getItemTypeDataverseName());
             Datatype dt = MetadataManager.INSTANCE.getDatatype(metadataProvider.getMetadataTxnContext(),
-                    itemTypeDatabase, ds.getItemTypeDataverseName(), ds.getItemTypeName());
+                    ds.getItemTypeDatabaseName(), ds.getItemTypeDataverseName(), ds.getItemTypeName());
             ARecordType aRecordType = (ARecordType) dt.getDatatype();
             /* TODO: unused for now becase indexes on meta are disabled -- see below
             ARecordType metaRecordType = null;
@@ -1396,9 +1419,9 @@
                             }
                         }
 
-                        Map<TypeSignature, IAType> typeMap = TypeTranslator.computeTypes(dataverseName, indexName,
-                                projectTypeExpr.getType(), dataverseName, mdTxnCtx);
-                        TypeSignature typeSignature = new TypeSignature(dataverseName, indexName);
+                        Map<TypeSignature, IAType> typeMap = TypeTranslator.computeTypes(databaseName, dataverseName,
+                                indexName, projectTypeExpr.getType(), databaseName, dataverseName, mdTxnCtx);
+                        TypeSignature typeSignature = new TypeSignature(databaseName, dataverseName, indexName);
                         fieldTypePrime = typeMap.get(typeSignature);
                         // BACK-COMPAT: keep prime type only if we're overriding field types
                         fieldTypeNullable = fieldTypeMissable = false;
@@ -1520,7 +1543,7 @@
                 }
             }
 
-            Index newIndex = new Index(database, dataverseName, datasetName, indexName, indexType, indexDetails,
+            Index newIndex = new Index(databaseName, dataverseName, datasetName, indexName, indexType, indexDetails,
                     stmtCreateIndex.isEnforced(), false, MetadataUtil.PENDING_ADD_OP);
 
             bActiveTxn = false; // doCreateIndexImpl() takes over the current transaction
@@ -1540,24 +1563,25 @@
         String fullTextFilterName = stmtCreateFilter.getFilterName();
         metadataProvider.validateDatabaseObjectName(stmtCreateFilter.getDataverseName(), fullTextFilterName,
                 stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtCreateFilter.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtCreateFilter.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createFullTextFilterBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.createFullTextFilterBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 fullTextFilterName);
         try {
-            doCreateFullTextFilter(metadataProvider, stmtCreateFilter, dataverseName);
+            doCreateFullTextFilter(metadataProvider, stmtCreateFilter, databaseName, dataverseName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected void doCreateFullTextFilter(MetadataProvider metadataProvider,
-            CreateFullTextFilterStatement stmtCreateFilter, DataverseName dataverseName) throws Exception {
+            CreateFullTextFilterStatement stmtCreateFilter, String databaseName, DataverseName dataverseName)
+            throws Exception {
         AbstractFullTextFilterDescriptor filterDescriptor;
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         String filterType = stmtCreateFilter.getFilterType();
         if (filterType == null) {
             throw new CompilationException(ErrorCode.PARSE_ERROR, stmtCreateFilter.getSourceLocation(),
@@ -1565,7 +1589,7 @@
         }
 
         if (FIELD_TYPE_STOPWORDS.equals(filterType)) {
-            filterDescriptor = new StopwordsFullTextFilterDescriptor(database, dataverseName,
+            filterDescriptor = new StopwordsFullTextFilterDescriptor(databaseName, dataverseName,
                     stmtCreateFilter.getFilterName(), stmtCreateFilter.getStopwordsList());
         } else {
             throw new CompilationException(ErrorCode.COMPILATION_ERROR, stmtCreateFilter.getSourceLocation(),
@@ -1575,7 +1599,7 @@
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, stmtCreateFilter.getSourceLocation(),
                         dataverseName);
@@ -1583,7 +1607,7 @@
 
             String filterName = stmtCreateFilter.getFilterName();
             FullTextFilterMetadataEntity existingFilter =
-                    MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, database, dataverseName, filterName);
+                    MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, databaseName, dataverseName, filterName);
             if (existingFilter != null) {
                 if (stmtCreateFilter.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -1608,32 +1632,33 @@
         String configName = stmtCreateConfig.getConfigName();
         metadataProvider.validateDatabaseObjectName(stmtCreateConfig.getDataverseName(), configName,
                 stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtCreateConfig.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtCreateConfig.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         ImmutableList<String> filterNames = stmtCreateConfig.getFilterNames();
 
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createFullTextConfigBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.createFullTextConfigBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 configName, filterNames);
         try {
-            doCreateFullTextConfig(metadataProvider, stmtCreateConfig, dataverseName, configName, filterNames);
+            doCreateFullTextConfig(metadataProvider, stmtCreateConfig, databaseName, dataverseName, configName,
+                    filterNames);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected void doCreateFullTextConfig(MetadataProvider metadataProvider,
-            CreateFullTextConfigStatement stmtCreateConfig, DataverseName dataverseName, String configName,
-            ImmutableList<String> filterNames) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            CreateFullTextConfigStatement stmtCreateConfig, String databaseName, DataverseName dataverseName,
+            String configName, ImmutableList<String> filterNames) throws Exception {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
 
         try {
             FullTextConfigMetadataEntity existingConfig =
-                    MetadataManager.INSTANCE.getFullTextConfig(mdTxnCtx, database, dataverseName, configName);
+                    MetadataManager.INSTANCE.getFullTextConfig(mdTxnCtx, databaseName, dataverseName, configName);
             if (existingConfig != null) {
                 if (stmtCreateConfig.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -1646,7 +1671,7 @@
 
             for (String filterName : filterNames) {
                 FullTextFilterMetadataEntity filterMetadataEntity =
-                        MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, database, dataverseName, filterName);
+                        MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, databaseName, dataverseName, filterName);
                 if (filterMetadataEntity == null) {
                     throw new CompilationException(ErrorCode.FULL_TEXT_FILTER_NOT_FOUND,
                             stmtCreateConfig.getSourceLocation(), filterName);
@@ -1654,8 +1679,8 @@
             }
 
             TokenizerCategory tokenizerCategory = stmtCreateConfig.getTokenizerCategory();
-            FullTextConfigDescriptor configDescriptor =
-                    new FullTextConfigDescriptor(database, dataverseName, configName, tokenizerCategory, filterNames);
+            FullTextConfigDescriptor configDescriptor = new FullTextConfigDescriptor(databaseName, dataverseName,
+                    configName, tokenizerCategory, filterNames);
             FullTextConfigMetadataEntity configMetadataEntity = new FullTextConfigMetadataEntity(configDescriptor);
 
             MetadataManager.INSTANCE.addFullTextConfig(mdTxnCtx, configMetadataEntity);
@@ -1851,20 +1876,21 @@
         SourceLocation sourceLoc = stmtCreateType.getSourceLocation();
         String typeName = stmtCreateType.getIdent().getValue();
         metadataProvider.validateDatabaseObjectName(stmtCreateType.getDataverseName(), typeName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtCreateType.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtCreateType.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.createTypeBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, typeName);
+        lockUtil.createTypeBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, typeName);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
-            Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, database, dataverseName, typeName);
+            Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, databaseName, dataverseName, typeName);
             if (dt != null) {
                 if (!stmtCreateType.getIfNotExists()) {
                     throw new CompilationException(ErrorCode.TYPE_EXISTS, sourceLoc, typeName);
@@ -1877,9 +1903,10 @@
                     throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc,
                             "Reserved type name " + typeName + ".");
                 } else {
-                    IAType type = translateType(dataverseName, typeName, stmtCreateType.getTypeDef(), mdTxnCtx);
+                    IAType type =
+                            translateType(databaseName, dataverseName, typeName, stmtCreateType.getTypeDef(), mdTxnCtx);
                     MetadataManager.INSTANCE.addDatatype(mdTxnCtx,
-                            new Datatype(database, dataverseName, typeName, type, false));
+                            new Datatype(databaseName, dataverseName, typeName, type, false));
                 }
             }
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -1891,11 +1918,11 @@
         }
     }
 
-    private IAType translateType(DataverseName dataverseName, String typeName, TypeExpression typeDef,
-            MetadataTransactionContext mdTxnCtx) throws AlgebricksException {
-        Map<TypeSignature, IAType> typeMap =
-                TypeTranslator.computeTypes(dataverseName, typeName, typeDef, dataverseName, mdTxnCtx);
-        TypeSignature typeSignature = new TypeSignature(dataverseName, typeName);
+    private IAType translateType(String databaseName, DataverseName dataverseName, String typeName,
+            TypeExpression typeDef, MetadataTransactionContext mdTxnCtx) throws AlgebricksException {
+        Map<TypeSignature, IAType> typeMap = TypeTranslator.computeTypes(databaseName, dataverseName, typeName, typeDef,
+                databaseName, dataverseName, mdTxnCtx);
+        TypeSignature typeSignature = new TypeSignature(databaseName, dataverseName, typeName);
         return typeMap.get(typeSignature);
     }
 
@@ -2030,8 +2057,8 @@
             }
 
             //TODO(DB): switch active database to the DEFAULT if the dropped database is the currently active one
-            if (activeDataverse.getDatabaseName().equals(databaseName)) {
-                activeDataverse = MetadataBuiltinEntities.DEFAULT_DATAVERSE;
+            if (activeNamespace.getDatabaseName().equals(databaseName)) {
+                activeNamespace = MetadataBuiltinEntities.DEFAULT_NAMESPACE;
             }
 
             validateDatasetsStateAfterNamespaceDrop(metadataProvider, mdTxnCtx, datasets);
@@ -2044,8 +2071,8 @@
             }
 
             if (progress == ProgressState.ADDED_PENDINGOP_RECORD_TO_METADATA) {
-                if (activeDataverse.getDatabaseName().equals(databaseName)) {
-                    activeDataverse = MetadataBuiltinEntities.DEFAULT_DATAVERSE;
+                if (activeNamespace.getDatabaseName().equals(databaseName)) {
+                    activeNamespace = MetadataBuiltinEntities.DEFAULT_NAMESPACE;
                 }
 
                 // #. execute compensation operations
@@ -2080,7 +2107,7 @@
         DataverseDropStatement stmtDropDataverse = (DataverseDropStatement) stmt;
         SourceLocation sourceLoc = stmtDropDataverse.getSourceLocation();
         DataverseName dataverseName = stmtDropDataverse.getDataverseName();
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        String databaseName = stmtDropDataverse.getDatabaseName();
         metadataProvider.validateDataverseName(dataverseName, sourceLoc);
         if (dataverseName.equals(MetadataConstants.DEFAULT_DATAVERSE_NAME)
                 || dataverseName.equals(MetadataConstants.METADATA_DATAVERSE_NAME)) {
@@ -2090,7 +2117,7 @@
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropDataverseBegin(lockManager, metadataProvider.getLocks(), database, dataverseName);
+        lockUtil.dropDataverseBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName);
         try {
             doDropDataverse(stmtDropDataverse, metadataProvider, hcc, requestParameters);
         } finally {
@@ -2102,7 +2129,7 @@
             IHyracksClientConnection hcc, IRequestParameters requestParameters) throws Exception {
         SourceLocation sourceLoc = stmtDropDataverse.getSourceLocation();
         DataverseName dataverseName = stmtDropDataverse.getDataverseName();
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        String databaseName = stmtDropDataverse.getDatabaseName();
         ProgressState progress = ProgressState.NO_PROGRESS;
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
@@ -2110,7 +2137,7 @@
         List<FeedEventsListener> feedsToStop = new ArrayList<>();
         List<JobSpecification> jobsToExecute = new ArrayList<>();
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 if (stmtDropDataverse.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2120,7 +2147,7 @@
                 }
             }
 
-            if (stmtDropDataverse.getIfEmpty() && isDataverseNotEmpty(database, dataverseName, mdTxnCtx)) {
+            if (stmtDropDataverse.getIfEmpty() && isDataverseNotEmpty(databaseName, dataverseName, mdTxnCtx)) {
                 MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
                 return false;
             }
@@ -2134,6 +2161,7 @@
             for (IActiveEntityEventsListener listener : activeListeners) {
                 EntityId activeEntityId = listener.getEntityId();
                 if (activeEntityId.getExtensionName().equals(Feed.EXTENSION_NAME)
+                        && activeEntityId.getDatabaseName().equals(databaseName)
                         && activeEntityId.getDataverseName().equals(dataverseName)) {
                     FeedEventsListener feedListener = (FeedEventsListener) listener;
                     feedsToStop.add(feedListener);
@@ -2143,13 +2171,14 @@
             }
 
             // #. prepare jobs which will drop corresponding datasets with indexes.
-            List<Dataset> datasets = MetadataManager.INSTANCE.getDataverseDatasets(mdTxnCtx, database, dataverseName);
+            List<Dataset> datasets =
+                    MetadataManager.INSTANCE.getDataverseDatasets(mdTxnCtx, databaseName, dataverseName);
             for (Dataset dataset : datasets) {
                 String datasetName = dataset.getDatasetName();
                 DatasetType dsType = dataset.getDatasetType();
                 switch (dsType) {
                     case INTERNAL:
-                        List<Index> indexes = MetadataManager.INSTANCE.getDatasetIndexes(mdTxnCtx, database,
+                        List<Index> indexes = MetadataManager.INSTANCE.getDatasetIndexes(mdTxnCtx, databaseName,
                                 dataverseName, datasetName);
                         for (Index index : indexes) {
                             jobsToExecute
@@ -2163,8 +2192,10 @@
             }
 
             // #. prepare jobs which will drop corresponding libraries.
-            List<Library> libraries = MetadataManager.INSTANCE.getDataverseLibraries(mdTxnCtx, database, dataverseName);
+            List<Library> libraries =
+                    MetadataManager.INSTANCE.getDataverseLibraries(mdTxnCtx, databaseName, dataverseName);
             for (Library library : libraries) {
+                //TODO(DB):
                 jobsToExecute.add(ExternalLibraryJobUtils.buildDropLibraryJobSpec(dataverseName, library.getName(),
                         metadataProvider));
             }
@@ -2175,9 +2206,9 @@
             // first, deleting the dataverse record from the DATAVERSE_DATASET
             // second, inserting the dataverse record with the PendingDropOp value into the DATAVERSE_DATASET
             // Note: the delete operation fails if the dataverse cannot be deleted due to metadata dependencies
-            MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, database, dataverseName);
+            MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, databaseName, dataverseName);
             MetadataManager.INSTANCE.addDataverse(mdTxnCtx,
-                    new Dataverse(database, dataverseName, dv.getDataFormat(), MetadataUtil.PENDING_DROP_OP));
+                    new Dataverse(databaseName, dataverseName, dv.getDataFormat(), MetadataUtil.PENDING_DROP_OP));
 
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             bActiveTxn = false;
@@ -2199,7 +2230,7 @@
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
 
             // #. finally, delete the dataverse.
-            MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, database, dataverseName);
+            MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, databaseName, dataverseName);
 
             // Drops all node groups that no longer needed
             for (Dataset dataset : datasets) {
@@ -2210,8 +2241,8 @@
                 }
             }
 
-            if (activeDataverse.getDataverseName().equals(dataverseName)) {
-                activeDataverse = MetadataBuiltinEntities.DEFAULT_DATAVERSE;
+            if (activeNamespace.getDataverseName().equals(dataverseName)) {
+                activeNamespace = MetadataBuiltinEntities.DEFAULT_NAMESPACE;
             }
 
             validateDatasetsStateAfterNamespaceDrop(metadataProvider, mdTxnCtx, datasets);
@@ -2223,8 +2254,8 @@
             }
 
             if (progress == ProgressState.ADDED_PENDINGOP_RECORD_TO_METADATA) {
-                if (activeDataverse.getDataverseName().equals(dataverseName)) {
-                    activeDataverse = MetadataBuiltinEntities.DEFAULT_DATAVERSE;
+                if (activeNamespace.getDataverseName().equals(dataverseName)) {
+                    activeNamespace = MetadataBuiltinEntities.DEFAULT_NAMESPACE;
                 }
 
                 // #. execute compensation operations
@@ -2241,7 +2272,7 @@
                 // remove the record from the metadata.
                 mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
                 try {
-                    MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, database, dataverseName);
+                    MetadataManager.INSTANCE.dropDataverse(mdTxnCtx, databaseName, dataverseName);
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
                 } catch (Exception e2) {
                     e.addSuppressed(e2);
@@ -2280,24 +2311,25 @@
         SourceLocation sourceLoc = stmtDelete.getSourceLocation();
         String datasetName = stmtDelete.getDatasetName().getValue();
         metadataProvider.validateDatabaseObjectName(stmtDelete.getDataverseName(), datasetName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtDelete.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtDelete.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName);
+        lockUtil.dropDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName);
         try {
-            doDropDataset(dataverseName, datasetName, metadataProvider, stmtDelete.getIfExists(), hcc,
+            doDropDataset(databaseName, dataverseName, datasetName, metadataProvider, stmtDelete.getIfExists(), hcc,
                     requestParameters, true, sourceLoc);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
-    protected boolean doDropDataset(DataverseName dataverseName, String datasetName, MetadataProvider metadataProvider,
-            boolean ifExists, IHyracksClientConnection hcc, IRequestParameters requestParameters,
-            boolean dropCorrespondingNodeGroup, SourceLocation sourceLoc) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+    protected boolean doDropDataset(String databaseName, DataverseName dataverseName, String datasetName,
+            MetadataProvider metadataProvider, boolean ifExists, IHyracksClientConnection hcc,
+            IRequestParameters requestParameters, boolean dropCorrespondingNodeGroup, SourceLocation sourceLoc)
+            throws Exception {
         MutableObject<ProgressState> progress = new MutableObject<>(ProgressState.NO_PROGRESS);
         MutableObject<MetadataTransactionContext> mdTxnCtx =
                 new MutableObject<>(MetadataManager.INSTANCE.beginTransaction());
@@ -2307,7 +2339,7 @@
         Dataset ds = null;
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx.getValue(), database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx.getValue(), databaseName, dataverseName);
             if (dv == null) {
                 if (ifExists) {
                     if (warningCollector.shouldWarn()) {
@@ -2319,7 +2351,7 @@
                     throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
                 }
             }
-            ds = metadataProvider.findDataset(database, dataverseName, datasetName, true);
+            ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName, true);
             if (ds == null) {
                 if (ifExists) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx.getValue());
@@ -2371,7 +2403,7 @@
                 mdTxnCtx.setValue(MetadataManager.INSTANCE.beginTransaction());
                 metadataProvider.setMetadataTxnContext(mdTxnCtx.getValue());
                 try {
-                    MetadataManager.INSTANCE.dropDataset(metadataProvider.getMetadataTxnContext(), database,
+                    MetadataManager.INSTANCE.dropDataset(metadataProvider.getMetadataTxnContext(), databaseName,
                             dataverseName, datasetName, requestParameters.isForceDropDataset());
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx.getValue());
                 } catch (Exception e2) {
@@ -2390,24 +2422,25 @@
         IndexDropStatement stmtIndexDrop = (IndexDropStatement) stmt;
         metadataProvider.validateDatabaseObjectName(stmtIndexDrop.getDataverseName(),
                 stmtIndexDrop.getIndexName().getValue(), stmtIndexDrop.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtIndexDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtIndexDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = stmtIndexDrop.getDatasetName().getValue();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropIndexBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName);
+        lockUtil.dropIndexBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName);
         try {
-            doDropIndex(metadataProvider, stmtIndexDrop, dataverseName, datasetName, hcc, requestParameters);
+            doDropIndex(metadataProvider, stmtIndexDrop, databaseName, dataverseName, datasetName, hcc,
+                    requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected boolean doDropIndex(MetadataProvider metadataProvider, IndexDropStatement stmtIndexDrop,
-            DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
+            String databaseName, DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
             IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         SourceLocation sourceLoc = stmtIndexDrop.getSourceLocation();
         String indexName = stmtIndexDrop.getIndexName().getValue();
         ProgressState progress = ProgressState.NO_PROGRESS;
@@ -2417,14 +2450,14 @@
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
             }
             if (ds.getDatasetType() == DatasetType.INTERNAL) {
-                Index index =
-                        MetadataManager.INSTANCE.getIndex(mdTxnCtx, database, dataverseName, datasetName, indexName);
+                Index index = MetadataManager.INSTANCE.getIndex(mdTxnCtx, databaseName, dataverseName, datasetName,
+                        indexName);
                 if (index == null) {
                     if (stmtIndexDrop.getIfExists()) {
                         MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2435,8 +2468,8 @@
                 }
                 ensureNonPrimaryIndexDrop(index, sourceLoc);
                 validateDatasetState(metadataProvider, ds, sourceLoc);
-                prepareIndexDrop(metadataProvider, dataverseName, datasetName, sourceLoc, indexName, jobsToExecute,
-                        mdTxnCtx, ds, index);
+                prepareIndexDrop(metadataProvider, databaseName, dataverseName, datasetName, sourceLoc, indexName,
+                        jobsToExecute, mdTxnCtx, ds, index);
 
                 // #. commit the existing transaction before calling runJob.
                 MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2453,7 +2486,7 @@
                 metadataProvider.setMetadataTxnContext(mdTxnCtx);
 
                 // #. finally, delete the existing index
-                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, database, dataverseName, datasetName, indexName);
+                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName);
             }
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return true;
@@ -2478,7 +2511,7 @@
                 mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
                 metadataProvider.setMetadataTxnContext(mdTxnCtx);
                 try {
-                    MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), database,
+                    MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), databaseName,
                             dataverseName, datasetName, indexName);
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
                 } catch (Exception e2) {
@@ -2496,30 +2529,31 @@
     protected void handleFullTextFilterDrop(MetadataProvider metadataProvider, Statement stmt,
             IHyracksClientConnection hcc, IRequestParameters requestParameters) throws Exception {
         FullTextFilterDropStatement stmtFilterDrop = (FullTextFilterDropStatement) stmt;
-        DataverseName dataverseName = getActiveDataverseName(stmtFilterDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtFilterDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String fullTextFilterName = stmtFilterDrop.getFilterName();
 
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropFullTextFilterBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.dropFullTextFilterBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 fullTextFilterName);
         try {
-            doDropFullTextFilter(metadataProvider, stmtFilterDrop, dataverseName, fullTextFilterName);
+            doDropFullTextFilter(metadataProvider, stmtFilterDrop, databaseName, dataverseName, fullTextFilterName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected void doDropFullTextFilter(MetadataProvider metadataProvider, FullTextFilterDropStatement stmtFilterDrop,
-            DataverseName dataverseName, String fullTextFilterName) throws AlgebricksException, RemoteException {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            String databaseName, DataverseName dataverseName, String fullTextFilterName)
+            throws AlgebricksException, RemoteException {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            FullTextFilterMetadataEntity filter =
-                    MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, database, dataverseName, fullTextFilterName);
+            FullTextFilterMetadataEntity filter = MetadataManager.INSTANCE.getFullTextFilter(mdTxnCtx, databaseName,
+                    dataverseName, fullTextFilterName);
             if (filter == null) {
                 if (stmtFilterDrop.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2530,7 +2564,7 @@
                 }
             }
 
-            MetadataManager.INSTANCE.dropFullTextFilter(mdTxnCtx, database, dataverseName, fullTextFilterName);
+            MetadataManager.INSTANCE.dropFullTextFilter(mdTxnCtx, databaseName, dataverseName, fullTextFilterName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
         } catch (Exception e) {
             abort(e, e, mdTxnCtx);
@@ -2542,39 +2576,39 @@
             IHyracksClientConnection hcc, IRequestParameters requestParameters)
             throws AlgebricksException, RemoteException {
         FullTextConfigDropStatement stmtConfigDrop = (FullTextConfigDropStatement) stmt;
-        DataverseName dataverseName = getActiveDataverseName(stmtConfigDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtConfigDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String configName = stmtConfigDrop.getConfigName();
 
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropFullTextConfigBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, configName);
+        lockUtil.dropFullTextConfigBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
+                configName);
         try {
-            doDropFullTextConfig(metadataProvider, stmtConfigDrop, hcc, requestParameters);
+            doDropFullTextConfig(metadataProvider, stmtConfigDrop, databaseName, dataverseName, hcc, requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     private void doDropFullTextConfig(MetadataProvider metadataProvider, FullTextConfigDropStatement stmtConfigDrop,
-            IHyracksClientConnection hcc, IRequestParameters requestParameters)
-            throws RemoteException, AlgebricksException {
+            String databaseName, DataverseName dataverseName, IHyracksClientConnection hcc,
+            IRequestParameters requestParameters) throws RemoteException, AlgebricksException {
         // If the config name is null, then it means the default config
         if (Strings.isNullOrEmpty(stmtConfigDrop.getConfigName())) {
             throw new CompilationException(ErrorCode.FULL_TEXT_DEFAULT_CONFIG_CANNOT_BE_DELETED_OR_CREATED,
                     stmtConfigDrop.getSourceLocation());
         }
 
-        DataverseName dataverseName = getActiveDataverseName(stmtConfigDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         String fullTextConfigName = stmtConfigDrop.getConfigName();
 
         try {
-            FullTextConfigMetadataEntity configMetadataEntity =
-                    MetadataManager.INSTANCE.getFullTextConfig(mdTxnCtx, database, dataverseName, fullTextConfigName);
+            FullTextConfigMetadataEntity configMetadataEntity = MetadataManager.INSTANCE.getFullTextConfig(mdTxnCtx,
+                    databaseName, dataverseName, fullTextConfigName);
             if (configMetadataEntity == null) {
                 if (stmtConfigDrop.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2585,7 +2619,7 @@
                 }
             }
 
-            MetadataManager.INSTANCE.dropFullTextConfig(mdTxnCtx, database, dataverseName, fullTextConfigName);
+            MetadataManager.INSTANCE.dropFullTextConfig(mdTxnCtx, databaseName, dataverseName, fullTextConfigName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
         } catch (Exception e) {
             abort(e, e, mdTxnCtx);
@@ -2598,17 +2632,18 @@
         SourceLocation sourceLoc = stmtTypeDrop.getSourceLocation();
         String typeName = stmtTypeDrop.getTypeName().getValue();
         metadataProvider.validateDatabaseObjectName(stmtTypeDrop.getDataverseName(), typeName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtTypeDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtTypeDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.dropTypeBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, typeName);
+        lockUtil.dropTypeBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, typeName);
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 if (stmtTypeDrop.getIfExists()) {
                     if (warningCollector.shouldWarn()) {
@@ -2621,13 +2656,13 @@
                 }
             }
 
-            Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, database, dataverseName, typeName);
+            Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, databaseName, dataverseName, typeName);
             if (dt == null) {
                 if (!stmtTypeDrop.getIfExists()) {
                     throw new CompilationException(ErrorCode.UNKNOWN_TYPE, sourceLoc, typeName);
                 }
             } else {
-                MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, database, dataverseName, typeName);
+                MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, databaseName, dataverseName, typeName);
             }
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
         } catch (Exception e) {
@@ -2673,54 +2708,58 @@
         CreateViewStatement cvs = (CreateViewStatement) stmt;
         String viewName = cvs.getViewName();
         metadataProvider.validateDatabaseObjectName(cvs.getDataverseName(), viewName, stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(cvs.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cvs.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
 
+        String itemTypeDatabaseName;
         DataverseName viewItemTypeDataverseName;
         String viewItemTypeName;
         boolean viewItemTypeAnonymous;
         if (cvs.hasItemType()) {
-            Triple<DataverseName, String, Boolean> viewTypeQualifiedName = extractDatasetItemTypeName(dataverseName,
+            Triple<Namespace, String, Boolean> viewTypeQualifiedName = extractDatasetItemTypeName(stmtActiveNamespace,
                     viewName, cvs.getItemType(), false, stmt.getSourceLocation());
-            viewItemTypeDataverseName = viewTypeQualifiedName.first;
+            itemTypeDatabaseName = viewTypeQualifiedName.first.getDatabaseName();
+            viewItemTypeDataverseName = viewTypeQualifiedName.first.getDataverseName();
             viewItemTypeName = viewTypeQualifiedName.second;
             viewItemTypeAnonymous = viewTypeQualifiedName.third;
         } else {
+            itemTypeDatabaseName = MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDatabaseName();
             viewItemTypeDataverseName = MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDataverseName();
             viewItemTypeName = MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDatatypeName();
             viewItemTypeAnonymous = false;
         }
-        String itemTypeDatabase = MetadataUtil.resolveDatabase(null, viewItemTypeDataverseName);
 
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, viewName,
-                itemTypeDatabase, viewItemTypeDataverseName, viewItemTypeName, viewItemTypeAnonymous, null, null, null,
-                false, null, null, true, DatasetType.VIEW, null);
+        lockUtil.createDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, viewName,
+                itemTypeDatabaseName, viewItemTypeDataverseName, viewItemTypeName, viewItemTypeAnonymous, null, null,
+                null, false, null, null, true, DatasetType.VIEW, null);
         try {
-            doCreateView(metadataProvider, cvs, dataverseName, viewName, viewItemTypeDataverseName, viewItemTypeName,
-                    stmtRewriter, requestParameters);
+            doCreateView(metadataProvider, cvs, databaseName, dataverseName, viewName, itemTypeDatabaseName,
+                    viewItemTypeDataverseName, viewItemTypeName, stmtRewriter, requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
-            metadataProvider.setDefaultDataverse(activeDataverse);
+            metadataProvider.setDefaultNamespace(activeNamespace);
         }
     }
 
-    protected CreateResult doCreateView(MetadataProvider metadataProvider, CreateViewStatement cvs,
-            DataverseName dataverseName, String viewName, DataverseName itemTypeDataverseName, String itemTypeName,
-            IStatementRewriter stmtRewriter, IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
-        String itemTypeDatabase = MetadataUtil.resolveDatabase(null, itemTypeDataverseName);
+    protected CreateResult doCreateView(MetadataProvider metadataProvider, CreateViewStatement cvs, String databaseName,
+            DataverseName dataverseName, String viewName, String itemTypeDatabaseName,
+            DataverseName itemTypeDataverseName, String itemTypeName, IStatementRewriter stmtRewriter,
+            IRequestParameters requestParameters) throws Exception {
         SourceLocation sourceLoc = cvs.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
-            Dataset existingDataset = MetadataManager.INSTANCE.getDataset(mdTxnCtx, database, dataverseName, viewName);
+            Namespace ns = new Namespace(dv.getDatabaseName(), dv.getDataverseName());
+            Dataset existingDataset =
+                    MetadataManager.INSTANCE.getDataset(mdTxnCtx, databaseName, dataverseName, viewName);
             if (existingDataset != null) {
                 if (DatasetUtil.isNotView(existingDataset)) {
                     throw new CompilationException(ErrorCode.DATASET_EXISTS, sourceLoc,
@@ -2736,7 +2775,7 @@
             }
 
             DatasetFullyQualifiedName viewQualifiedName =
-                    new DatasetFullyQualifiedName(database, dataverseName, viewName);
+                    new DatasetFullyQualifiedName(databaseName, dataverseName, viewName);
 
             Datatype itemTypeEntity = null;
             boolean itemTypeIsInline = false;
@@ -2746,8 +2785,9 @@
             List<ViewDetails.ForeignKey> foreignKeys = null;
             String datetimeFormat = null, dateFormat = null, timeFormat = null;
             if (cvs.hasItemType()) {
-                Pair<Datatype, Boolean> itemTypePair = fetchDatasetItemType(mdTxnCtx, DatasetType.VIEW,
-                        itemTypeDataverseName, itemTypeName, cvs.getItemType(), false, metadataProvider, sourceLoc);
+                Pair<Datatype, Boolean> itemTypePair =
+                        fetchDatasetItemType(mdTxnCtx, DatasetType.VIEW, itemTypeDatabaseName, itemTypeDataverseName,
+                                itemTypeName, cvs.getItemType(), false, metadataProvider, sourceLoc);
                 itemTypeEntity = itemTypePair.first;
                 itemTypeIsInline = itemTypePair.second;
                 ARecordType itemType = (ARecordType) itemTypeEntity.getDatatype();
@@ -2760,20 +2800,21 @@
                         List<String> foreignKeyFields =
                                 ValidateUtil.validateViewKeyFields(foreignKeyDecl, itemType, true, sourceLoc);
                         DataverseName refDataverseName = foreignKeyDecl.getReferencedDataverseName();
-                        String refDatabase = MetadataUtil.resolveDatabase(null, refDataverseName);
+                        String refDatabaseName = foreignKeyDecl.getReferencedDatabaseName();
                         if (refDataverseName == null) {
                             refDataverseName = dataverseName;
-                            refDatabase = MetadataUtil.resolveDatabase(null, dataverseName);
+                            refDatabaseName = databaseName;
                         } else {
                             Dataverse refDataverse =
-                                    MetadataManager.INSTANCE.getDataverse(mdTxnCtx, refDatabase, refDataverseName);
+                                    MetadataManager.INSTANCE.getDataverse(mdTxnCtx, refDatabaseName, refDataverseName);
                             if (refDataverse == null) {
                                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc,
                                         refDataverseName);
                             }
                         }
                         String refDatasetName = foreignKeyDecl.getReferencedDatasetName().getValue();
-                        boolean isSelfRef = refDataverseName.equals(dataverseName) && refDatasetName.equals(viewName);
+                        boolean isSelfRef = refDatabaseName.equals(databaseName)
+                                && refDataverseName.equals(dataverseName) && refDatasetName.equals(viewName);
                         DatasetType refDatasetType;
                         DatasetFullyQualifiedName refQualifiedName;
                         List<String> refPrimaryKeyFields;
@@ -2783,8 +2824,8 @@
                             refPrimaryKeyFields = primaryKeyFields;
                         } else {
                             // findDataset() will acquire lock on referenced dataset (view)
-                            Dataset refDataset =
-                                    metadataProvider.findDataset(refDatabase, refDataverseName, refDatasetName, true);
+                            Dataset refDataset = metadataProvider.findDataset(refDatabaseName, refDataverseName,
+                                    refDatasetName, true);
                             if (refDataset == null || DatasetUtil.isNotView(refDataset)) {
                                 throw new CompilationException(ErrorCode.UNKNOWN_VIEW, sourceLoc,
                                         DatasetUtil.getFullyQualifiedDisplayName(refDataverseName, refDatasetName));
@@ -2792,7 +2833,7 @@
                             ViewDetails refViewDetails = (ViewDetails) refDataset.getDatasetDetails();
                             refDatasetType = refDataset.getDatasetType();
                             refQualifiedName =
-                                    new DatasetFullyQualifiedName(refDatabase, refDataverseName, refDatasetName);
+                                    new DatasetFullyQualifiedName(refDatabaseName, refDataverseName, refDatasetName);
                             refPrimaryKeyFields = refViewDetails.getPrimaryKeyFields();
                         }
 
@@ -2856,7 +2897,7 @@
             viewDecl.setSourceLocation(sourceLoc);
             IQueryRewriter queryRewriter = rewriterFactory.createQueryRewriter();
             Query wrappedQuery = queryRewriter.createViewAccessorQuery(viewDecl);
-            metadataProvider.setDefaultDataverse(dv);
+            metadataProvider.setDefaultNamespace(ns);
             LangRewritingContext langRewritingContext = createLangRewritingContext(metadataProvider, declaredFunctions,
                     Collections.singletonList(viewDecl), warningCollector, wrappedQuery.getVarCounter());
             apiFramework.reWriteQuery(langRewritingContext, wrappedQuery, sessionOutput, false, false,
@@ -2868,9 +2909,10 @@
             ViewDetails viewDetails = new ViewDetails(cvs.getViewBody(), dependencies, cvs.getDefaultNull(),
                     primaryKeyFields, foreignKeys, datetimeFormat, dateFormat, timeFormat);
 
-            Dataset view = new Dataset(database, dataverseName, viewName, itemTypeDatabase, itemTypeDataverseName,
-                    itemTypeName, MetadataConstants.METADATA_NODEGROUP_NAME, "", Collections.emptyMap(), viewDetails,
-                    Collections.emptyMap(), DatasetType.VIEW, 0, MetadataUtil.PENDING_NO_OP);
+            Dataset view =
+                    new Dataset(databaseName, dataverseName, viewName, itemTypeDatabaseName, itemTypeDataverseName,
+                            itemTypeName, MetadataConstants.METADATA_NODEGROUP_NAME, "", Collections.emptyMap(),
+                            viewDetails, Collections.emptyMap(), DatasetType.VIEW, 0, MetadataUtil.PENDING_NO_OP);
             if (existingDataset == null) {
                 if (itemTypeIsInline) {
                     MetadataManager.INSTANCE.addDatatype(mdTxnCtx, itemTypeEntity);
@@ -2895,28 +2937,28 @@
         SourceLocation sourceLoc = stmtDrop.getSourceLocation();
         String viewName = stmtDrop.getViewName().getValue();
         metadataProvider.validateDatabaseObjectName(stmtDrop.getDataverseName(), viewName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, viewName);
+        lockUtil.dropDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, viewName);
         try {
-            doDropView(metadataProvider, stmtDrop, dataverseName, viewName);
+            doDropView(metadataProvider, stmtDrop, databaseName, dataverseName, viewName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
-    protected boolean doDropView(MetadataProvider metadataProvider, ViewDropStatement stmtViewDrop,
+    protected boolean doDropView(MetadataProvider metadataProvider, ViewDropStatement stmtViewDrop, String databaseName,
             DataverseName dataverseName, String viewName) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         SourceLocation sourceLoc = stmtViewDrop.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 if (stmtViewDrop.getIfExists()) {
                     if (warningCollector.shouldWarn()) {
@@ -2929,7 +2971,7 @@
                     throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
                 }
             }
-            Dataset dataset = metadataProvider.findDataset(database, dataverseName, viewName, true);
+            Dataset dataset = metadataProvider.findDataset(databaseName, dataverseName, viewName, true);
             if (dataset == null) {
                 if (stmtViewDrop.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -2942,7 +2984,7 @@
                 throw new CompilationException(ErrorCode.UNKNOWN_VIEW, sourceLoc,
                         DatasetUtil.getFullyQualifiedDisplayName(dataverseName, viewName));
             }
-            MetadataManager.INSTANCE.dropDataset(mdTxnCtx, database, dataverseName, viewName, false);
+            MetadataManager.INSTANCE.dropDataset(mdTxnCtx, databaseName, dataverseName, viewName, false);
             String itemTypeDatabaseName = dataset.getItemTypeDatabaseName();
             if (TypeUtil.isDatasetInlineTypeName(dataset, itemTypeDatabaseName, dataset.getItemTypeDataverseName(),
                     dataset.getItemTypeName())) {
@@ -2963,8 +3005,7 @@
         DataverseName funDataverse = signature.getDataverseName();
         metadataProvider.validateDatabaseObjectName(funDataverse, signature.getName(), stmt.getSourceLocation());
         if (funDataverse == null) {
-            Dataverse activeDv = getActiveDataverse();
-            signature.setDataverseName(activeDv.getDatabaseName(), activeDv.getDataverseName());
+            signature.setDataverseName(activeNamespace.getDatabaseName(), activeNamespace.getDataverseName());
         }
         declaredFunctions.add(fds);
     }
@@ -2976,35 +3017,36 @@
         DataverseName funDataverse = signature.getDataverseName();
         metadataProvider.validateDatabaseObjectName(funDataverse, signature.getName(), stmt.getSourceLocation());
         DataverseName dataverseName;
-        String database;
+        String databaseName;
         if (funDataverse == null) {
-            Dataverse activeDv = getActiveDataverse();
-            dataverseName = activeDv.getDataverseName();
-            database = activeDv.getDatabaseName();
-            signature.setDataverseName(database, dataverseName);
+            dataverseName = activeNamespace.getDataverseName();
+            databaseName = activeNamespace.getDatabaseName();
+            signature.setDataverseName(databaseName, dataverseName);
         } else {
             dataverseName = funDataverse;
-            database = signature.getDatabaseName();
+            databaseName = signature.getDatabaseName();
         }
         DataverseName libraryDataverseName = null;
+        String libraryDatabaseName = null;
         String libraryName = cfs.getLibraryName();
         if (libraryName != null) {
             libraryDataverseName = cfs.getLibraryDataverseName();
+            libraryDatabaseName = cfs.getLibraryDatabaseName();
             if (libraryDataverseName == null) {
                 libraryDataverseName = dataverseName;
+                libraryDatabaseName = databaseName;
             }
         }
-        String libraryDatabase = MetadataUtil.resolveDatabase(null, libraryDataverseName);
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createFunctionBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
-                signature.getName(), libraryDatabase, libraryDataverseName, libraryName);
+        lockUtil.createFunctionBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
+                signature.getName(), libraryDatabaseName, libraryDataverseName, libraryName);
         try {
             doCreateFunction(metadataProvider, cfs, signature, stmtRewriter, requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
-            metadataProvider.setDefaultDataverse(activeDataverse);
+            metadataProvider.setDefaultNamespace(activeNamespace);
         }
     }
 
@@ -3012,15 +3054,16 @@
             FunctionSignature functionSignature, IStatementRewriter stmtRewriter, IRequestParameters requestParameters)
             throws Exception {
         DataverseName dataverseName = functionSignature.getDataverseName();
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        String databaseName = functionSignature.getDatabaseName();
         SourceLocation sourceLoc = cfs.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
+            Namespace ns = new Namespace(dv.getDatabaseName(), dv.getDataverseName());
             List<TypeSignature> existingInlineTypes;
             Function existingFunction = MetadataManager.INSTANCE.getFunction(mdTxnCtx, functionSignature);
             if (existingFunction != null) {
@@ -3102,13 +3145,14 @@
                 }
 
                 DataverseName libraryDataverseName = cfs.getLibraryDataverseName();
+                String libraryDatabaseName = cfs.getLibraryDatabaseName();
                 if (libraryDataverseName == null) {
                     libraryDataverseName = dataverseName;
+                    libraryDatabaseName = databaseName;
                 }
-                String libraryDatabase = MetadataUtil.resolveDatabase(null, libraryDataverseName);
                 String libraryName = cfs.getLibraryName();
-                Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDatabase, libraryDataverseName,
-                        libraryName);
+                Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDatabaseName,
+                        libraryDataverseName, libraryName);
                 if (library == null) {
                     throw new CompilationException(ErrorCode.UNKNOWN_LIBRARY, sourceLoc, libraryName);
                 }
@@ -3122,9 +3166,9 @@
                         FunctionUtil.getExternalFunctionDependencies(depTypes);
 
                 function = new Function(functionSignature, paramNames, paramTypes, returnTypeSignature, null,
-                        FunctionKind.SCALAR.toString(), library.getLanguage(), libraryDatabase, libraryDataverseName,
-                        libraryName, externalIdentifier, cfs.getNullCall(), cfs.getDeterministic(), cfs.getResources(),
-                        dependencies);
+                        FunctionKind.SCALAR.toString(), library.getLanguage(), libraryDatabaseName,
+                        libraryDataverseName, libraryName, externalIdentifier, cfs.getNullCall(),
+                        cfs.getDeterministic(), cfs.getResources(), dependencies);
             } else {
                 List<Pair<VarIdentifier, TypeExpression>> paramList = cfs.getParameters();
                 int paramCount = paramList.size();
@@ -3150,7 +3194,7 @@
                 List<FunctionDecl> fdList = new ArrayList<>(declaredFunctions.size() + 1);
                 fdList.addAll(declaredFunctions);
                 fdList.add(fd);
-                metadataProvider.setDefaultDataverse(dv);
+                metadataProvider.setDefaultNamespace(ns);
                 LangRewritingContext langRewritingContext = createLangRewritingContext(metadataProvider, fdList, null,
                         warningCollector, wrappedQuery.getVarCounter());
                 apiFramework.reWriteQuery(langRewritingContext, wrappedQuery, sessionOutput, false, false,
@@ -3177,8 +3221,7 @@
                     Datatype newInlineType =
                             newInlineTypes.isEmpty() ? null : newInlineTypes.remove(existingInlineType);
                     if (newInlineType == null) {
-                        String existingInlineTypeDatabase = existingInlineType.getDatabaseName();
-                        MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, existingInlineTypeDatabase,
+                        MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, existingInlineType.getDatabaseName(),
                                 existingInlineType.getDataverseName(), existingInlineType.getName());
                     } else {
                         MetadataManager.INSTANCE.updateDatatype(mdTxnCtx, newInlineType);
@@ -3216,30 +3259,39 @@
                     depTypeSignature = null;
                 } else {
                     // user-defined type
-                    DataverseName paramTypeDataverseName = paramTypeRefExpr.getIdent().first;
-                    if (paramTypeDataverseName == null) {
+                    Namespace paramTypeRefNamespace = paramTypeRefExpr.getIdent().first;
+                    DataverseName paramTypeDataverseName;
+                    String paramTypeDatabaseName;
+                    if (paramTypeRefNamespace == null) {
                         paramTypeDataverseName = functionSignature.getDataverseName();
+                        paramTypeDatabaseName = functionSignature.getDatabaseName();
+                    } else {
+                        paramTypeDataverseName = paramTypeRefNamespace.getDataverseName();
+                        paramTypeDatabaseName = paramTypeRefNamespace.getDatabaseName();
                     }
-                    String paramTypeDatabase = MetadataUtil.resolveDatabase(null, paramTypeDataverseName);
-                    Datatype paramTypeEntity =
-                            metadataProvider.findTypeEntity(paramTypeDatabase, paramTypeDataverseName, paramTypeName);
+
+                    Datatype paramTypeEntity = metadataProvider.findTypeEntity(paramTypeDatabaseName,
+                            paramTypeDataverseName, paramTypeName);
                     if (paramTypeEntity == null || paramTypeEntity.getIsAnonymous()) {
                         throw new CompilationException(ErrorCode.UNKNOWN_TYPE, sourceLoc, paramTypeName);
                     }
-                    paramTypeSignature = depTypeSignature = new TypeSignature(paramTypeDataverseName, paramTypeName);
+                    paramTypeSignature = depTypeSignature =
+                            new TypeSignature(paramTypeDatabaseName, paramTypeDataverseName, paramTypeName);
                 }
                 break;
             case ORDEREDLIST:
             case UNORDEREDLIST:
                 DataverseName paramTypeDataverseName = functionSignature.getDataverseName();
-                String database = MetadataUtil.resolveDatabase(null, paramTypeDataverseName);
+                String paramTypeDatabaseName = functionSignature.getDatabaseName();
                 paramTypeName = TypeUtil.createFunctionParameterTypeName(functionSignature.getName(),
                         functionSignature.getArity(), paramIdx);
-                IAType paramType = translateType(paramTypeDataverseName, paramTypeName, paramTypeExpr, mdTxnCtx);
-                paramTypeSignature = new TypeSignature(paramTypeDataverseName, paramTypeName);
-                depTypeSignature =
-                        FunctionUtil.getTypeDependencyFromFunctionParameter(paramTypeExpr, paramTypeDataverseName);
-                paramInlineTypeEntity = new Datatype(database, paramTypeDataverseName, paramTypeName, paramType, true);
+                IAType paramType = translateType(paramTypeDatabaseName, paramTypeDataverseName, paramTypeName,
+                        paramTypeExpr, mdTxnCtx);
+                paramTypeSignature = new TypeSignature(paramTypeDatabaseName, paramTypeDataverseName, paramTypeName);
+                depTypeSignature = FunctionUtil.getTypeDependencyFromFunctionParameter(paramTypeExpr,
+                        paramTypeDatabaseName, paramTypeDataverseName);
+                paramInlineTypeEntity =
+                        new Datatype(paramTypeDatabaseName, paramTypeDataverseName, paramTypeName, paramType, true);
                 break;
             default:
                 throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc);
@@ -3256,20 +3308,19 @@
         metadataProvider.validateDatabaseObjectName(funDataverse, signature.getName(),
                 stmtDropFunction.getSourceLocation());
         DataverseName dataverseName;
-        String database;
+        String databaseName;
         if (funDataverse == null) {
-            Dataverse activeDv = getActiveDataverse();
-            dataverseName = activeDv.getDataverseName();
-            database = activeDv.getDatabaseName();
-            signature.setDataverseName(database, dataverseName);
+            dataverseName = activeNamespace.getDataverseName();
+            databaseName = activeNamespace.getDatabaseName();
+            signature.setDataverseName(databaseName, dataverseName);
         } else {
             dataverseName = funDataverse;
-            database = signature.getDatabaseName();
+            databaseName = signature.getDatabaseName();
         }
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropFunctionBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.dropFunctionBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 signature.getName());
         try {
             doDropFunction(metadataProvider, stmtDropFunction, signature, requestParameters);
@@ -3281,12 +3332,12 @@
     protected boolean doDropFunction(MetadataProvider metadataProvider, FunctionDropStatement stmtDropFunction,
             FunctionSignature signature, IRequestParameters requestParameters) throws Exception {
         DataverseName dataverseName = signature.getDataverseName();
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        String databaseName = signature.getDatabaseName();
         SourceLocation sourceLoc = stmtDropFunction.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dataverse == null) {
                 if (stmtDropFunction.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3324,40 +3375,41 @@
         CreateAdapterStatement cas = (CreateAdapterStatement) stmt;
         String adapterName = cas.getAdapterName();
         metadataProvider.validateDatabaseObjectName(cas.getDataverseName(), adapterName, cas.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(cas.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cas.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         DataverseName libraryDataverseName = cas.getLibraryDataverseName();
+        String libraryDatabaseName = cas.getLibraryDatabaseName();
         if (libraryDataverseName == null) {
             libraryDataverseName = dataverseName;
+            libraryDatabaseName = databaseName;
         }
-        String libraryDatabase = MetadataUtil.resolveDatabase(null, libraryDataverseName);
         String libraryName = cas.getLibraryName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createAdapterBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, adapterName,
-                libraryDatabase, libraryDataverseName, libraryName);
+        lockUtil.createAdapterBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, adapterName,
+                libraryDatabaseName, libraryDataverseName, libraryName);
         try {
-            doCreateAdapter(metadataProvider, cas);
+            doCreateAdapter(metadataProvider, databaseName, dataverseName, cas);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
-    protected void doCreateAdapter(MetadataProvider metadataProvider, CreateAdapterStatement cas) throws Exception {
+    protected void doCreateAdapter(MetadataProvider metadataProvider, String databaseName, DataverseName dataverseName,
+            CreateAdapterStatement cas) throws Exception {
         SourceLocation sourceLoc = cas.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            DataverseName dataverseName = getActiveDataverseName(cas.getDataverseName());
-            String database = MetadataUtil.resolveDatabase(null, dataverseName);
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
             String adapterName = cas.getAdapterName();
             DatasourceAdapter adapter =
-                    MetadataManager.INSTANCE.getAdapter(mdTxnCtx, database, dataverseName, adapterName);
+                    MetadataManager.INSTANCE.getAdapter(mdTxnCtx, databaseName, dataverseName, adapterName);
             if (adapter != null) {
                 if (cas.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3367,13 +3419,14 @@
             }
 
             DataverseName libraryDataverseName = cas.getLibraryDataverseName();
+            String libraryDatabaseName = cas.getLibraryDatabaseName();
             if (libraryDataverseName == null) {
                 libraryDataverseName = dataverseName;
+                libraryDatabaseName = databaseName;
             }
-            String libraryDatabase = MetadataUtil.resolveDatabase(null, libraryDataverseName);
             String libraryName = cas.getLibraryName();
-            Library library =
-                    MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDatabase, libraryDataverseName, libraryName);
+            Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDatabaseName, libraryDataverseName,
+                    libraryName);
             if (library == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_LIBRARY, sourceLoc, libraryName);
             }
@@ -3390,9 +3443,9 @@
             }
             String adapterFactoryClass = externalIdentifier.get(0);
 
-            adapter = new DatasourceAdapter(new AdapterIdentifier(database, dataverseName, adapterName),
-                    IDataSourceAdapter.AdapterType.EXTERNAL, adapterFactoryClass, libraryDatabase, libraryDataverseName,
-                    libraryName);
+            adapter = new DatasourceAdapter(new AdapterIdentifier(databaseName, dataverseName, adapterName),
+                    IDataSourceAdapter.AdapterType.EXTERNAL, adapterFactoryClass, libraryDatabaseName,
+                    libraryDataverseName, libraryName);
             MetadataManager.INSTANCE.addAdapter(mdTxnCtx, adapter);
             if (LOGGER.isInfoEnabled()) {
                 LOGGER.info("Installed adapter: " + adapterName);
@@ -3409,27 +3462,27 @@
         SourceLocation sourceLoc = stmtDropAdapter.getSourceLocation();
         String adapterName = stmtDropAdapter.getAdapterName();
         metadataProvider.validateDatabaseObjectName(stmtDropAdapter.getDataverseName(), adapterName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtDropAdapter.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtDropAdapter.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropAdapterBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, adapterName);
+        lockUtil.dropAdapterBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, adapterName);
         try {
-            doDropAdapter(metadataProvider, stmtDropAdapter, dataverseName, adapterName);
+            doDropAdapter(metadataProvider, stmtDropAdapter, databaseName, dataverseName, adapterName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected boolean doDropAdapter(MetadataProvider metadataProvider, AdapterDropStatement stmtDropAdapter,
-            DataverseName dataverseName, String adapterName) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            String databaseName, DataverseName dataverseName, String adapterName) throws Exception {
         SourceLocation sourceLoc = stmtDropAdapter.getSourceLocation();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dataverse == null) {
                 if (stmtDropAdapter.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3439,7 +3492,7 @@
                 }
             }
             DatasourceAdapter adapter =
-                    MetadataManager.INSTANCE.getAdapter(mdTxnCtx, database, dataverseName, adapterName);
+                    MetadataManager.INSTANCE.getAdapter(mdTxnCtx, databaseName, dataverseName, adapterName);
             if (adapter == null) {
                 if (stmtDropAdapter.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3449,7 +3502,7 @@
                 }
             }
 
-            MetadataManager.INSTANCE.dropAdapter(mdTxnCtx, database, dataverseName, adapterName);
+            MetadataManager.INSTANCE.dropAdapter(mdTxnCtx, databaseName, dataverseName, adapterName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return true;
         } catch (Exception e) {
@@ -3463,25 +3516,26 @@
         CreateLibraryStatement cls = (CreateLibraryStatement) stmt;
         metadataProvider.validateDatabaseObjectName(cls.getDataverseName(), cls.getLibraryName(),
                 cls.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(cls.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cls.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String libraryName = cls.getLibraryName();
         String libraryHash = cls.getHash();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createLibraryBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, libraryName);
+        lockUtil.createLibraryBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, libraryName);
         try {
-            doCreateLibrary(metadataProvider, dataverseName, libraryName, libraryHash, cls, hcc, requestParameters);
+            doCreateLibrary(metadataProvider, databaseName, dataverseName, libraryName, libraryHash, cls, hcc,
+                    requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
-    protected CreateResult doCreateLibrary(MetadataProvider metadataProvider, DataverseName dataverseName,
-            String libraryName, String libraryHash, CreateLibraryStatement cls, IHyracksClientConnection hcc,
-            IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+    protected CreateResult doCreateLibrary(MetadataProvider metadataProvider, String databaseName,
+            DataverseName dataverseName, String libraryName, String libraryHash, CreateLibraryStatement cls,
+            IHyracksClientConnection hcc, IRequestParameters requestParameters) throws Exception {
         JobUtils.ProgressState progress = ProgressState.NO_PROGRESS;
         boolean prepareJobSuccessful = false;
         JobSpecification abortJobSpec = null;
@@ -3490,20 +3544,20 @@
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, dataverseName);
             }
             ExternalFunctionLanguage language = cls.getLang();
-            existingLibrary = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, database, dataverseName, libraryName);
+            existingLibrary = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
             if (existingLibrary != null && !cls.getReplaceIfExists()) {
                 throw new CompilationException(ErrorCode.COMPILATION_ERROR,
                         "A library with this name " + libraryName + " already exists.");
             }
 
             // #. add/update library with PendingAddOp
-            Library libraryPendingAdd = new Library(database, dataverseName, libraryName, language.name(), libraryHash,
-                    MetadataUtil.PENDING_ADD_OP);
+            Library libraryPendingAdd = new Library(databaseName, dataverseName, libraryName, language.name(),
+                    libraryHash, MetadataUtil.PENDING_ADD_OP);
             if (existingLibrary == null) {
                 MetadataManager.INSTANCE.addLibrary(mdTxnCtx, libraryPendingAdd);
             } else {
@@ -3511,6 +3565,7 @@
             }
 
             // #. prepare to create library artifacts in NC.
+            //TODO(DB):
             Triple<JobSpecification, JobSpecification, JobSpecification> jobSpecs =
                     ExternalLibraryJobUtils.buildCreateLibraryJobSpec(dataverseName, libraryName, language,
                             cls.getLocation(), cls.getAuthToken(), metadataProvider);
@@ -3532,7 +3587,7 @@
             bActiveTxn = true;
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
 
-            Library newLibrary = new Library(database, dataverseName, libraryName, language.name(), libraryHash,
+            Library newLibrary = new Library(databaseName, dataverseName, libraryName, language.name(), libraryHash,
                     MetadataUtil.PENDING_NO_OP);
             MetadataManager.INSTANCE.updateLibrary(mdTxnCtx, newLibrary);
 
@@ -3555,6 +3610,7 @@
                 } else if (existingLibrary == null) {
                     // 'commit' job failed for a new library -> try removing the library
                     try {
+                        //TODO(DB):
                         JobSpecification dropLibraryJobSpec = ExternalLibraryJobUtils
                                 .buildDropLibraryJobSpec(dataverseName, libraryName, metadataProvider);
                         runJob(hcc, dropLibraryJobSpec, jobFlags);
@@ -3571,7 +3627,7 @@
                 mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
                 try {
                     if (existingLibrary == null) {
-                        MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, database, dataverseName, libraryName);
+                        MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
                     } else {
                         MetadataManager.INSTANCE.updateLibrary(mdTxnCtx, existingLibrary);
                     }
@@ -3598,29 +3654,30 @@
         String libraryName = stmtDropLibrary.getLibraryName();
         metadataProvider.validateDatabaseObjectName(stmtDropLibrary.getDataverseName(), libraryName,
                 stmtDropLibrary.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtDropLibrary.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtDropLibrary.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropLibraryBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, libraryName);
+        lockUtil.dropLibraryBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, libraryName);
         try {
-            doDropLibrary(metadataProvider, stmtDropLibrary, dataverseName, libraryName, hcc, requestParameters);
+            doDropLibrary(metadataProvider, stmtDropLibrary, databaseName, dataverseName, libraryName, hcc,
+                    requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected boolean doDropLibrary(MetadataProvider metadataProvider, LibraryDropStatement stmtDropLibrary,
-            DataverseName dataverseName, String libraryName, IHyracksClientConnection hcc,
+            String databaseName, DataverseName dataverseName, String libraryName, IHyracksClientConnection hcc,
             IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         JobUtils.ProgressState progress = ProgressState.NO_PROGRESS;
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dataverse == null) {
                 if (stmtDropLibrary.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3630,7 +3687,7 @@
                             dataverseName);
                 }
             }
-            Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, database, dataverseName, libraryName);
+            Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
             if (library == null) {
                 if (stmtDropLibrary.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3643,11 +3700,12 @@
 
             // #. mark the existing library as PendingDropOp
             // do drop instead of update because drop will fail if the library is used by functions/adapters
-            MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, database, dataverseName, libraryName);
-            MetadataManager.INSTANCE.addLibrary(mdTxnCtx, new Library(database, dataverseName, libraryName,
+            MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
+            MetadataManager.INSTANCE.addLibrary(mdTxnCtx, new Library(databaseName, dataverseName, libraryName,
                     library.getLanguage(), library.getHash(), MetadataUtil.PENDING_DROP_OP));
 
             // #. drop library artifacts in NCs.
+            //TODO(DB):
             JobSpecification jobSpec =
                     ExternalLibraryJobUtils.buildDropLibraryJobSpec(dataverseName, libraryName, metadataProvider);
 
@@ -3664,7 +3722,7 @@
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
 
             // #. drop library
-            MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, database, dataverseName, libraryName);
+            MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
 
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return true;
@@ -3676,7 +3734,7 @@
                 // remove the record from the metadata.
                 mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
                 try {
-                    MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, database, dataverseName, libraryName);
+                    MetadataManager.INSTANCE.dropLibrary(mdTxnCtx, databaseName, dataverseName, libraryName);
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
                 } catch (Exception e2) {
                     e.addSuppressed(e2);
@@ -3693,36 +3751,36 @@
         CreateSynonymStatement css = (CreateSynonymStatement) stmt;
         metadataProvider.validateDatabaseObjectName(css.getDataverseName(), css.getSynonymName(),
                 css.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(css.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(css.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String synonymName = css.getSynonymName();
-        DataverseName objectDataverseName =
-                css.getObjectDataverseName() != null ? css.getObjectDataverseName() : dataverseName;
+        Namespace objectNamespace = css.getObjectNamespace() != null ? css.getObjectNamespace() : stmtActiveNamespace;
         String objectName = css.getObjectName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createSynonymBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, synonymName);
+        lockUtil.createSynonymBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, synonymName);
         try {
-            doCreateSynonym(metadataProvider, css, dataverseName, synonymName, objectDataverseName, objectName);
+            doCreateSynonym(metadataProvider, css, stmtActiveNamespace, synonymName, objectNamespace, objectName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected CreateResult doCreateSynonym(MetadataProvider metadataProvider, CreateSynonymStatement css,
-            DataverseName dataverseName, String synonymName, DataverseName objectDataverseName, String objectName)
-            throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            Namespace namespace, String synonymName, Namespace objectNamespace, String objectName) throws Exception {
+        String databaseName = namespace.getDatabaseName();
+        DataverseName dataverseName = namespace.getDataverseName();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, css.getSourceLocation(), dataverseName);
             }
-            Synonym synonym = MetadataManager.INSTANCE.getSynonym(metadataProvider.getMetadataTxnContext(), database,
-                    dataverseName, synonymName);
+            Synonym synonym = MetadataManager.INSTANCE.getSynonym(metadataProvider.getMetadataTxnContext(),
+                    databaseName, dataverseName, synonymName);
             if (synonym != null) {
                 if (css.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3734,9 +3792,8 @@
                 }
                 throw new CompilationException(ErrorCode.SYNONYM_EXISTS, css.getSourceLocation(), synonymName);
             }
-            String objectDatabaseName = MetadataUtil.resolveDatabase(null, objectDataverseName);
-            synonym = new Synonym(database, dataverseName, synonymName, objectDatabaseName, objectDataverseName,
-                    objectName);
+            synonym = new Synonym(databaseName, dataverseName, synonymName, objectNamespace.getDatabaseName(),
+                    objectNamespace.getDataverseName(), objectName);
             MetadataManager.INSTANCE.addSynonym(metadataProvider.getMetadataTxnContext(), synonym);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return CreateResult.CREATED;
@@ -3751,26 +3808,26 @@
         String synonymName = stmtSynDrop.getSynonymName();
         metadataProvider.validateDatabaseObjectName(stmtSynDrop.getDataverseName(), synonymName,
                 stmtSynDrop.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtSynDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtSynDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.dropSynonymBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, synonymName);
+        lockUtil.dropSynonymBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, synonymName);
         try {
-            doDropSynonym(metadataProvider, stmtSynDrop, dataverseName, synonymName);
+            doDropSynonym(metadataProvider, stmtSynDrop, databaseName, dataverseName, synonymName);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected boolean doDropSynonym(MetadataProvider metadataProvider, SynonymDropStatement stmtSynDrop,
-            DataverseName dataverseName, String synonymName) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+            String databaseName, DataverseName dataverseName, String synonymName) throws Exception {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
-            Synonym synonym = MetadataManager.INSTANCE.getSynonym(mdTxnCtx, database, dataverseName, synonymName);
+            Synonym synonym = MetadataManager.INSTANCE.getSynonym(mdTxnCtx, databaseName, dataverseName, synonymName);
             if (synonym == null) {
                 if (stmtSynDrop.getIfExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -3778,7 +3835,7 @@
                 }
                 throw new CompilationException(ErrorCode.UNKNOWN_SYNONYM, stmtSynDrop.getSourceLocation(), synonymName);
             }
-            MetadataManager.INSTANCE.dropSynonym(mdTxnCtx, database, dataverseName, synonymName);
+            MetadataManager.INSTANCE.dropSynonym(mdTxnCtx, databaseName, dataverseName, synonymName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             return true;
         } catch (Exception e) {
@@ -3793,17 +3850,18 @@
         String datasetName = loadStmt.getDatasetName();
         metadataProvider.validateDatabaseObjectName(loadStmt.getDataverseName(), datasetName,
                 loadStmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(loadStmt.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(loadStmt.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.modifyDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName);
+        lockUtil.modifyDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName);
         try {
             Map<String, String> properties = loadStmt.getProperties();
             ExternalDataUtils.normalize(properties);
             ExternalDataUtils.validate(properties);
-            CompiledLoadFromFileStatement cls = new CompiledLoadFromFileStatement(dataverseName,
+            CompiledLoadFromFileStatement cls = new CompiledLoadFromFileStatement(databaseName, dataverseName,
                     loadStmt.getDatasetName(), loadStmt.getAdapter(), properties, loadStmt.dataIsAlreadySorted());
             cls.setSourceLocation(stmt.getSourceLocation());
             JobSpecification spec = apiFramework.compileQuery(hcc, metadataProvider, null, 0, null, sessionOutput, cls,
@@ -3824,9 +3882,9 @@
         }
     }
 
-    protected Map<String, String> createExternalDataPropertiesForCopyStmt(DataverseName dataverseName,
-            CopyStatement copyStatement, Datatype itemType, MetadataTransactionContext mdTxnCtx)
-            throws AlgebricksException {
+    protected Map<String, String> createExternalDataPropertiesForCopyStmt(String databaseName,
+            DataverseName dataverseName, CopyStatement copyStatement, Datatype itemType,
+            MetadataTransactionContext mdTxnCtx) throws AlgebricksException {
         return copyStatement.getExternalDetails().getProperties();
     }
 
@@ -3836,44 +3894,47 @@
         String datasetName = copyStmt.getDatasetName();
         metadataProvider.validateDatabaseObjectName(copyStmt.getDataverseName(), datasetName,
                 copyStmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(copyStmt.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(copyStmt.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 datasetName);
         JobId jobId = null;
         boolean atomic = false;
         try {
             metadataProvider.setWriteTransaction(true);
-            Dataset dataset = metadataProvider.findDataset(database, dataverseName, copyStmt.getDatasetName());
+            Dataset dataset = metadataProvider.findDataset(databaseName, dataverseName, copyStmt.getDatasetName());
             if (dataset == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, stmt.getSourceLocation(),
                         datasetName, dataverseName);
             }
-            Datatype itemType = MetadataManager.INSTANCE.getDatatype(mdTxnCtx,
-                    MetadataUtil.resolveDatabase(null, dataset.getItemTypeDataverseName()),
+            Datatype itemType = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, dataset.getItemTypeDatabaseName(),
                     dataset.getItemTypeDataverseName(), dataset.getItemTypeName());
             // Copy statement with csv files will have a type expression
             if (copyStmt.getTypeExpr() != null) {
                 TypeExpression itemTypeExpr = copyStmt.getTypeExpr();
-                Triple<DataverseName, String, Boolean> itemTypeQualifiedName = extractDatasetItemTypeName(dataverseName,
-                        datasetName, itemTypeExpr, false, stmt.getSourceLocation());
-                DataverseName itemTypeDataverseName = itemTypeQualifiedName.first;
+                Triple<Namespace, String, Boolean> itemTypeQualifiedName = extractDatasetItemTypeName(
+                        stmtActiveNamespace, datasetName, itemTypeExpr, false, stmt.getSourceLocation());
+                Namespace itemTypeNamespace = itemTypeQualifiedName.first;
+                DataverseName itemTypeDataverseName = itemTypeNamespace.getDataverseName();
                 String itemTypeName = itemTypeQualifiedName.second;
-                String itemTypeDatabase = MetadataUtil.resolveDatabase(null, itemTypeDataverseName);
-                IAType itemTypeEntity = translateType(itemTypeDataverseName, itemTypeName, itemTypeExpr, mdTxnCtx);
-                itemType = new Datatype(itemTypeDatabase, itemTypeDataverseName, itemTypeName, itemTypeEntity, true);
+                String itemTypeDatabaseName = itemTypeNamespace.getDatabaseName();
+                IAType itemTypeEntity = translateType(itemTypeDatabaseName, itemTypeDataverseName, itemTypeName,
+                        itemTypeExpr, mdTxnCtx);
+                itemType =
+                        new Datatype(itemTypeDatabaseName, itemTypeDataverseName, itemTypeName, itemTypeEntity, true);
             }
             ExternalDetailsDecl externalDetails = copyStmt.getExternalDetails();
             Map<String, String> properties =
-                    createExternalDataPropertiesForCopyStmt(dataverseName, copyStmt, itemType, mdTxnCtx);
+                    createExternalDataPropertiesForCopyStmt(databaseName, dataverseName, copyStmt, itemType, mdTxnCtx);
             ExternalDataUtils.normalize(properties);
             ExternalDataUtils.validate(properties);
             validateExternalDatasetProperties(externalDetails, properties, copyStmt.getSourceLocation(), mdTxnCtx,
                     appCtx);
-            CompiledCopyFromFileStatement cls = new CompiledCopyFromFileStatement(dataverseName,
+            CompiledCopyFromFileStatement cls = new CompiledCopyFromFileStatement(databaseName, dataverseName,
                     copyStmt.getDatasetName(), itemType, externalDetails.getAdapter(), properties);
             cls.setSourceLocation(stmt.getSourceLocation());
             JobSpecification spec = apiFramework.compileQuery(hcc, metadataProvider, null, 0, null, sessionOutput, cls,
@@ -3928,13 +3989,14 @@
         String datasetName = stmtInsertUpsert.getDatasetName();
         metadataProvider.validateDatabaseObjectName(stmtInsertUpsert.getDataverseName(), datasetName,
                 stmtInsertUpsert.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtInsertUpsert.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtInsertUpsert.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         final IMetadataLocker locker = new IMetadataLocker() {
             @Override
             public void lock() throws AlgebricksException {
                 compilationLock.readLock().lock();
-                lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+                lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                         datasetName);
             }
 
@@ -3974,10 +4036,7 @@
                 if (jobSpec == null) {
                     return jobSpec;
                 }
-                String insertStmtDatabase =
-                        MetadataUtil.resolveDatabase(null, ((InsertStatement) stmt).getDataverseName());
-                Dataset ds = metadataProvider.findDataset(insertStmtDatabase,
-                        ((InsertStatement) stmt).getDataverseName(), ((InsertStatement) stmt).getDatasetName());
+                Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
                 atomic = ds.isAtomic();
                 if (atomic) {
                     int numParticipatingNodes = appCtx.getNodeJobTracker()
@@ -4020,19 +4079,21 @@
         String datasetName = stmtDelete.getDatasetName();
         metadataProvider.validateDatabaseObjectName(stmtDelete.getDataverseName(), datasetName,
                 stmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(stmtDelete.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtDelete.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.insertDeleteUpsertBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 datasetName);
         boolean atomic = false;
         JobId jobId = null;
         try {
             metadataProvider.setWriteTransaction(true);
-            CompiledDeleteStatement clfrqs = new CompiledDeleteStatement(stmtDelete.getVariableExpr(), dataverseName,
-                    datasetName, stmtDelete.getCondition(), stmtDelete.getVarCounter(), stmtDelete.getQuery());
+            CompiledDeleteStatement clfrqs =
+                    new CompiledDeleteStatement(stmtDelete.getVariableExpr(), databaseName, dataverseName, datasetName,
+                            stmtDelete.getCondition(), stmtDelete.getVarCounter(), stmtDelete.getQuery());
             clfrqs.setSourceLocation(stmt.getSourceLocation());
             JobSpecification jobSpec =
                     rewriteCompileQuery(hcc, metadataProvider, clfrqs.getQuery(), clfrqs, stmtParams, null);
@@ -4041,7 +4102,7 @@
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             bActiveTxn = false;
             if (jobSpec != null && !isCompileOnly()) {
-                Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+                Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
                 atomic = ds.isAtomic();
                 if (atomic) {
                     int numParticipatingNodes = appCtx.getNodeJobTracker()
@@ -4114,20 +4175,22 @@
                 insertUpsert, sessionOutput, true, true, externalVars.keySet());
 
         InsertStatement rewrittenInsertUpsert = (InsertStatement) rewrittenResult.first;
-        DataverseName dataverseName = getActiveDataverseName(rewrittenInsertUpsert.getDataverseName());
+        Namespace stmtActiveNamespace = getActiveNamespace(rewrittenInsertUpsert.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = rewrittenInsertUpsert.getDatasetName();
         CompiledInsertStatement clfrqs;
         switch (insertUpsert.getKind()) {
             case INSERT:
-                clfrqs = new CompiledInsertStatement(dataverseName, datasetName, rewrittenInsertUpsert.getQuery(),
-                        rewrittenInsertUpsert.getVarCounter(), rewrittenInsertUpsert.getVar(),
-                        rewrittenInsertUpsert.getReturnExpression());
+                clfrqs = new CompiledInsertStatement(databaseName, dataverseName, datasetName,
+                        rewrittenInsertUpsert.getQuery(), rewrittenInsertUpsert.getVarCounter(),
+                        rewrittenInsertUpsert.getVar(), rewrittenInsertUpsert.getReturnExpression());
                 clfrqs.setSourceLocation(insertUpsert.getSourceLocation());
                 break;
             case UPSERT:
-                clfrqs = new CompiledUpsertStatement(dataverseName, datasetName, rewrittenInsertUpsert.getQuery(),
-                        rewrittenInsertUpsert.getVarCounter(), rewrittenInsertUpsert.getVar(),
-                        rewrittenInsertUpsert.getReturnExpression());
+                clfrqs = new CompiledUpsertStatement(databaseName, dataverseName, datasetName,
+                        rewrittenInsertUpsert.getQuery(), rewrittenInsertUpsert.getVarCounter(),
+                        rewrittenInsertUpsert.getVar(), rewrittenInsertUpsert.getReturnExpression());
                 clfrqs.setSourceLocation(insertUpsert.getSourceLocation());
                 break;
             default:
@@ -4146,16 +4209,17 @@
         SourceLocation sourceLoc = cfs.getSourceLocation();
         String feedName = cfs.getFeedName().getValue();
         metadataProvider.validateDatabaseObjectName(cfs.getDataverseName(), feedName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(cfs.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cfs.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.createFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, feedName);
+        lockUtil.createFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, feedName);
         try {
-            Feed feed = MetadataManager.INSTANCE.getFeed(metadataProvider.getMetadataTxnContext(), database,
+            Feed feed = MetadataManager.INSTANCE.getFeed(metadataProvider.getMetadataTxnContext(), databaseName,
                     dataverseName, feedName);
             if (feed != null) {
                 if (cfs.getIfNotExists()) {
@@ -4169,7 +4233,7 @@
             Map<String, String> configuration = cfs.getConfiguration();
             ExternalDataUtils.normalize(configuration);
             ExternalDataUtils.validate(configuration);
-            feed = new Feed(database, dataverseName, feedName, configuration);
+            feed = new Feed(databaseName, dataverseName, feedName, configuration);
             FeedMetadataUtil.validateFeed(feed, mdTxnCtx, appCtx, warningCollector);
             MetadataManager.INSTANCE.addFeed(metadataProvider.getMetadataTxnContext(), feed);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4189,17 +4253,18 @@
         SourceLocation sourceLoc = cfps.getSourceLocation();
         String policyName = cfps.getPolicyName();
         metadataProvider.validateDatabaseObjectName(null, policyName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(null);
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        DataverseName dataverseName = activeNamespace.getDataverseName();
+        String databaseName = activeNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.createFeedPolicyBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, policyName);
+        lockUtil.createFeedPolicyBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
+                policyName);
         try {
             mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
             FeedPolicyEntity feedPolicy = MetadataManager.INSTANCE
-                    .getFeedPolicy(metadataProvider.getMetadataTxnContext(), database, dataverseName, policyName);
+                    .getFeedPolicy(metadataProvider.getMetadataTxnContext(), databaseName, dataverseName, policyName);
             if (feedPolicy != null) {
                 if (cfps.getIfNotExists()) {
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4212,8 +4277,9 @@
             boolean extendingExisting = cfps.getSourcePolicyName() != null;
             String description = cfps.getDescription() == null ? "" : cfps.getDescription();
             if (extendingExisting) {
-                FeedPolicyEntity sourceFeedPolicy = MetadataManager.INSTANCE.getFeedPolicy(
-                        metadataProvider.getMetadataTxnContext(), database, dataverseName, cfps.getSourcePolicyName());
+                FeedPolicyEntity sourceFeedPolicy =
+                        MetadataManager.INSTANCE.getFeedPolicy(metadataProvider.getMetadataTxnContext(), databaseName,
+                                dataverseName, cfps.getSourcePolicyName());
                 if (sourceFeedPolicy == null) {
                     sourceFeedPolicy = MetadataManager.INSTANCE.getFeedPolicy(metadataProvider.getMetadataTxnContext(),
                             MetadataConstants.SYSTEM_DATABASE, MetadataConstants.METADATA_DATAVERSE_NAME,
@@ -4225,7 +4291,8 @@
                 }
                 Map<String, String> policyProperties = sourceFeedPolicy.getProperties();
                 policyProperties.putAll(cfps.getProperties());
-                newPolicy = new FeedPolicyEntity(database, dataverseName, policyName, description, policyProperties);
+                newPolicy =
+                        new FeedPolicyEntity(databaseName, dataverseName, policyName, description, policyProperties);
             } else {
                 Properties prop = new Properties();
                 try {
@@ -4237,7 +4304,8 @@
                 }
                 Map<String, String> policyProperties = new HashMap<>();
                 prop.forEach((key, value) -> policyProperties.put((String) key, (String) value));
-                newPolicy = new FeedPolicyEntity(database, dataverseName, policyName, description, policyProperties);
+                newPolicy =
+                        new FeedPolicyEntity(databaseName, dataverseName, policyName, description, policyProperties);
             }
             MetadataManager.INSTANCE.addFeedPolicy(mdTxnCtx, newPolicy);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4255,16 +4323,17 @@
         SourceLocation sourceLoc = stmtFeedDrop.getSourceLocation();
         String feedName = stmtFeedDrop.getFeedName().getValue();
         metadataProvider.validateDatabaseObjectName(stmtFeedDrop.getDataverseName(), feedName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtFeedDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtFeedDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.dropFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, feedName);
+        lockUtil.dropFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, feedName);
         try {
-            Feed feed = MetadataManager.INSTANCE.getFeed(mdTxnCtx, database, dataverseName, feedName);
+            Feed feed = MetadataManager.INSTANCE.getFeed(mdTxnCtx, databaseName, dataverseName, feedName);
             if (feed == null) {
                 if (!stmtFeedDrop.getIfExists()) {
                     throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc,
@@ -4297,11 +4366,11 @@
         } else if (listener != null) {
             listener.unregister();
         }
-        String feedDatabase = MetadataUtil.resolveDatabase(null, feedId.getDataverseName());
         JobSpecification spec = FeedOperations.buildRemoveFeedStorageJob(metadataProvider, MetadataManager.INSTANCE
-                .getFeed(mdTxnCtx, feedDatabase, feedId.getDataverseName(), feedId.getEntityName()));
+                .getFeed(mdTxnCtx, feedId.getDatabaseName(), feedId.getDataverseName(), feedId.getEntityName()));
         runJob(hcc, spec);
-        MetadataManager.INSTANCE.dropFeed(mdTxnCtx, feedDatabase, feed.getDataverseName(), feed.getFeedName());
+        MetadataManager.INSTANCE.dropFeed(mdTxnCtx, feed.getDatabaseName(), feed.getDataverseName(),
+                feed.getFeedName());
         if (LOGGER.isInfoEnabled()) {
             LOGGER.info("Removed feed " + feedId);
         }
@@ -4312,17 +4381,18 @@
         SourceLocation sourceLoc = stmtFeedPolicyDrop.getSourceLocation();
         String policyName = stmtFeedPolicyDrop.getPolicyName().getValue();
         metadataProvider.validateDatabaseObjectName(stmtFeedPolicyDrop.getDataverseName(), policyName, sourceLoc);
-        DataverseName dataverseName = getActiveDataverseName(stmtFeedPolicyDrop.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(stmtFeedPolicyDrop.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.dropFeedPolicyBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, policyName);
+        lockUtil.dropFeedPolicyBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, policyName);
         try {
             FeedPolicyEntity feedPolicy =
-                    MetadataManager.INSTANCE.getFeedPolicy(mdTxnCtx, database, dataverseName, policyName);
+                    MetadataManager.INSTANCE.getFeedPolicy(mdTxnCtx, databaseName, dataverseName, policyName);
             if (feedPolicy == null) {
                 if (!stmtFeedPolicyDrop.getIfExists()) {
                     throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc,
@@ -4331,7 +4401,7 @@
                 MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
                 return;
             }
-            MetadataManager.INSTANCE.dropFeedPolicy(mdTxnCtx, database, dataverseName, policyName);
+            MetadataManager.INSTANCE.dropFeedPolicy(mdTxnCtx, databaseName, dataverseName, policyName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
         } catch (Exception e) {
             abort(e, e, mdTxnCtx);
@@ -4345,24 +4415,25 @@
             IHyracksClientConnection hcc) throws Exception {
         StartFeedStatement sfs = (StartFeedStatement) stmt;
         SourceLocation sourceLoc = sfs.getSourceLocation();
-        DataverseName dataverseName = getActiveDataverseName(sfs.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(sfs.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String feedName = sfs.getFeedName().getValue();
         if (isCompileOnly()) {
             return;
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         boolean committed = false;
-        lockUtil.startFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, feedName);
+        lockUtil.startFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, feedName);
         try {
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
             // Runtime handler
-            EntityId entityId = new EntityId(Feed.EXTENSION_NAME, database, dataverseName, feedName);
+            EntityId entityId = new EntityId(Feed.EXTENSION_NAME, databaseName, dataverseName, feedName);
             // Feed & Feed Connections
-            Feed feed = FeedMetadataUtil.validateIfFeedExists(database, dataverseName, feedName,
+            Feed feed = FeedMetadataUtil.validateIfFeedExists(databaseName, dataverseName, feedName,
                     metadataProvider.getMetadataTxnContext());
             List<FeedConnection> feedConnections = MetadataManager.INSTANCE
-                    .getFeedConections(metadataProvider.getMetadataTxnContext(), database, dataverseName, feedName);
+                    .getFeedConections(metadataProvider.getMetadataTxnContext(), databaseName, dataverseName, feedName);
             if (feedConnections.isEmpty()) {
                 throw new CompilationException(ErrorCode.FEED_START_FEED_WITHOUT_CONNECTION, sourceLoc, feedName);
             }
@@ -4402,10 +4473,11 @@
     protected void handleStopFeedStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception {
         StopFeedStatement sfst = (StopFeedStatement) stmt;
         SourceLocation sourceLoc = sfst.getSourceLocation();
-        DataverseName dataverseName = getActiveDataverseName(sfst.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(sfst.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String feedName = sfst.getFeedName().getValue();
-        EntityId entityId = new EntityId(Feed.EXTENSION_NAME, database, dataverseName, feedName);
+        EntityId entityId = new EntityId(Feed.EXTENSION_NAME, databaseName, dataverseName, feedName);
         ActiveNotificationHandler activeEventHandler =
                 (ActiveNotificationHandler) appCtx.getActiveNotificationHandler();
         // Obtain runtime info from ActiveListener
@@ -4417,7 +4489,7 @@
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.stopFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, feedName);
+        lockUtil.stopFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, feedName);
         try {
             listener.stop(metadataProvider);
         } finally {
@@ -4429,8 +4501,9 @@
         FeedConnection fc;
         ConnectFeedStatement cfs = (ConnectFeedStatement) stmt;
         SourceLocation sourceLoc = cfs.getSourceLocation();
-        DataverseName dataverseName = getActiveDataverseName(cfs.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cfs.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String feedName = cfs.getFeedName();
         String datasetName = cfs.getDatasetName().getValue();
         String policyName = cfs.getPolicy();
@@ -4445,13 +4518,13 @@
         ActiveNotificationHandler activeEventHandler =
                 (ActiveNotificationHandler) appCtx.getActiveNotificationHandler();
         // Transaction handling
-        lockUtil.connectFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName,
+        lockUtil.connectFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName,
                 feedName);
         try {
             // validation
-            Dataset dataset =
-                    FeedMetadataUtil.validateIfDatasetExists(metadataProvider, database, dataverseName, datasetName);
-            Feed feed = FeedMetadataUtil.validateIfFeedExists(database, dataverseName, feedName,
+            Dataset dataset = FeedMetadataUtil.validateIfDatasetExists(metadataProvider, databaseName, dataverseName,
+                    datasetName);
+            Feed feed = FeedMetadataUtil.validateIfFeedExists(databaseName, dataverseName, feedName,
                     metadataProvider.getMetadataTxnContext());
             FeedEventsListener listener = (FeedEventsListener) activeEventHandler.getListener(feed.getFeedId());
             if (listener != null && listener.isActive()) {
@@ -4467,13 +4540,13 @@
                             func.getName());
                 }
             }
-            fc = MetadataManager.INSTANCE.getFeedConnection(metadataProvider.getMetadataTxnContext(), database,
+            fc = MetadataManager.INSTANCE.getFeedConnection(metadataProvider.getMetadataTxnContext(), databaseName,
                     dataverseName, feedName, datasetName);
             if (fc != null) {
                 throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc,
                         "Feed" + feedName + " is already connected to " + dataset() + " " + datasetName);
             }
-            fc = new FeedConnection(database, dataverseName, feedName, datasetName, appliedFunctions, policyName,
+            fc = new FeedConnection(databaseName, dataverseName, feedName, datasetName, appliedFunctions, policyName,
                     whereClauseBody, outputType.getTypeName());
             MetadataManager.INSTANCE.addFeedConnection(metadataProvider.getMetadataTxnContext(), fc);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4492,8 +4565,9 @@
     protected void handleDisconnectFeedStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception {
         DisconnectFeedStatement cfs = (DisconnectFeedStatement) stmt;
         SourceLocation sourceLoc = cfs.getSourceLocation();
-        DataverseName dataverseName = getActiveDataverseName(cfs.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(cfs.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = cfs.getDatasetName().getValue();
         String feedName = cfs.getFeedName().getValue();
         if (isCompileOnly()) {
@@ -4501,24 +4575,24 @@
         }
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
-        lockUtil.disconnectFeedBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName,
+        lockUtil.disconnectFeedBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName,
                 feedName);
         try {
             ActiveNotificationHandler activeEventHandler =
                     (ActiveNotificationHandler) appCtx.getActiveNotificationHandler();
             // Check whether feed is alive
             ActiveEntityEventsListener listener = (ActiveEntityEventsListener) activeEventHandler
-                    .getListener(new EntityId(Feed.EXTENSION_NAME, database, dataverseName, feedName));
+                    .getListener(new EntityId(Feed.EXTENSION_NAME, databaseName, dataverseName, feedName));
             if (listener != null && listener.isActive()) {
                 throw new CompilationException(ErrorCode.FEED_CHANGE_FEED_CONNECTIVITY_ON_ALIVE_FEED, sourceLoc,
                         feedName);
             }
-            FeedMetadataUtil.validateIfDatasetExists(metadataProvider, database, dataverseName,
+            FeedMetadataUtil.validateIfDatasetExists(metadataProvider, databaseName, dataverseName,
                     cfs.getDatasetName().getValue());
-            FeedMetadataUtil.validateIfFeedExists(database, dataverseName, cfs.getFeedName().getValue(), mdTxnCtx);
+            FeedMetadataUtil.validateIfFeedExists(databaseName, dataverseName, cfs.getFeedName().getValue(), mdTxnCtx);
             FeedConnection fc = MetadataManager.INSTANCE.getFeedConnection(metadataProvider.getMetadataTxnContext(),
-                    database, dataverseName, feedName, datasetName);
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+                    databaseName, dataverseName, feedName, datasetName);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
@@ -4527,7 +4601,7 @@
                 throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc, "Feed " + feedName
                         + " is currently not connected to " + cfs.getDatasetName().getValue() + ". Invalid operation!");
             }
-            MetadataManager.INSTANCE.dropFeedConnection(mdTxnCtx, database, dataverseName, feedName, datasetName);
+            MetadataManager.INSTANCE.dropFeedConnection(mdTxnCtx, databaseName, dataverseName, feedName, datasetName);
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
             if (listener != null) {
                 listener.remove(ds);
@@ -4545,24 +4619,26 @@
         AnalyzeStatement analyzeStatement = (AnalyzeStatement) stmt;
         metadataProvider.validateDatabaseObjectName(analyzeStatement.getDataverseName(),
                 analyzeStatement.getDatasetName(), analyzeStatement.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(analyzeStatement.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(analyzeStatement.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = analyzeStatement.getDatasetName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.analyzeDatasetBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName);
+        lockUtil.analyzeDatasetBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
+                datasetName);
         try {
-            doAnalyzeDataset(metadataProvider, analyzeStatement, dataverseName, datasetName, hcc, requestParameters);
+            doAnalyzeDataset(metadataProvider, analyzeStatement, databaseName, dataverseName, datasetName, hcc,
+                    requestParameters);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected void doAnalyzeDataset(MetadataProvider metadataProvider, AnalyzeStatement stmtAnalyze,
-            DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
+            String databaseName, DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
             IRequestParameters requestParameters) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         SourceLocation sourceLoc = stmtAnalyze.getSourceLocation();
         ProgressState progressNewIndexCreate = ProgressState.NO_PROGRESS;
         ProgressState progressExistingIndexDrop = ProgressState.NO_PROGRESS;
@@ -4574,12 +4650,12 @@
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
             // Check if the dataverse exists
-            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, database, dataverseName);
+            Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, databaseName, dataverseName);
             if (dv == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName);
             }
             // Check if the dataset exists
-            ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+            ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
@@ -4593,13 +4669,13 @@
             IndexType sampleIndexType = IndexType.SAMPLE;
             Pair<String, String> sampleIndexNames = IndexUtil.getSampleIndexNames(datasetName);
             String newIndexName;
-            existingIndex = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(), database,
+            existingIndex = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(), databaseName,
                     dataverseName, datasetName, sampleIndexNames.first);
             if (existingIndex != null) {
                 newIndexName = sampleIndexNames.second;
             } else {
-                existingIndex = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(), database,
-                        dataverseName, datasetName, sampleIndexNames.second);
+                existingIndex = MetadataManager.INSTANCE.getIndex(metadataProvider.getMetadataTxnContext(),
+                        databaseName, dataverseName, datasetName, sampleIndexNames.second);
                 newIndexName = sampleIndexNames.first;
             }
 
@@ -4610,7 +4686,7 @@
             Index.SampleIndexDetails newIndexDetailsPendingAdd = new Index.SampleIndexDetails(dsDetails.getPrimaryKey(),
                     dsDetails.getKeySourceIndicator(), dsDetails.getPrimaryKeyType(), sampleCardinalityTarget, 0, 0,
                     sampleSeed, Collections.emptyMap());
-            newIndexPendingAdd = new Index(database, dataverseName, datasetName, newIndexName, sampleIndexType,
+            newIndexPendingAdd = new Index(databaseName, dataverseName, datasetName, newIndexName, sampleIndexType,
                     newIndexDetailsPendingAdd, false, false, MetadataUtil.PENDING_ADD_OP);
 
             // #. add a new index with PendingAddOp
@@ -4631,7 +4707,7 @@
             runJob(hcc, spec);
 
             // #. flush dataset
-            FlushDatasetUtil.flushDataset(hcc, metadataProvider, database, dataverseName, datasetName);
+            FlushDatasetUtil.flushDataset(hcc, metadataProvider, databaseName, dataverseName, datasetName);
 
             mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
             bActiveTxn = true;
@@ -4652,7 +4728,7 @@
             Index.SampleIndexDetails newIndexDetailsFinal = new Index.SampleIndexDetails(dsDetails.getPrimaryKey(),
                     dsDetails.getKeySourceIndicator(), dsDetails.getPrimaryKeyType(), sampleCardinalityTarget,
                     stats.getCardinality(), stats.getAvgTupleSize(), sampleSeed, stats.getIndexesStats());
-            Index newIndexFinal = new Index(database, dataverseName, datasetName, newIndexName, sampleIndexType,
+            Index newIndexFinal = new Index(databaseName, dataverseName, datasetName, newIndexName, sampleIndexType,
                     newIndexDetailsFinal, false, false, MetadataUtil.PENDING_NO_OP);
 
             // #. begin new metadataTxn
@@ -4770,25 +4846,26 @@
         AnalyzeDropStatement analyzeDropStmt = (AnalyzeDropStatement) stmt;
         metadataProvider.validateDatabaseObjectName(analyzeDropStmt.getDataverseName(),
                 analyzeDropStmt.getDatasetName(), analyzeDropStmt.getSourceLocation());
-        DataverseName dataverseName = getActiveDataverseName(analyzeDropStmt.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(analyzeDropStmt.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = analyzeDropStmt.getDatasetName();
         if (isCompileOnly()) {
             return;
         }
-        lockUtil.analyzeDatasetDropBegin(lockManager, metadataProvider.getLocks(), database, dataverseName,
+        lockUtil.analyzeDatasetDropBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName,
                 datasetName);
         try {
-            doAnalyzeDatasetDrop(metadataProvider, analyzeDropStmt, dataverseName, datasetName, hcc, requestParams);
+            doAnalyzeDatasetDrop(metadataProvider, analyzeDropStmt, databaseName, dataverseName, datasetName, hcc,
+                    requestParams);
         } finally {
             metadataProvider.getLocks().unlock();
         }
     }
 
     protected boolean doAnalyzeDatasetDrop(MetadataProvider metadataProvider, AnalyzeDropStatement stmtIndexDrop,
-            DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
+            String databaseName, DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc,
             IRequestParameters requestParams) throws Exception {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         SourceLocation sourceLoc = stmtIndexDrop.getSourceLocation();
         Pair<String, String> sampleIndexNames = IndexUtil.getSampleIndexNames(datasetName);
         String indexName1 = sampleIndexNames.first;
@@ -4801,7 +4878,7 @@
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         boolean index1Exists = false, index2Exists = false;
         try {
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
@@ -4810,9 +4887,9 @@
                 throw new CompilationException(ErrorCode.OPERATION_NOT_SUPPORTED, sourceLoc);
             }
             Index index1 =
-                    MetadataManager.INSTANCE.getIndex(mdTxnCtx, database, dataverseName, datasetName, indexName1);
+                    MetadataManager.INSTANCE.getIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName1);
             Index index2 =
-                    MetadataManager.INSTANCE.getIndex(mdTxnCtx, database, dataverseName, datasetName, indexName2);
+                    MetadataManager.INSTANCE.getIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName2);
             index1Exists = index1 != null;
             index2Exists = index2 != null;
             if (!index1Exists && !index2Exists) {
@@ -4821,10 +4898,10 @@
             }
             ensureNonPrimaryIndexesDrop(index1, index2, sourceLoc);
             validateDatasetState(metadataProvider, ds, sourceLoc);
-            prepareIndexDrop(metadataProvider, dataverseName, datasetName, sourceLoc, indexName1, jobsToExecute,
-                    mdTxnCtx, ds, index1);
-            prepareIndexDrop(metadataProvider, dataverseName, datasetName, sourceLoc, indexName2, jobsToExecute,
-                    mdTxnCtx, ds, index2);
+            prepareIndexDrop(metadataProvider, databaseName, dataverseName, datasetName, sourceLoc, indexName1,
+                    jobsToExecute, mdTxnCtx, ds, index1);
+            prepareIndexDrop(metadataProvider, databaseName, dataverseName, datasetName, sourceLoc, indexName2,
+                    jobsToExecute, mdTxnCtx, ds, index2);
 
             // #. commit the existing transaction before calling runJob.
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4842,10 +4919,10 @@
 
             // #. finally, delete the existing indexes
             if (index1Exists) {
-                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, database, dataverseName, datasetName, indexName1);
+                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName1);
             }
             if (index2Exists) {
-                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, database, dataverseName, datasetName, indexName2);
+                MetadataManager.INSTANCE.dropIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName2);
             }
 
             MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4871,11 +4948,11 @@
                 metadataProvider.setMetadataTxnContext(mdTxnCtx);
                 try {
                     if (index1Exists) {
-                        MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), database,
+                        MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), databaseName,
                                 dataverseName, datasetName, indexName1);
                     }
                     if (index2Exists) {
-                        MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), database,
+                        MetadataManager.INSTANCE.dropIndex(metadataProvider.getMetadataTxnContext(), databaseName,
                                 dataverseName, datasetName, indexName2);
                     }
                     MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
@@ -4904,18 +4981,17 @@
         }
     }
 
-    private void prepareIndexDrop(MetadataProvider metadataProvider, DataverseName dataverseName, String datasetName,
-            SourceLocation sourceLoc, String indexName, List<JobSpecification> jobsToExecute,
+    private void prepareIndexDrop(MetadataProvider metadataProvider, String databaseName, DataverseName dataverseName,
+            String datasetName, SourceLocation sourceLoc, String indexName, List<JobSpecification> jobsToExecute,
             MetadataTransactionContext mdTxnCtx, Dataset ds, Index index) throws AlgebricksException {
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
         if (index != null) {
             // #. prepare a job to drop the index in NC.
             jobsToExecute.add(IndexUtil.buildDropIndexJobSpec(index, metadataProvider, ds, sourceLoc));
 
             // #. mark PendingDropOp on the existing index
-            MetadataManager.INSTANCE.dropIndex(mdTxnCtx, database, dataverseName, datasetName, indexName);
+            MetadataManager.INSTANCE.dropIndex(mdTxnCtx, databaseName, dataverseName, datasetName, indexName);
             MetadataManager.INSTANCE.addIndex(mdTxnCtx,
-                    new Index(database, dataverseName, datasetName, indexName, index.getIndexType(),
+                    new Index(databaseName, dataverseName, datasetName, indexName, index.getIndexType(),
                             index.getIndexDetails(), index.isEnforced(), index.isPrimaryIndex(),
                             MetadataUtil.PENDING_DROP_OP));
         }
@@ -4925,8 +5001,9 @@
             IHyracksClientConnection hcc) throws Exception {
         CompactStatement compactStatement = (CompactStatement) stmt;
         SourceLocation sourceLoc = compactStatement.getSourceLocation();
-        DataverseName dataverseName = getActiveDataverseName(compactStatement.getDataverseName());
-        String database = MetadataUtil.resolveDatabase(null, dataverseName);
+        Namespace stmtActiveNamespace = getActiveNamespace(compactStatement.getNamespace());
+        DataverseName dataverseName = stmtActiveNamespace.getDataverseName();
+        String databaseName = stmtActiveNamespace.getDatabaseName();
         String datasetName = compactStatement.getDatasetName().getValue();
         if (isCompileOnly()) {
             return;
@@ -4935,22 +5012,22 @@
         boolean bActiveTxn = true;
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         List<JobSpecification> jobsToExecute = new ArrayList<>();
-        lockUtil.compactBegin(lockManager, metadataProvider.getLocks(), database, dataverseName, datasetName);
+        lockUtil.compactBegin(lockManager, metadataProvider.getLocks(), databaseName, dataverseName, datasetName);
         try {
-            Dataset ds = metadataProvider.findDataset(database, dataverseName, datasetName);
+            Dataset ds = metadataProvider.findDataset(databaseName, dataverseName, datasetName);
             if (ds == null) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATASET_IN_DATAVERSE, sourceLoc, datasetName,
                         dataverseName);
             }
             // Prepare jobs to compact the datatset and its indexes
             List<Index> indexes =
-                    MetadataManager.INSTANCE.getDatasetIndexes(mdTxnCtx, database, dataverseName, datasetName);
+                    MetadataManager.INSTANCE.getDatasetIndexes(mdTxnCtx, databaseName, dataverseName, datasetName);
             if (indexes.isEmpty()) {
                 throw new CompilationException(ErrorCode.COMPILATION_ERROR, sourceLoc,
                         "Cannot compact the external " + dataset() + " " + datasetName + " because it has no indexes");
             }
             Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(metadataProvider.getMetadataTxnContext(),
-                    database, dataverseName);
+                    databaseName, dataverseName);
             jobsToExecute.add(DatasetUtil.compactDatasetJobSpec(dataverse, datasetName, metadataProvider));
 
             if (ds.getDatasetType() == DatasetType.INTERNAL) {
@@ -5191,11 +5268,9 @@
             // ensure request not cancelled before running job
             ensureNotCancelled(clientRequest);
             if (atomicStatement != null) {
-                String database =
-                        MetadataUtil.resolveDatabase(null, ((InsertStatement) atomicStatement).getDataverseName());
-                Dataset ds =
-                        metadataProvider.findDataset(database, ((InsertStatement) atomicStatement).getDataverseName(),
-                                ((InsertStatement) atomicStatement).getDatasetName());
+                Dataset ds = metadataProvider.findDataset(((InsertStatement) atomicStatement).getDatabaseName(),
+                        ((InsertStatement) atomicStatement).getDataverseName(),
+                        ((InsertStatement) atomicStatement).getDatasetName());
                 atomic = ds.isAtomic();
                 if (atomic) {
                     int numParticipatingNodes = appCtx.getNodeJobTracker()
@@ -5284,12 +5359,8 @@
     }
 
     @Override
-    public DataverseName getActiveDataverseName(DataverseName dataverseName) {
-        return dataverseName != null ? dataverseName : activeDataverse.getDataverseName();
-    }
-
-    public Dataverse getActiveDataverse() {
-        return activeDataverse;
+    public Namespace getActiveNamespace(Namespace namespace) {
+        return namespace != null ? namespace : activeNamespace;
     }
 
     @Override
diff --git a/asterixdb/asterix-app/src/main/java/org/apache/asterix/utils/FeedOperations.java b/asterixdb/asterix-app/src/main/java/org/apache/asterix/utils/FeedOperations.java
index 11ca118..85014ab 100644
--- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/utils/FeedOperations.java
+++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/utils/FeedOperations.java
@@ -34,6 +34,7 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.common.transactions.TxnId;
 import org.apache.asterix.external.api.ITypedAdapterFactory;
 import org.apache.asterix.external.feed.management.FeedConnectionId;
@@ -222,15 +223,17 @@
         metadataProvider.getConfig().put(FeedActivityDetails.FEED_POLICY_NAME, feedConn.getPolicyName());
         Query feedConnQuery = makeConnectionQuery(feedConn, metadataProvider);
         CompiledStatements.ICompiledDmlStatement clfrqs;
+        String feedDatabaseName = feedConn.getDatabaseName();
+        DataverseName feedDataverseName = feedConn.getDataverseName();
         if (insertFeed) {
-            InsertStatement stmtUpsert = new InsertStatement(feedConn.getDataverseName(), feedConn.getDatasetName(),
-                    feedConnQuery, -1, null, null);
-            clfrqs = new CompiledStatements.CompiledInsertStatement(feedConn.getDataverseName(),
+            InsertStatement stmtUpsert = new InsertStatement(new Namespace(feedDatabaseName, feedDataverseName),
+                    feedConn.getDatasetName(), feedConnQuery, -1, null, null);
+            clfrqs = new CompiledStatements.CompiledInsertStatement(feedDatabaseName, feedDataverseName,
                     feedConn.getDatasetName(), feedConnQuery, stmtUpsert.getVarCounter(), null, null);
         } else {
-            UpsertStatement stmtUpsert = new UpsertStatement(feedConn.getDataverseName(), feedConn.getDatasetName(),
-                    feedConnQuery, -1, null, null);
-            clfrqs = new CompiledStatements.CompiledUpsertStatement(feedConn.getDataverseName(),
+            UpsertStatement stmtUpsert = new UpsertStatement(new Namespace(feedDatabaseName, feedDataverseName),
+                    feedConn.getDatasetName(), feedConnQuery, -1, null, null);
+            clfrqs = new CompiledStatements.CompiledUpsertStatement(feedDatabaseName, feedDataverseName,
                     feedConn.getDatasetName(), feedConnQuery, stmtUpsert.getVarCounter(), null, null);
         }
         return statementExecutor.rewriteCompileQuery(hcc, metadataProvider, feedConnQuery, clfrqs, null, null);
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/api/http/servlet/ConnectorApiServletTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/api/http/servlet/ConnectorApiServletTest.java
index 9d4f921..d8fb053 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/api/http/servlet/ConnectorApiServletTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/api/http/servlet/ConnectorApiServletTest.java
@@ -182,8 +182,8 @@
             throws Exception {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         // Retrieves file splits of the dataset.
-        MetadataProvider metadataProvider = MetadataProvider
-                .create((ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(), null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(
+                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext());
         try {
             metadataProvider.setMetadataTxnContext(mdTxnCtx);
             Dataset dataset = metadataProvider.findDataset(database, dataverseName, datasetName);
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/app/bootstrap/TestNodeController.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/app/bootstrap/TestNodeController.java
index f929677..fc992e3 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/app/bootstrap/TestNodeController.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/app/bootstrap/TestNodeController.java
@@ -37,6 +37,7 @@
 import org.apache.asterix.common.dataflow.LSMInsertDeleteOperatorNodePushable;
 import org.apache.asterix.common.exceptions.ACIDException;
 import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.common.metadata.NamespacePathResolver;
 import org.apache.asterix.common.transactions.ITransactionManager;
 import org.apache.asterix.common.transactions.TxnId;
@@ -47,7 +48,6 @@
 import org.apache.asterix.formats.nontagged.TypeTraitProvider;
 import org.apache.asterix.metadata.MetadataManager;
 import org.apache.asterix.metadata.MetadataTransactionContext;
-import org.apache.asterix.metadata.bootstrap.MetadataBuiltinEntities;
 import org.apache.asterix.metadata.declared.MetadataProvider;
 import org.apache.asterix.metadata.entities.Dataset;
 import org.apache.asterix.metadata.entities.Dataverse;
@@ -238,7 +238,7 @@
             throws AlgebricksException, HyracksDataException, RemoteException, ACIDException {
         CcApplicationContext appCtx =
                 (CcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext();
-        MetadataProvider mdProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider mdProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         try {
             MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
             org.apache.hyracks.algebricks.common.utils.Pair<ILSMMergePolicyFactory, Map<String, String>> mergePolicy =
@@ -357,7 +357,7 @@
             throws AlgebricksException, HyracksDataException, RemoteException, ACIDException {
         CcApplicationContext appCtx =
                 (CcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext();
-        MetadataProvider mdProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider mdProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         try {
             MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
             org.apache.hyracks.algebricks.common.utils.Pair<ILSMMergePolicyFactory, Map<String, String>> mergePolicy =
@@ -488,22 +488,6 @@
         return new JobId(jobCounter++);
     }
 
-    public IResourceFactory getPrimaryResourceFactory(IHyracksTaskContext ctx, PrimaryIndexInfo primaryIndexInfo,
-            IStorageComponentProvider storageComponentProvider, Dataset dataset) throws AlgebricksException {
-        Dataverse dataverse = new Dataverse(dataset.getDatabaseName(), dataset.getDataverseName(),
-                NonTaggedDataFormat.class.getName(), MetadataUtil.PENDING_NO_OP);
-        Index index = primaryIndexInfo.getIndex();
-        CcApplicationContext appCtx =
-                (CcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext();
-        MetadataProvider mdProvider = MetadataProvider.create(appCtx, dataverse);
-        try {
-            return dataset.getResourceFactory(mdProvider, index, primaryIndexInfo.recordType, primaryIndexInfo.metaType,
-                    primaryIndexInfo.mergePolicyFactory, primaryIndexInfo.mergePolicyProperties);
-        } finally {
-            mdProvider.getLocks().unlock();
-        }
-    }
-
     public PrimaryIndexInfo createPrimaryIndex(Dataset dataset, IAType[] primaryKeyTypes, ARecordType recordType,
             ARecordType metaType, int[] filterFields, IStorageComponentProvider storageComponentProvider,
             int[] primaryKeyIndexes, List<Integer> primaryKeyIndicators, int partition)
@@ -516,8 +500,9 @@
                 mergePolicy.first, mergePolicy.second, filterFields, primaryKeyIndexes, primaryKeyIndicators);
         Dataverse dataverse = new Dataverse(dataset.getDatabaseName(), dataset.getDataverseName(),
                 NonTaggedDataFormat.class.getName(), MetadataUtil.PENDING_NO_OP);
+        Namespace namespace = new Namespace(dataverse.getDatabaseName(), dataverse.getDataverseName());
         MetadataProvider mdProvider = MetadataProvider.create(
-                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(), dataverse);
+                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(), namespace);
         try {
             IResourceFactory resourceFactory = dataset.getResourceFactory(mdProvider, primaryIndexInfo.index,
                     recordType, metaType, mergePolicy.first, mergePolicy.second);
@@ -543,8 +528,9 @@
         Dataverse dataverse =
                 new Dataverse(primaryIndexInfo.dataset.getDatabaseName(), primaryIndexInfo.dataset.getDataverseName(),
                         NonTaggedDataFormat.class.getName(), MetadataUtil.PENDING_NO_OP);
+        Namespace namespace = new Namespace(dataverse.getDatabaseName(), dataverse.getDataverseName());
         MetadataProvider mdProvider = MetadataProvider.create(
-                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(), dataverse);
+                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(), namespace);
         SecondaryIndexInfo secondaryIndexInfo = new SecondaryIndexInfo(primaryIndexInfo, secondaryIndex);
         try {
             IResourceFactory resourceFactory = primaryIndexInfo.dataset.getResourceFactory(mdProvider, secondaryIndex,
@@ -830,9 +816,8 @@
             int[] keyIndexes, List<Integer> keyIndicators, StorageComponentProvider storageComponentProvider,
             IFrameOperationCallbackFactory frameOpCallbackFactory, boolean hasSecondaries) throws Exception {
         MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
-        MetadataProvider mdProvider = MetadataProvider.create(
-                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext(),
-                MetadataBuiltinEntities.DEFAULT_DATAVERSE);
+        MetadataProvider mdProvider = MetadataProvider.createWithDefaultNamespace(
+                (ICcApplicationContext) ExecutionTestUtil.integrationUtil.cc.getApplicationContext());
         org.apache.hyracks.algebricks.common.utils.Pair<ILSMMergePolicyFactory, Map<String, String>> mergePolicy =
                 DatasetUtil.getMergePolicyFactory(dataset, mdTxnCtx);
         MetadataManager.INSTANCE.commitTransaction(mdTxnCtx);
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/common/TestDataUtil.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/common/TestDataUtil.java
index b58ad47..b213e9d 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/common/TestDataUtil.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/common/TestDataUtil.java
@@ -191,7 +191,7 @@
             DataverseName dataverseName, String datasetName, String[] targetNodes) throws Exception {
         ICcApplicationContext ccAppCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        MetadataProvider metadataProvider = MetadataProvider.create(ccAppCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(ccAppCtx);
         try {
             ActiveNotificationHandler activeNotificationHandler =
                     (ActiveNotificationHandler) ccAppCtx.getActiveNotificationHandler();
@@ -224,7 +224,7 @@
             throws AlgebricksException, RemoteException {
         final ICcApplicationContext appCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        final MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        final MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         Dataset dataset;
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveEventsListenerTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveEventsListenerTest.java
index 13dc4f9..841e81b 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveEventsListenerTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveEventsListenerTest.java
@@ -144,7 +144,7 @@
         Mockito.when(ccExtensionManager.getFunctionManager())
                 .thenReturn(new FunctionManager(FunctionCollection.createDefaultFunctionCollection()));
         Mockito.when(appCtx.getExtensionManager()).thenReturn(ccExtensionManager);
-        metadataProvider = MetadataProvider.create(appCtx, null);
+        metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         clusterController = new TestClusterControllerActor("CC", handler, allDatasets);
         nodeControllers = new TestNodeControllerActor[2];
         nodeControllers[0] = new TestNodeControllerActor(nodes[0], clusterController);
@@ -159,7 +159,7 @@
     }
 
     TestUserActor newUser(String name, CcApplicationContext appCtx) {
-        MetadataProvider actorMdProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider actorMdProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         return new TestUserActor("User: " + name, actorMdProvider, clusterController);
     }
 
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveStatsTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveStatsTest.java
index 3baf5d0..59e0878 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveStatsTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/active/ActiveStatsTest.java
@@ -107,7 +107,7 @@
                 .create(appCtx, Collections.emptyList(), sessionOutput,
                         extensionManager.getCompilationProvider(Language.SQLPP), appCtx.getStorageComponentProvider(),
                         new ResponsePrinter(sessionOutput));
-        MetadataProvider mdProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider mdProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         // Add event listener
         ActiveEntityEventsListener eventsListener = new DummyFeedEventsListener(statementExecutor, appCtx, null,
                 entityId, datasetList, partitionConstraint, FeedIntakeOperatorNodePushable.class.getSimpleName(),
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/ddl/SecondaryBTreeOperationsHelperTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/ddl/SecondaryBTreeOperationsHelperTest.java
index c8cccfa..135f7ab 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/ddl/SecondaryBTreeOperationsHelperTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/ddl/SecondaryBTreeOperationsHelperTest.java
@@ -63,7 +63,7 @@
     public void createPrimaryIndex() throws Exception {
         ICcApplicationContext appCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        final MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        final MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         MetadataTransactionContext mdTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxn);
         try {
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/metadata/MetadataTxnTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/metadata/MetadataTxnTest.java
index 7583307..9e0683b 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/metadata/MetadataTxnTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/metadata/MetadataTxnTest.java
@@ -77,7 +77,7 @@
     public void abortMetadataTxn() throws Exception {
         ICcApplicationContext appCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        final MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        final MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext mdTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxn);
         final String nodeGroupName = "ng";
@@ -116,7 +116,7 @@
                 + "(KeyType) PRIMARY KEY id WITH {\"node-group\":{\"name\":\"" + nodeGroup + "\"}};", format);
         // find source dataset
         Dataset sourceDataset;
-        MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         try {
@@ -128,7 +128,7 @@
         }
 
         // create rebalance metadata provider and metadata txn
-        metadataProvider = MetadataProvider.create(appCtx, null);
+        metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext rebalanceTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(rebalanceTxn);
         try {
@@ -166,7 +166,7 @@
         // get created dataset
         ICcApplicationContext appCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxnCtx);
         Dataset sourceDataset;
@@ -226,7 +226,7 @@
     public void surviveInterruptOnMetadataTxnCommit() throws Exception {
         ICcApplicationContext appCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        final MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        final MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext mdTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxn);
         final String nodeGroupName = "ng";
@@ -258,7 +258,7 @@
     public void failedFlushOnUncommittedMetadataTxn() throws Exception {
         ICcApplicationContext ccAppCtx =
                 (ICcApplicationContext) integrationUtil.getClusterControllerService().getApplicationContext();
-        final MetadataProvider metadataProvider = MetadataProvider.create(ccAppCtx, null);
+        final MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(ccAppCtx);
         final MetadataTransactionContext mdTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(mdTxn);
         final String nodeGroupName = "ng";
@@ -325,7 +325,7 @@
                 source.getDatabaseName(), source.getDataverseName(), source.getDatasetType().name(),
                 source.getNodeGroupName(), NoMergePolicyFactory.NAME, null, source.getDatasetDetails(),
                 source.getHints(), DatasetConfig.DatasetType.INTERNAL, datasetPostfix, 0);
-        MetadataProvider metadataProvider = MetadataProvider.create(appCtx, null);
+        MetadataProvider metadataProvider = MetadataProvider.createWithDefaultNamespace(appCtx);
         final MetadataTransactionContext writeTxn = MetadataManager.INSTANCE.beginTransaction();
         metadataProvider.setMetadataTxnContext(writeTxn);
         try {
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/sqlpp/ParserTestExecutor.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/sqlpp/ParserTestExecutor.java
index 3b0e977..ba2381b 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/sqlpp/ParserTestExecutor.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/sqlpp/ParserTestExecutor.java
@@ -42,7 +42,7 @@
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.MetadataConstants;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.common.metadata.NamespaceResolver;
 import org.apache.asterix.lang.common.base.IParser;
 import org.apache.asterix.lang.common.base.IParserFactory;
@@ -144,8 +144,9 @@
         try {
             List<Statement> statements = parser.parse();
             //TODO(DB): fix this properly so that metadataProvider.getDefaultDataverse() works when actually called
-            DataverseName dvName = getDefaultDataverse(statements);
-            String dbName = MetadataUtil.databaseFor(dvName);
+            Namespace namespace = getDefaultDataverse(statements);
+            DataverseName dvName = namespace.getDataverseName();
+            String dbName = namespace.getDatabaseName();
             List<FunctionDecl> functions = getDeclaredFunctions(statements, dbName, dvName);
             List<FunctionSignature> createdFunctionsList = getCreatedFunctions(statements, dbName, dvName);
             createdFunctions.addAll(createdFunctionsList);
@@ -154,8 +155,7 @@
 
             @SuppressWarnings("unchecked")
             Map<String, Object> config = mock(Map.class);
-            when(metadataProvider.getDefaultDataverseName()).thenReturn(dvName);
-            when(metadataProvider.getDefaultDatabase()).thenReturn(dbName);
+            when(metadataProvider.getDefaultNamespace()).thenReturn(namespace);
             when(metadataProvider.getConfig()).thenReturn(config);
             when(config.get(FunctionUtil.IMPORT_PRIVATE_FUNCTIONS)).thenReturn("true");
             when(metadataProvider.findDataverse(anyString(), Mockito.<DataverseName> any()))
@@ -271,14 +271,14 @@
     }
 
     // Gets the default dataverse for the input statements.
-    private DataverseName getDefaultDataverse(List<Statement> statements) {
+    private Namespace getDefaultDataverse(List<Statement> statements) {
         for (Statement st : statements) {
             if (st.getKind() == Statement.Kind.DATAVERSE_DECL) {
                 DataverseDecl dv = (DataverseDecl) st;
-                return dv.getDataverseName();
+                return dv.getNamespace();
             }
         }
-        return MetadataConstants.DEFAULT_DATAVERSE_NAME;
+        return MetadataConstants.DEFAULT_NAMESPACE;
     }
 
     // Rewrite queries.
diff --git a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/storage/IndexDropOperatorNodePushableTest.java b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/storage/IndexDropOperatorNodePushableTest.java
index bdbdfab..8d9a5f5 100644
--- a/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/storage/IndexDropOperatorNodePushableTest.java
+++ b/asterixdb/asterix-app/src/test/java/org/apache/asterix/test/storage/IndexDropOperatorNodePushableTest.java
@@ -153,7 +153,7 @@
             final MetadataTransactionContext mdTxn = MetadataManager.INSTANCE.beginTransaction();
             ICcApplicationContext appCtx = (ICcApplicationContext) ExecutionTestUtil.integrationUtil
                     .getClusterControllerService().getApplicationContext();
-            MetadataProvider metadataProver = MetadataProvider.create(appCtx, null);
+            MetadataProvider metadataProver = MetadataProvider.createWithDefaultNamespace(appCtx);
             metadataProver.setMetadataTxnContext(mdTxn);
             final DataverseName defaultDv = MetadataBuiltinEntities.DEFAULT_DATAVERSE.getDataverseName();
             final Dataset dataset = MetadataManager.INSTANCE.getDataset(mdTxn, MetadataConstants.DEFAULT_DATABASE,
diff --git a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/api/INamespaceResolver.java b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/api/INamespaceResolver.java
index a552dfb..7f9bde6 100644
--- a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/api/INamespaceResolver.java
+++ b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/api/INamespaceResolver.java
@@ -27,6 +27,8 @@
 
     Namespace resolve(List<String> multiIdentifier) throws AsterixException;
 
+    Namespace resolve(List<String> multiIdentifier, int fromIndex, int toIndex) throws AsterixException;
+
     Namespace resolve(String namespace) throws AsterixException;
 
 }
diff --git a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/MetadataConstants.java b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/MetadataConstants.java
index 3ac7d9d..02cf6d6 100644
--- a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/MetadataConstants.java
+++ b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/MetadataConstants.java
@@ -43,6 +43,8 @@
     // Name of the pre-defined default dataverse
     public static final DataverseName DEFAULT_DATAVERSE_NAME = DataverseName.createBuiltinDataverseName("Default");
 
+    public static final Namespace DEFAULT_NAMESPACE = new Namespace(DEFAULT_DATABASE, DEFAULT_DATAVERSE_NAME);
+
     // Name of the node group where metadata is stored on.
     public static final String METADATA_NODEGROUP_NAME = "MetadataGroup";
 
diff --git a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/Namespace.java b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/Namespace.java
index 26b549a..5b75c79 100644
--- a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/Namespace.java
+++ b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/Namespace.java
@@ -19,9 +19,12 @@
 
 package org.apache.asterix.common.metadata;
 
+import java.io.Serializable;
 import java.util.Objects;
 
-public final class Namespace {
+public final class Namespace implements Serializable {
+
+    private static final long serialVersionUID = 1L;
 
     private final String databaseName;
     private final DataverseName dataverseName;
diff --git a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/NamespaceResolver.java b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/NamespaceResolver.java
index 011432b..b18562e 100644
--- a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/NamespaceResolver.java
+++ b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/metadata/NamespaceResolver.java
@@ -34,10 +34,15 @@
 
     @Override
     public Namespace resolve(List<String> multiIdentifier) throws AsterixException {
+        return resolve(multiIdentifier, 0, multiIdentifier.size());
+    }
+
+    @Override
+    public Namespace resolve(List<String> multiIdentifier, int fromIndex, int toIndex) throws AsterixException {
         if (multiIdentifier == null) {
             return null;
         }
-        DataverseName dataverseName = DataverseName.create(multiIdentifier);
+        DataverseName dataverseName = DataverseName.create(multiIdentifier, fromIndex, toIndex);
         return new Namespace(MetadataUtil.databaseFor(dataverseName), dataverseName);
     }
 
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/OrderedListTypeDefinition.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/OrderedListTypeDefinition.java
index d4c03b2..1bbc2a7 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/OrderedListTypeDefinition.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/OrderedListTypeDefinition.java
@@ -25,7 +25,7 @@
 
 public class OrderedListTypeDefinition extends AbstractTypeExpression {
 
-    private TypeExpression itemTypeExpression;
+    private final TypeExpression itemTypeExpression;
 
     public OrderedListTypeDefinition(TypeExpression itemTypeExpression) {
         this.itemTypeExpression = itemTypeExpression;
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/TypeReferenceExpression.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/TypeReferenceExpression.java
index ea0b1b1..9c98ecd 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/TypeReferenceExpression.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/TypeReferenceExpression.java
@@ -21,20 +21,20 @@
 import java.util.Objects;
 
 import org.apache.asterix.common.exceptions.CompilationException;
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.struct.Identifier;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 import org.apache.hyracks.algebricks.common.utils.Pair;
 
 public class TypeReferenceExpression extends AbstractTypeExpression {
 
-    private final Pair<DataverseName, Identifier> ident;
+    private final Pair<Namespace, Identifier> ident;
 
-    public TypeReferenceExpression(Pair<DataverseName, Identifier> ident) {
+    public TypeReferenceExpression(Pair<Namespace, Identifier> ident) {
         this.ident = ident;
     }
 
-    public Pair<DataverseName, Identifier> getIdent() {
+    public Pair<Namespace, Identifier> getIdent() {
         return ident;
     }
 
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/UnorderedListTypeDefinition.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/UnorderedListTypeDefinition.java
index b55c910..b23a780 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/UnorderedListTypeDefinition.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/expression/UnorderedListTypeDefinition.java
@@ -25,7 +25,7 @@
 
 public class UnorderedListTypeDefinition extends AbstractTypeExpression {
 
-    private TypeExpression itemTypeExpression;
+    private final TypeExpression itemTypeExpression;
 
     public UnorderedListTypeDefinition(TypeExpression itemTypeExpression) {
         this.itemTypeExpression = itemTypeExpression;
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AdapterDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AdapterDropStatement.java
index 481dbe4..8b2a8e1 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AdapterDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AdapterDropStatement.java
@@ -20,19 +20,20 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class AdapterDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final String adapterName;
 
     private final boolean ifExists;
 
-    public AdapterDropStatement(DataverseName dataverseName, String adapterName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public AdapterDropStatement(Namespace namespace, String adapterName, boolean ifExists) {
+        this.namespace = namespace;
         this.adapterName = adapterName;
         this.ifExists = ifExists;
     }
@@ -42,8 +43,12 @@
         return Kind.ADAPTER_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getAdapterName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeDropStatement.java
index 67cfeec..ceefea3 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeDropStatement.java
@@ -20,16 +20,17 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class AnalyzeDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String datasetName;
 
-    public AnalyzeDropStatement(DataverseName dataverseName, String datasetName) {
-        this.dataverseName = dataverseName;
+    public AnalyzeDropStatement(Namespace namespace, String datasetName) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
     }
 
@@ -38,8 +39,12 @@
         return Kind.ANALYZE_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeStatement.java
index a719c34..5afb85f 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/AnalyzeStatement.java
@@ -25,6 +25,7 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.expression.FieldBinding;
@@ -53,13 +54,13 @@
 
     private static final String SAMPLE_SEED_FIELD_NAME = "sample-seed";
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String datasetName;
     private final AdmObjectNode options;
 
-    public AnalyzeStatement(DataverseName dataverseName, String datasetName, RecordConstructor options)
+    public AnalyzeStatement(Namespace namespace, String datasetName, RecordConstructor options)
             throws CompilationException {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.options = options == null ? null : validateOptions(options);
     }
@@ -94,8 +95,12 @@
         return Kind.ANALYZE;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CompactStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CompactStatement.java
index 4c79029..581ce9d 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CompactStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CompactStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,11 +28,11 @@
 
 public class CompactStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier datasetName;
 
-    public CompactStatement(DataverseName dataverseName, Identifier datasetName) {
-        this.dataverseName = dataverseName;
+    public CompactStatement(Namespace namespace, Identifier datasetName) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
     }
 
@@ -40,8 +41,12 @@
         return Statement.Kind.COMPACT;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ConnectFeedStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ConnectFeedStatement.java
index 90892d2..357b437 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ConnectFeedStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ConnectFeedStatement.java
@@ -23,6 +23,7 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -32,22 +33,21 @@
 
 public class ConnectFeedStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier datasetName;
     private final String feedName;
     private final String policy;
     private final String whereClauseBody;
-    private int varCounter;
+    private final int varCounter;
     private final List<FunctionSignature> appliedFunctions;
 
-    public ConnectFeedStatement(Pair<DataverseName, Identifier> feedNameCmp,
-            Pair<DataverseName, Identifier> datasetNameCmp, List<FunctionSignature> appliedFunctions, String policy,
-            String whereClauseBody, int varCounter) {
+    public ConnectFeedStatement(Pair<Namespace, Identifier> feedNameCmp, Pair<Namespace, Identifier> datasetNameCmp,
+            List<FunctionSignature> appliedFunctions, String policy, String whereClauseBody, int varCounter) {
         if (feedNameCmp.first != null && datasetNameCmp.first != null
                 && !feedNameCmp.first.equals(datasetNameCmp.first)) {
             throw new IllegalArgumentException("Dataverse for source feed and target dataset do not match");
         }
-        this.dataverseName = feedNameCmp.first != null ? feedNameCmp.first : datasetNameCmp.first;
+        this.namespace = feedNameCmp.first != null ? feedNameCmp.first : datasetNameCmp.first;
         this.datasetName = datasetNameCmp.second;
         this.feedName = feedNameCmp.second.getValue();
         this.policy = policy != null ? policy : BuiltinFeedPolicies.DEFAULT_POLICY.getPolicyName();
@@ -56,8 +56,12 @@
         this.appliedFunctions = appliedFunctions;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CopyStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CopyStatement.java
index 2a1a51a..a07371d 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CopyStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CopyStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.expression.RecordConstructor;
 import org.apache.asterix.lang.common.expression.TypeExpression;
@@ -29,27 +30,27 @@
 
 public class CopyStatement extends AbstractStatement {
 
-    private DataverseName dataverseName;
-    private String datasetName;
-    private TypeExpression typeExpr;
-    private ExternalDetailsDecl externalDetails;
-    private AdmObjectNode withObjectNode;
+    private final Namespace namespace;
+    private final String datasetName;
+    private final TypeExpression typeExpr;
+    private final ExternalDetailsDecl externalDetails;
+    private final AdmObjectNode withObjectNode;
 
-    public CopyStatement(DataverseName dataverseName, String datasetName, TypeExpression typeExpr,
+    public CopyStatement(Namespace namespace, String datasetName, TypeExpression typeExpr,
             ExternalDetailsDecl externalDetails, RecordConstructor withRecord) throws CompilationException {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.typeExpr = typeExpr;
         this.externalDetails = externalDetails;
         this.withObjectNode = withRecord == null ? new AdmObjectNode() : ExpressionUtils.toNode(withRecord);
     }
 
-    public DataverseName getDataverseName() {
-        return dataverseName;
+    public Namespace getNamespace() {
+        return namespace;
     }
 
-    public void setDataverseName(DataverseName dataverseName) {
-        this.dataverseName = dataverseName;
+    public DataverseName getDataverseName() {
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     @Override
@@ -61,10 +62,6 @@
         return datasetName;
     }
 
-    public void setDatasetName(String datasetName) {
-        this.datasetName = datasetName;
-    }
-
     @Override
     public <R, T> R accept(ILangVisitor<R, T> visitor, T arg) throws CompilationException {
         return visitor.visit(this, arg);
@@ -74,18 +71,10 @@
         return externalDetails;
     }
 
-    public void setExternalDetails(ExternalDetailsDecl externalDetails) {
-        this.externalDetails = externalDetails;
-    }
-
     public AdmObjectNode getWithObjectNode() {
         return withObjectNode;
     }
 
-    public void setWithObjectNode(AdmObjectNode withObjectNode) {
-        this.withObjectNode = withObjectNode;
-    }
-
     @Override
     public byte getCategory() {
         return Category.UPDATE;
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateAdapterStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateAdapterStatement.java
index 6e5886c..4442f7a 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateAdapterStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateAdapterStatement.java
@@ -22,16 +22,17 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class CreateAdapterStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final String adapterName;
 
-    private final DataverseName libraryDataverseName;
+    private final Namespace libraryNamespace;
 
     private final String libraryName;
 
@@ -39,11 +40,11 @@
 
     private final boolean ifNotExists;
 
-    public CreateAdapterStatement(DataverseName dataverseName, String adapterName, DataverseName libraryDataverseName,
+    public CreateAdapterStatement(Namespace namespace, String adapterName, Namespace libraryNamespace,
             String libraryName, List<String> externalIdentifier, boolean ifNotExists) {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.adapterName = adapterName;
-        this.libraryDataverseName = libraryDataverseName;
+        this.libraryNamespace = libraryNamespace;
         this.libraryName = libraryName;
         this.externalIdentifier = externalIdentifier;
         this.ifNotExists = ifNotExists;
@@ -54,16 +55,24 @@
         return Kind.CREATE_ADAPTER;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getAdapterName() {
         return adapterName;
     }
 
+    public String getLibraryDatabaseName() {
+        return libraryNamespace == null ? null : libraryNamespace.getDatabaseName();
+    }
+
     public DataverseName getLibraryDataverseName() {
-        return libraryDataverseName;
+        return libraryNamespace == null ? null : libraryNamespace.getDataverseName();
     }
 
     public String getLibraryName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateDataverseStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateDataverseStatement.java
index 2276755..9b437c2 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateDataverseStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateDataverseStatement.java
@@ -18,8 +18,11 @@
  */
 package org.apache.asterix.lang.common.statement;
 
+import java.util.Objects;
+
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
@@ -27,18 +30,22 @@
 
 public class CreateDataverseStatement extends AbstractStatement {
 
-    private DataverseName dataverseName;
-    private String format;
-    private boolean ifNotExists;
+    private final Namespace namespace;
+    private final String format;
+    private final boolean ifNotExists;
 
-    public CreateDataverseStatement(DataverseName dataverseName, String format, boolean ifNotExists) {
-        this.dataverseName = dataverseName;
+    public CreateDataverseStatement(Namespace namespace, String format, boolean ifNotExists) {
+        this.namespace = Objects.requireNonNull(namespace);
         this.format = (format == null) ? NonTaggedDataFormat.class.getName() : format;
         this.ifNotExists = ifNotExists;
     }
 
+    public String getDatabaseName() {
+        return namespace.getDatabaseName();
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace.getDataverseName();
     }
 
     public String getFormat() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFeedStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFeedStatement.java
index f12dfce..3f68536 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFeedStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFeedStatement.java
@@ -22,6 +22,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.expression.RecordConstructor;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -38,21 +39,25 @@
  */
 public class CreateFeedStatement extends AbstractStatement {
 
-    private final Pair<DataverseName, Identifier> qName;
+    private final Pair<Namespace, Identifier> qName;
     private final boolean ifNotExists;
     private final AdmObjectNode withObjectNode;
 
-    public CreateFeedStatement(Pair<DataverseName, Identifier> qName, RecordConstructor withRecord, boolean ifNotExists)
+    public CreateFeedStatement(Pair<Namespace, Identifier> qName, RecordConstructor withRecord, boolean ifNotExists)
             throws AlgebricksException {
         this.qName = qName;
         this.ifNotExists = ifNotExists;
         this.withObjectNode = withRecord == null ? null : ExpressionUtils.toNode(withRecord);
     }
 
-    public DataverseName getDataverseName() {
+    public Namespace getNamespace() {
         return qName.first;
     }
 
+    public DataverseName getDataverseName() {
+        return qName.first == null ? null : qName.first.getDataverseName();
+    }
+
     public Identifier getFeedName() {
         return qName.second;
     }
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextConfigStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextConfigStatement.java
index 2d304be..5aa680a 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextConfigStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextConfigStatement.java
@@ -18,10 +18,9 @@
  */
 package org.apache.asterix.lang.common.statement;
 
-import java.util.Iterator;
-
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.expression.RecordConstructor;
 import org.apache.asterix.lang.common.util.FullTextUtil;
@@ -37,7 +36,7 @@
 
 public class CreateFullTextConfigStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String configName;
     private final boolean ifNotExists;
     private final AdmObjectNode configNode;
@@ -45,16 +44,20 @@
     public static final String FIELD_NAME_TOKENIZER = "tokenizer";
     public static final String FIELD_NAME_FILTER_PIPELINE = "filterPipeline";
 
-    public CreateFullTextConfigStatement(DataverseName dataverseName, String configName, boolean ifNotExists,
+    public CreateFullTextConfigStatement(Namespace namespace, String configName, boolean ifNotExists,
             RecordConstructor expr) throws CompilationException {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.configName = configName;
         this.ifNotExists = ifNotExists;
         this.configNode = FullTextUtil.validateAndGetConfigNode(expr);
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getConfigName() {
@@ -82,18 +85,15 @@
 
     public TokenizerCategory getTokenizerCategory() throws HyracksDataException {
         String tokenizerCategoryStr = configNode.getString(FIELD_NAME_TOKENIZER);
-        TokenizerCategory tokenizerCategory = TokenizerCategory.getEnumIgnoreCase(tokenizerCategoryStr);
-
-        return tokenizerCategory;
+        return TokenizerCategory.getEnumIgnoreCase(tokenizerCategoryStr);
     }
 
     public ImmutableList<String> getFilterNames() {
         AdmArrayNode arrayNode = (AdmArrayNode) configNode.get(FIELD_NAME_FILTER_PIPELINE);
         ImmutableList.Builder<String> filterNamesBuilder = ImmutableList.builder();
 
-        Iterator<IAdmNode> iterator = arrayNode.iterator();
-        while (iterator.hasNext()) {
-            filterNamesBuilder.add(((AdmStringNode) iterator.next()).get());
+        for (IAdmNode iAdmNode : arrayNode) {
+            filterNamesBuilder.add(((AdmStringNode) iAdmNode).get());
         }
 
         return filterNamesBuilder.build();
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextFilterStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextFilterStatement.java
index 20427fd..2075178 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextFilterStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFullTextFilterStatement.java
@@ -18,11 +18,10 @@
  */
 package org.apache.asterix.lang.common.statement;
 
-import java.util.Iterator;
-
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.expression.RecordConstructor;
 import org.apache.asterix.lang.common.util.FullTextUtil;
@@ -37,7 +36,7 @@
 
 public class CreateFullTextFilterStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String filterName;
     private final boolean ifNotExists;
     private final AdmObjectNode filterNode;
@@ -46,16 +45,20 @@
     public static final String FIELD_NAME_STOPWORDS_LIST = "stopwordsList";
     public static final String FIELD_TYPE_STOPWORDS = "stopwords";
 
-    public CreateFullTextFilterStatement(DataverseName dataverseName, String filterName, boolean ifNotExists,
+    public CreateFullTextFilterStatement(Namespace namespace, String filterName, boolean ifNotExists,
             RecordConstructor expr) throws CompilationException {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.filterName = filterName;
         this.ifNotExists = ifNotExists;
         this.filterNode = FullTextUtil.getFilterNode(expr);
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getFilterName() {
@@ -71,21 +74,19 @@
     }
 
     public ImmutableList<String> getStopwordsList() throws CompilationException {
-        ImmutableList.Builder listBuiler = ImmutableList.<String> builder();
+        ImmutableList.Builder<String> listBuilder = ImmutableList.builder();
         AdmArrayNode arrayNode = (AdmArrayNode) filterNode.get(FIELD_NAME_STOPWORDS_LIST);
 
-        Iterator<IAdmNode> iterator = arrayNode.iterator();
-        while (iterator.hasNext()) {
-            IAdmNode node = iterator.next();
+        for (IAdmNode node : arrayNode) {
             if (!(node instanceof AdmStringNode)) {
                 throw new CompilationException(ErrorCode.PARSE_ERROR, getSourceLocation(),
                         "error when parsing stopwords list");
             }
 
-            listBuiler.add(((AdmStringNode) node).get());
+            listBuilder.add(((AdmStringNode) node).get());
         }
 
-        return listBuiler.build();
+        return listBuilder.build();
     }
 
     @Override
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFunctionStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFunctionStatement.java
index baaa2c1..e0623a1 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFunctionStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateFunctionStatement.java
@@ -25,6 +25,7 @@
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Statement;
@@ -55,7 +56,7 @@
     private final List<Pair<VarIdentifier, TypeExpression>> paramList;
     private final TypeExpression returnType;
 
-    private final DataverseName libraryDataverseName;
+    private final Namespace libraryNamespace;
     private final String libraryName;
     private final List<String> externalIdentifier;
     private final AdmObjectNode options;
@@ -70,7 +71,7 @@
         this.functionBodyExpression = functionBodyExpression;
         this.paramList = requireNullTypes(paramList); // parameter type specification is not allowed for inline functions
         this.returnType = null; // return type specification is not allowed for inline functions
-        this.libraryDataverseName = null;
+        this.libraryNamespace = null;
         this.libraryName = null;
         this.externalIdentifier = null;
         this.options = null;
@@ -79,13 +80,12 @@
     }
 
     public CreateFunctionStatement(FunctionSignature signature, List<Pair<VarIdentifier, TypeExpression>> paramList,
-            TypeExpression returnType, DataverseName libraryDataverseName, String libraryName,
-            List<String> externalIdentifier, RecordConstructor options, boolean replaceIfExists, boolean ifNotExists)
-            throws CompilationException {
+            TypeExpression returnType, Namespace libraryNamespace, String libraryName, List<String> externalIdentifier,
+            RecordConstructor options, boolean replaceIfExists, boolean ifNotExists) throws CompilationException {
         this.signature = signature;
         this.paramList = paramList;
         this.returnType = returnType;
-        this.libraryDataverseName = libraryDataverseName;
+        this.libraryNamespace = libraryNamespace;
         this.libraryName = libraryName;
         this.externalIdentifier = externalIdentifier;
         this.options = options == null ? null : ExpressionUtils.toNode(options);
@@ -136,8 +136,12 @@
         return externalIdentifier;
     }
 
+    public String getLibraryDatabaseName() {
+        return libraryNamespace == null ? null : libraryNamespace.getDatabaseName();
+    }
+
     public DataverseName getLibraryDataverseName() {
-        return libraryDataverseName;
+        return libraryNamespace == null ? null : libraryNamespace.getDataverseName();
     }
 
     public String getLibraryName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateIndexStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateIndexStatement.java
index aabd76d..1d9e5ab 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateIndexStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateIndexStatement.java
@@ -27,6 +27,7 @@
 import org.apache.asterix.common.config.DatasetConfig.IndexType;
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.expression.IndexedTypeExpression;
@@ -39,7 +40,7 @@
 
 public class CreateIndexStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier datasetName;
     private final Identifier indexName;
     private final IndexType indexType;
@@ -54,11 +55,10 @@
     private final OptionalBoolean castDefaultNull;
     private final Map<String, String> castConfig;
 
-    public CreateIndexStatement(DataverseName dataverseName, Identifier datasetName, Identifier indexName,
-            IndexType indexType, List<IndexedElement> indexedElements, boolean enforced, int gramLength,
-            String fullTextConfigName, boolean ifNotExists, Boolean excludeUnknownKey, Boolean castDefaultNull,
-            Map<String, String> castConfig) {
-        this.dataverseName = dataverseName;
+    public CreateIndexStatement(Namespace namespace, Identifier datasetName, Identifier indexName, IndexType indexType,
+            List<IndexedElement> indexedElements, boolean enforced, int gramLength, String fullTextConfigName,
+            boolean ifNotExists, Boolean excludeUnknownKey, Boolean castDefaultNull, Map<String, String> castConfig) {
+        this.namespace = namespace;
         this.datasetName = Objects.requireNonNull(datasetName);
         this.indexName = Objects.requireNonNull(indexName);
         this.indexType = Objects.requireNonNull(indexType);
@@ -76,8 +76,12 @@
         return fullTextConfigName;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateLibraryStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateLibraryStatement.java
index e8f589d..5941ab2 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateLibraryStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateLibraryStatement.java
@@ -24,12 +24,13 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.functions.ExternalFunctionLanguage;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public final class CreateLibraryStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String libraryName;
     private final ExternalFunctionLanguage lang;
     private final String hash;
@@ -37,9 +38,9 @@
     private final boolean replaceIfExists;
     private final String authToken;
 
-    public CreateLibraryStatement(DataverseName dataverseName, String libraryName, ExternalFunctionLanguage lang,
-            String hash, URI location, boolean replaceIfExists, String authToken) {
-        this.dataverseName = dataverseName;
+    public CreateLibraryStatement(Namespace namespace, String libraryName, ExternalFunctionLanguage lang, String hash,
+            URI location, boolean replaceIfExists, String authToken) {
+        this.namespace = namespace;
         this.libraryName = libraryName;
         this.lang = lang;
         this.location = location;
@@ -48,8 +49,12 @@
         this.hash = hash;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getLibraryName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateSynonymStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateSynonymStatement.java
index afc58f4..a4f071b 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateSynonymStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateSynonymStatement.java
@@ -21,40 +21,49 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class CreateSynonymStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final String synonymName;
 
-    private final DataverseName objectDataverseName;
+    private final Namespace objectNamespace;
 
     private final String objectName;
 
     private final boolean ifNotExists;
 
-    public CreateSynonymStatement(DataverseName dataverseName, String synonymName, DataverseName objectDataverseName,
-            String objectName, boolean ifNotExists) {
-        this.dataverseName = dataverseName;
+    public CreateSynonymStatement(Namespace namespace, String synonymName, Namespace objectNamespace, String objectName,
+            boolean ifNotExists) {
+        this.namespace = namespace;
         this.synonymName = synonymName;
-        this.objectDataverseName = objectDataverseName;
+        this.objectNamespace = objectNamespace;
         this.objectName = objectName;
         this.ifNotExists = ifNotExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getSynonymName() {
         return synonymName;
     }
 
+    public Namespace getObjectNamespace() {
+        return objectNamespace;
+    }
+
     public DataverseName getObjectDataverseName() {
-        return objectDataverseName;
+        return objectNamespace == null ? null : objectNamespace.getDataverseName();
     }
 
     public String getObjectName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateViewStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateViewStatement.java
index 7e4a0ef..9d30bba 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateViewStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/CreateViewStatement.java
@@ -25,6 +25,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Statement;
@@ -34,7 +35,7 @@
 
 public final class CreateViewStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final String viewName;
 
@@ -56,10 +57,10 @@
 
     private final boolean ifNotExists;
 
-    public CreateViewStatement(DataverseName dataverseName, String viewName, TypeExpression itemType, String viewBody,
+    public CreateViewStatement(Namespace namespace, String viewName, TypeExpression itemType, String viewBody,
             Expression viewBodyExpression, Boolean defaultNull, Map<String, String> viewConfig, KeyDecl primaryKeyDecl,
             List<ForeignKeyDecl> foreignKeyDecls, boolean replaceIfExists, boolean ifNotExists) {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.viewName = Objects.requireNonNull(viewName);
         this.itemType = itemType;
         this.viewBody = Objects.requireNonNull(viewBody);
@@ -82,8 +83,12 @@
         return Category.DDL;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getViewName() {
@@ -159,19 +164,23 @@
 
     public static class ForeignKeyDecl extends KeyDecl {
 
-        private final DataverseName referencedDataverseName;
+        private final Namespace referencedNamespace;
 
         private final Identifier referencedDatasetName;
 
-        public ForeignKeyDecl(List<List<String>> fields, List<Integer> sourceIndicators,
-                DataverseName referencedDataverseName, Identifier referencedDatasetName) {
+        public ForeignKeyDecl(List<List<String>> fields, List<Integer> sourceIndicators, Namespace referencedNamespace,
+                Identifier referencedDatasetName) {
             super(fields, sourceIndicators);
-            this.referencedDataverseName = referencedDataverseName;
+            this.referencedNamespace = referencedNamespace;
             this.referencedDatasetName = referencedDatasetName;
         }
 
+        public String getReferencedDatabaseName() {
+            return referencedNamespace == null ? null : referencedNamespace.getDatabaseName();
+        }
+
         public DataverseName getReferencedDataverseName() {
-            return referencedDataverseName;
+            return referencedNamespace == null ? null : referencedNamespace.getDataverseName();
         }
 
         public Identifier getReferencedDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DatasetDecl.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DatasetDecl.java
index 22fd3a7..e4afd6b 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DatasetDecl.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DatasetDecl.java
@@ -24,6 +24,7 @@
 import org.apache.asterix.common.config.DatasetConfig.DatasetType;
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.expression.RecordConstructor;
@@ -38,8 +39,9 @@
 import org.apache.asterix.runtime.compression.CompressionManager;
 
 public class DatasetDecl extends AbstractStatement {
+
     protected final Identifier name;
-    protected final DataverseName dataverse;
+    protected final Namespace namespace;
     protected final TypeExpression itemType;
     protected final TypeExpression metaItemType;
     protected final DatasetType datasetType;
@@ -49,16 +51,16 @@
     protected final boolean ifNotExists;
     protected final Query query;
 
-    public DatasetDecl(DataverseName dataverse, Identifier name, TypeExpression itemType, TypeExpression metaItemType,
+    public DatasetDecl(Namespace namespace, Identifier name, TypeExpression itemType, TypeExpression metaItemType,
             Map<String, String> hints, DatasetType datasetType, IDatasetDetailsDecl idd, RecordConstructor withRecord,
             boolean ifNotExists) throws CompilationException {
-        this(dataverse, name, itemType, metaItemType, hints, datasetType, idd, withRecord, ifNotExists, null);
+        this(namespace, name, itemType, metaItemType, hints, datasetType, idd, withRecord, ifNotExists, null);
     }
 
-    public DatasetDecl(DataverseName dataverse, Identifier name, TypeExpression itemType, TypeExpression metaItemType,
+    public DatasetDecl(Namespace namespace, Identifier name, TypeExpression itemType, TypeExpression metaItemType,
             Map<String, String> hints, DatasetType datasetType, IDatasetDetailsDecl idd, RecordConstructor withRecord,
             boolean ifNotExists, Query query) throws CompilationException {
-        this.dataverse = dataverse;
+        this.namespace = namespace;
         this.name = name;
         this.itemType = itemType;
         this.metaItemType = metaItemType;
@@ -82,8 +84,12 @@
         return name;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverse() {
-        return dataverse;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public TypeExpression getItemType() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDecl.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDecl.java
index dd22950..07395d2 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDecl.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDecl.java
@@ -42,6 +42,10 @@
         this.ifExists = ifExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
         return namespace.getDataverseName();
     }
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDropStatement.java
index fa6bc4e..14ed0da 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DataverseDropStatement.java
@@ -18,24 +18,27 @@
  */
 package org.apache.asterix.lang.common.statement;
 
+import java.util.Objects;
+
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class DataverseDropStatement extends AbstractStatement {
 
-    private DataverseName dataverseName;
-    private boolean ifExists;
-    private boolean ifEmpty;
+    private final Namespace namespace;
+    private final boolean ifExists;
+    private final boolean ifEmpty;
 
-    public DataverseDropStatement(DataverseName dataverseName, boolean ifExists) {
-        this(dataverseName, ifExists, false);
+    public DataverseDropStatement(Namespace namespace, boolean ifExists) {
+        this(namespace, ifExists, false);
     }
 
-    public DataverseDropStatement(DataverseName dataverseName, boolean ifExists, boolean ifEmpty) {
-        this.dataverseName = dataverseName;
+    public DataverseDropStatement(Namespace namespace, boolean ifExists, boolean ifEmpty) {
+        this.namespace = Objects.requireNonNull(namespace);
         this.ifExists = ifExists;
         this.ifEmpty = ifEmpty;
     }
@@ -45,8 +48,12 @@
         return Statement.Kind.DATAVERSE_DROP;
     }
 
+    public String getDatabaseName() {
+        return namespace.getDatabaseName();
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public boolean getIfExists() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DeleteStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DeleteStatement.java
index 1ce2d55..6243149 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DeleteStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DeleteStatement.java
@@ -22,6 +22,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Statement;
@@ -30,17 +31,17 @@
 
 public class DeleteStatement extends AbstractStatement {
 
-    private VariableExpr vars;
-    private DataverseName dataverseName;
+    private final VariableExpr vars;
+    private Namespace namespace;
     private String datasetName;
-    private Expression condition;
-    private int varCounter;
+    private final Expression condition;
+    private final int varCounter;
     private Query rewrittenQuery;
 
-    public DeleteStatement(VariableExpr vars, DataverseName dataverseName, String datasetName, Expression condition,
+    public DeleteStatement(VariableExpr vars, Namespace namespace, String datasetName, Expression condition,
             int varCounter) {
         this.vars = vars;
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.condition = condition;
         this.varCounter = varCounter;
@@ -55,12 +56,20 @@
         return vars;
     }
 
-    public DataverseName getDataverseName() {
-        return dataverseName;
+    public Namespace getNamespace() {
+        return namespace;
     }
 
-    public void setDataverseName(DataverseName dataverseName) {
-        this.dataverseName = dataverseName;
+    public String getDatabaseName() {
+        return namespace == null ? null : namespace.getDatabaseName();
+    }
+
+    public DataverseName getDataverseName() {
+        return namespace == null ? null : namespace.getDataverseName();
+    }
+
+    public void setNamespace(Namespace namespace) {
+        this.namespace = namespace;
     }
 
     public String getDatasetName() {
@@ -94,7 +103,7 @@
 
     @Override
     public int hashCode() {
-        return Objects.hash(condition, datasetName, dataverseName, rewrittenQuery, vars);
+        return Objects.hash(condition, datasetName, namespace, rewrittenQuery, vars);
     }
 
     @Override
@@ -108,9 +117,8 @@
         }
         DeleteStatement target = (DeleteStatement) object;
         return Objects.equals(condition, target.condition) && Objects.equals(datasetName, target.datasetName)
-                && Objects.equals(dataverseName, target.dataverseName)
-                && Objects.equals(rewrittenQuery, target.rewrittenQuery) && Objects.equals(vars, target.vars)
-                && varCounter == target.varCounter;
+                && Objects.equals(namespace, target.namespace) && Objects.equals(rewrittenQuery, target.rewrittenQuery)
+                && Objects.equals(vars, target.vars) && varCounter == target.varCounter;
     }
 
     @Override
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DisconnectFeedStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DisconnectFeedStatement.java
index 20306c5..eb2ae01 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DisconnectFeedStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DisconnectFeedStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -28,29 +29,27 @@
 
 public class DisconnectFeedStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier feedName;
     private final Identifier datasetName;
 
-    public DisconnectFeedStatement(DataverseName dataverseName, Identifier feedName, Identifier datasetName) {
-        this.feedName = feedName;
-        this.datasetName = datasetName;
-        this.dataverseName = dataverseName;
-    }
-
-    public DisconnectFeedStatement(Pair<DataverseName, Identifier> feedNameComponent,
-            Pair<DataverseName, Identifier> datasetNameComponent) {
+    public DisconnectFeedStatement(Pair<Namespace, Identifier> feedNameComponent,
+            Pair<Namespace, Identifier> datasetNameComponent) {
         if (feedNameComponent.first != null && datasetNameComponent.first != null
                 && !feedNameComponent.first.equals(datasetNameComponent.first)) {
             throw new IllegalArgumentException("Dataverse for source feed and target dataset do not match");
         }
-        this.dataverseName = feedNameComponent.first != null ? feedNameComponent.first : datasetNameComponent.first;
+        this.namespace = feedNameComponent.first != null ? feedNameComponent.first : datasetNameComponent.first;
         this.datasetName = datasetNameComponent.second;
         this.feedName = feedNameComponent.second;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getFeedName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DropDatasetStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DropDatasetStatement.java
index 557a647..b0ee41a 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DropDatasetStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/DropDatasetStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,12 +28,12 @@
 
 public class DropDatasetStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier datasetName;
-    private boolean ifExists;
+    private final boolean ifExists;
 
-    public DropDatasetStatement(DataverseName dataverseName, Identifier datasetName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public DropDatasetStatement(Namespace namespace, Identifier datasetName, boolean ifExists) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.ifExists = ifExists;
     }
@@ -42,8 +43,12 @@
         return Statement.Kind.DATASET_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedDropStatement.java
index c91d1a1..6147fe8 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedDropStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,12 +28,12 @@
 
 public class FeedDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier feedName;
-    private boolean ifExists;
+    private final boolean ifExists;
 
-    public FeedDropStatement(DataverseName dataverseName, Identifier feedName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public FeedDropStatement(Namespace namespace, Identifier feedName, boolean ifExists) {
+        this.namespace = namespace;
         this.feedName = feedName;
         this.ifExists = ifExists;
     }
@@ -42,8 +43,12 @@
         return Statement.Kind.DROP_FEED;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getFeedName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedPolicyDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedPolicyDropStatement.java
index 21a6a39..4c3f52e 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedPolicyDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FeedPolicyDropStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,12 +28,12 @@
 
 public class FeedPolicyDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier policyName;
-    private boolean ifExists;
+    private final boolean ifExists;
 
-    public FeedPolicyDropStatement(DataverseName dataverseName, Identifier policyName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public FeedPolicyDropStatement(Namespace namespace, Identifier policyName, boolean ifExists) {
+        this.namespace = namespace;
         this.policyName = policyName;
         this.ifExists = ifExists;
     }
@@ -42,8 +43,12 @@
         return Statement.Kind.DROP_FEED_POLICY;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getPolicyName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextConfigDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextConfigDropStatement.java
index ad84571..5ecd09c 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextConfigDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextConfigDropStatement.java
@@ -20,17 +20,18 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class FullTextConfigDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String configName;
     private final boolean ifExists;
 
-    public FullTextConfigDropStatement(DataverseName dataverseName, String configName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public FullTextConfigDropStatement(Namespace namespace, String configName, boolean ifExists) {
+        this.namespace = namespace;
         this.configName = configName;
         this.ifExists = ifExists;
     }
@@ -44,8 +45,12 @@
         return ifExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getConfigName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextFilterDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextFilterDropStatement.java
index 9debca0..5e42133 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextFilterDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/FullTextFilterDropStatement.java
@@ -20,17 +20,18 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class FullTextFilterDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String filterName;
     private final boolean ifExists;
 
-    public FullTextFilterDropStatement(DataverseName dataverseName, String filterName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public FullTextFilterDropStatement(Namespace namespace, String filterName, boolean ifExists) {
+        this.namespace = namespace;
         this.filterName = filterName;
         this.ifExists = ifExists;
     }
@@ -40,8 +41,12 @@
         return Kind.FULL_TEXT_FILTER_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getFilterName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/IndexDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/IndexDropStatement.java
index d479626..0576326 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/IndexDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/IndexDropStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,14 +28,13 @@
 
 public class IndexDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier datasetName;
     private final Identifier indexName;
     private final boolean ifExists;
 
-    public IndexDropStatement(DataverseName dataverseName, Identifier datasetName, Identifier indexName,
-            boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public IndexDropStatement(Namespace namespace, Identifier datasetName, Identifier indexName, boolean ifExists) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.indexName = indexName;
         this.ifExists = ifExists;
@@ -45,8 +45,12 @@
         return Statement.Kind.INDEX_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getDatasetName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/InsertStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/InsertStatement.java
index cf720ba..d4251c6 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/InsertStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/InsertStatement.java
@@ -24,6 +24,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.IReturningStatement;
@@ -33,16 +34,16 @@
 
 public class InsertStatement extends AbstractStatement implements IReturningStatement {
 
-    private DataverseName dataverseName;
+    private Namespace namespace;
     private String datasetName;
     private final Query query;
     private final VariableExpr var;
     private Expression returnExpression;
     private int varCounter;
 
-    public InsertStatement(DataverseName dataverseName, String datasetName, Query query, int varCounter,
-            VariableExpr var, Expression returnExpression) {
-        this.dataverseName = dataverseName;
+    public InsertStatement(Namespace namespace, String datasetName, Query query, int varCounter, VariableExpr var,
+            Expression returnExpression) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.query = query;
         this.varCounter = varCounter;
@@ -55,12 +56,20 @@
         return Statement.Kind.INSERT;
     }
 
-    public DataverseName getDataverseName() {
-        return dataverseName;
+    public Namespace getNamespace() {
+        return namespace;
     }
 
-    public void setDataverseName(DataverseName dataverseName) {
-        this.dataverseName = dataverseName;
+    public DataverseName getDataverseName() {
+        return namespace == null ? null : namespace.getDataverseName();
+    }
+
+    public String getDatabaseName() {
+        return namespace == null ? null : namespace.getDatabaseName();
+    }
+
+    public void setNamespace(Namespace namespace) {
+        this.namespace = namespace;
     }
 
     public String getDatasetName() {
@@ -129,7 +138,7 @@
 
     @Override
     public int hashCode() {
-        return Objects.hash(datasetName, dataverseName, query, varCounter, var, returnExpression);
+        return Objects.hash(datasetName, namespace, query, varCounter, var, returnExpression);
     }
 
     @Override
@@ -142,7 +151,7 @@
             return false;
         }
         InsertStatement target = (InsertStatement) object;
-        return Objects.equals(datasetName, target.datasetName) && Objects.equals(dataverseName, target.dataverseName)
+        return Objects.equals(datasetName, target.datasetName) && Objects.equals(namespace, target.namespace)
                 && Objects.equals(query, target.query) && Objects.equals(returnExpression, target.returnExpression)
                 && varCounter == target.varCounter && Objects.equals(var, target.var);
     }
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LibraryDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LibraryDropStatement.java
index 412b3ba..85d6389 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LibraryDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LibraryDropStatement.java
@@ -21,24 +21,29 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public final class LibraryDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final String libraryName;
 
     private final boolean ifExists;
 
-    public LibraryDropStatement(DataverseName dataverseName, String libraryName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public LibraryDropStatement(Namespace namespace, String libraryName, boolean ifExists) {
+        this.namespace = namespace;
         this.libraryName = libraryName;
         this.ifExists = ifExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getLibraryName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LoadStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LoadStatement.java
index e649e2a..38accc5 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LoadStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/LoadStatement.java
@@ -22,24 +22,25 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class LoadStatement extends AbstractStatement {
 
-    private DataverseName dataverseName;
+    private Namespace namespace;
     private String datasetName;
     private String adapter;
     private Map<String, String> properties;
-    private boolean dataIsLocallySorted;
+    private final boolean dataIsLocallySorted;
 
-    public LoadStatement(DataverseName dataverseName, String datasetName, String adapter,
-            Map<String, String> propertiees, boolean dataIsLocallySorted) {
-        this.dataverseName = dataverseName;
+    public LoadStatement(Namespace namespace, String datasetName, String adapter, Map<String, String> properties,
+            boolean dataIsLocallySorted) {
+        this.namespace = namespace;
         this.datasetName = datasetName;
         this.adapter = adapter;
-        this.properties = propertiees;
+        this.properties = properties;
         this.dataIsLocallySorted = dataIsLocallySorted;
     }
 
@@ -59,12 +60,20 @@
         this.properties = properties;
     }
 
-    public DataverseName getDataverseName() {
-        return dataverseName;
+    public Namespace getNamespace() {
+        return namespace;
     }
 
-    public void setDataverseName(DataverseName dataverseName) {
-        this.dataverseName = dataverseName;
+    public DataverseName getDataverseName() {
+        return namespace == null ? null : namespace.getDataverseName();
+    }
+
+    public String getDatabaseName() {
+        return namespace == null ? null : namespace.getDatabaseName();
+    }
+
+    public void setNamespace(Namespace namespace) {
+        this.namespace = namespace;
     }
 
     @Override
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodeGroupDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodeGroupDropStatement.java
index 7bb0c69..8ca632e 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodeGroupDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodeGroupDropStatement.java
@@ -26,8 +26,8 @@
 
 public class NodeGroupDropStatement extends AbstractStatement {
 
-    private Identifier nodeGroupName;
-    private boolean ifExists;
+    private final Identifier nodeGroupName;
+    private final boolean ifExists;
 
     public NodeGroupDropStatement(Identifier nodeGroupName, boolean ifExists) {
         this.nodeGroupName = nodeGroupName;
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodegroupDecl.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodegroupDecl.java
index e4b3f5b..a01c841 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodegroupDecl.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/NodegroupDecl.java
@@ -28,9 +28,9 @@
 
 public class NodegroupDecl extends AbstractStatement {
 
-    private Identifier nodegroupName;
-    private List<Identifier> nodeControllerNames;
-    private boolean ifNotExists;
+    private final Identifier nodegroupName;
+    private final List<Identifier> nodeControllerNames;
+    private final boolean ifNotExists;
 
     public NodegroupDecl(Identifier nodegroupName, List<Identifier> nodeControllerNames, boolean ifNotExists) {
         this.nodegroupName = nodegroupName;
@@ -46,10 +46,6 @@
         return nodeControllerNames;
     }
 
-    public void setNodeControllerNames(List<Identifier> nodeControllerNames) {
-        this.nodeControllerNames = nodeControllerNames;
-    }
-
     public boolean getIfNotExists() {
         return this.ifNotExists;
     }
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SetStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SetStatement.java
index 8c52b45..6239655 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SetStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SetStatement.java
@@ -25,8 +25,8 @@
 
 public class SetStatement extends AbstractStatement {
 
-    private String propName;
-    private String propValue;
+    private final String propName;
+    private final String propValue;
 
     public SetStatement(String propName, String propValue) {
         this.propName = propName;
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StartFeedStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StartFeedStatement.java
index 7dc652e..921b4b0 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StartFeedStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StartFeedStatement.java
@@ -21,6 +21,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.struct.Identifier;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
@@ -29,11 +30,11 @@
 public class StartFeedStatement extends AbstractStatement {
 
     public static final String WAIT_FOR_COMPLETION = "wait-for-completion-feed";
-    private DataverseName dataverseName;
-    private Identifier feedName;
+    private final Namespace namespace;
+    private final Identifier feedName;
 
-    public StartFeedStatement(Pair<DataverseName, Identifier> feedNameComp) {
-        dataverseName = feedNameComp.first;
+    public StartFeedStatement(Pair<Namespace, Identifier> feedNameComp) {
+        namespace = feedNameComp.first;
         feedName = feedNameComp.second;
     }
 
@@ -52,8 +53,12 @@
         return Category.UPDATE;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getFeedName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StopFeedStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StopFeedStatement.java
index 4cfcc0a..e69519b 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StopFeedStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/StopFeedStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.struct.Identifier;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
@@ -27,11 +28,11 @@
 
 public class StopFeedStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier feedName;
 
-    public StopFeedStatement(Pair<DataverseName, Identifier> feedNameComp) {
-        this.dataverseName = feedNameComp.first;
+    public StopFeedStatement(Pair<Namespace, Identifier> feedNameComp) {
+        this.namespace = feedNameComp.first;
         this.feedName = feedNameComp.second;
     }
 
@@ -50,8 +51,12 @@
         return visitor.visit(this, arg);
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getFeedName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SynonymDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SynonymDropStatement.java
index 31c8337..d81b872 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SynonymDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/SynonymDropStatement.java
@@ -21,25 +21,30 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.visitor.base.ILangVisitor;
 
 public class SynonymDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final String synonymName;
 
     private final boolean ifExists;
 
-    public SynonymDropStatement(DataverseName dataverseName, String synonymName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public SynonymDropStatement(Namespace namespace, String synonymName, boolean ifExists) {
+        this.namespace = namespace;
         this.synonymName = synonymName;
         this.ifExists = ifExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public String getSynonymName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDecl.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDecl.java
index a840fea..264a797 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDecl.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDecl.java
@@ -21,6 +21,7 @@
 import org.apache.asterix.common.annotations.TypeDataGen;
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.expression.TypeExpression;
@@ -29,31 +30,31 @@
 
 public class TypeDecl extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
     private final Identifier ident;
     private final TypeExpression typeDef;
     private final TypeDataGen datagenAnnotation;
     private final boolean ifNotExists;
 
-    public TypeDecl(DataverseName dataverseName, Identifier ident, TypeExpression typeDef, TypeDataGen datagen,
+    public TypeDecl(Namespace namespace, Identifier ident, TypeExpression typeDef, TypeDataGen datagen,
             boolean ifNotExists) {
-        this.dataverseName = dataverseName;
+        this.namespace = namespace;
         this.ident = ident;
         this.typeDef = typeDef;
         this.datagenAnnotation = datagen;
         this.ifNotExists = ifNotExists;
     }
 
-    public TypeDecl(DataverseName dataverse, Identifier ident, TypeExpression typeDef) {
-        this(dataverse, ident, typeDef, null, false);
-    }
-
     public Identifier getIdent() {
         return ident;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public TypeExpression getTypeDef() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDropStatement.java
index 73aef54..2eb7ef1 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/TypeDropStatement.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -27,12 +28,12 @@
 
 public class TypeDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
-    private Identifier typeName;
-    private boolean ifExists;
+    private final Namespace namespace;
+    private final Identifier typeName;
+    private final boolean ifExists;
 
-    public TypeDropStatement(DataverseName dataverseName, Identifier typeName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public TypeDropStatement(Namespace namespace, Identifier typeName, boolean ifExists) {
+        this.namespace = namespace;
         this.typeName = typeName;
         this.ifExists = ifExists;
     }
@@ -42,8 +43,12 @@
         return Statement.Kind.TYPE_DROP;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getTypeName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/UpsertStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/UpsertStatement.java
index 09ef2f2..b537cdf 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/UpsertStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/UpsertStatement.java
@@ -18,16 +18,16 @@
  */
 package org.apache.asterix.lang.common.statement;
 
-import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.expression.VariableExpr;
 
 public class UpsertStatement extends InsertStatement {
 
-    public UpsertStatement(DataverseName dataverseName, String datasetName, Query query, int varCounter,
-            VariableExpr var, Expression returnExpression) {
-        super(dataverseName, datasetName, query, varCounter, var, returnExpression);
+    public UpsertStatement(Namespace namespace, String datasetName, Query query, int varCounter, VariableExpr var,
+            Expression returnExpression) {
+        super(namespace, datasetName, query, varCounter, var, returnExpression);
     }
 
     @Override
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ViewDropStatement.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ViewDropStatement.java
index 9f8577c..d5a053a 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ViewDropStatement.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/statement/ViewDropStatement.java
@@ -21,6 +21,7 @@
 
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractStatement;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.struct.Identifier;
@@ -28,20 +29,24 @@
 
 public class ViewDropStatement extends AbstractStatement {
 
-    private final DataverseName dataverseName;
+    private final Namespace namespace;
 
     private final Identifier viewName;
 
     private final boolean ifExists;
 
-    public ViewDropStatement(DataverseName dataverseName, Identifier viewName, boolean ifExists) {
-        this.dataverseName = dataverseName;
+    public ViewDropStatement(Namespace namespace, Identifier viewName, boolean ifExists) {
+        this.namespace = namespace;
         this.viewName = viewName;
         this.ifExists = ifExists;
     }
 
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
     public DataverseName getDataverseName() {
-        return dataverseName;
+        return namespace == null ? null : namespace.getDataverseName();
     }
 
     public Identifier getViewName() {
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/util/FunctionUtil.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/util/FunctionUtil.java
index b5757af..e1ba3ba 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/util/FunctionUtil.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/util/FunctionUtil.java
@@ -38,6 +38,7 @@
 import org.apache.asterix.common.metadata.DatasetFullyQualifiedName;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.DependencyFullyQualifiedName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.IParser;
 import org.apache.asterix.lang.common.base.IParserFactory;
@@ -90,15 +91,17 @@
         return BuiltinFunctions.getBuiltinFunctionInfo(fi);
     }
 
-    public static TypeSignature getTypeDependencyFromFunctionParameter(TypeExpression typeExpr,
+    public static TypeSignature getTypeDependencyFromFunctionParameter(TypeExpression typeExpr, String defaultDatabase,
             DataverseName defaultDataverse) {
         switch (typeExpr.getTypeKind()) {
             case ORDEREDLIST:
                 return getTypeDependencyFromFunctionParameter(
-                        ((OrderedListTypeDefinition) typeExpr).getItemTypeExpression(), defaultDataverse);
+                        ((OrderedListTypeDefinition) typeExpr).getItemTypeExpression(), defaultDatabase,
+                        defaultDataverse);
             case UNORDEREDLIST:
                 return getTypeDependencyFromFunctionParameter(
-                        ((UnorderedListTypeDefinition) typeExpr).getItemTypeExpression(), defaultDataverse);
+                        ((UnorderedListTypeDefinition) typeExpr).getItemTypeExpression(), defaultDatabase,
+                        defaultDataverse);
             case TYPEREFERENCE:
                 TypeReferenceExpression typeRef = ((TypeReferenceExpression) typeExpr);
                 String typeName = typeRef.getIdent().getSecond().toString();
@@ -106,9 +109,17 @@
                 if (builtinType != null) {
                     return null;
                 }
-                DataverseName typeDataverseName =
-                        typeRef.getIdent().getFirst() != null ? typeRef.getIdent().getFirst() : defaultDataverse;
-                return new TypeSignature(typeDataverseName, typeName);
+                Namespace typeRefNamespace = typeRef.getIdent().getFirst();
+                DataverseName typeDataverseName;
+                String typeDatabaseName;
+                if (typeRefNamespace == null) {
+                    typeDataverseName = defaultDataverse;
+                    typeDatabaseName = defaultDatabase;
+                } else {
+                    typeDataverseName = typeRefNamespace.getDataverseName();
+                    typeDatabaseName = typeRefNamespace.getDatabaseName();
+                }
+                return new TypeSignature(typeDatabaseName, typeDataverseName, typeName);
             case RECORD:
                 throw new IllegalArgumentException();
             default:
@@ -123,8 +134,9 @@
         DataverseName dataverse = fs.getDataverseName();
         String database = fs.getDatabaseName();
         if (dataverse == null) {
-            dataverse = metadataProvider.getDefaultDataverseName();
-            database = metadataProvider.getDefaultDatabase();
+            Namespace defaultNamespace = metadataProvider.getDefaultNamespace();
+            dataverse = defaultNamespace.getDataverseName();
+            database = defaultNamespace.getDatabaseName();
         }
         if (searchUdfs && !isBuiltinFunctionDataverse(dataverse)) {
             // attempt to resolve to a user-defined function
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/FormatPrintVisitor.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/FormatPrintVisitor.java
index c24ddef..8edff28 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/FormatPrintVisitor.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/FormatPrintVisitor.java
@@ -408,7 +408,8 @@
     @Override
     public Void visit(TypeReferenceExpression t, Integer arg) throws CompilationException {
         if (t.getIdent().first != null && t.getIdent().first != null) {
-            out.print(generateDataverseName(t.getIdent().first));
+            //TODO(DB): include database
+            out.print(generateDataverseName(t.getIdent().first.getDataverseName()));
             out.print('.');
         }
         out.print(normalize(t.getIdent().second.getValue()));
diff --git a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/QueryPrintVisitor.java b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/QueryPrintVisitor.java
index aa875b4..3656e5e 100644
--- a/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/QueryPrintVisitor.java
+++ b/asterixdb/asterix-lang-common/src/main/java/org/apache/asterix/lang/common/visitor/QueryPrintVisitor.java
@@ -336,7 +336,8 @@
     @Override
     public Void visit(TypeReferenceExpression t, Integer arg) throws CompilationException {
         if (t.getIdent().first != null && t.getIdent().first != null) {
-            out.print(t.getIdent().first);
+            //TODO(DB): include database
+            out.print(t.getIdent().first.getDataverseName());
             out.print('.');
         }
         out.print(t.getIdent().second.getValue());
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppQueryRewriter.java b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppQueryRewriter.java
index 34757a9..0ce09e5 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppQueryRewriter.java
+++ b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppQueryRewriter.java
@@ -33,6 +33,7 @@
 import org.apache.asterix.common.functions.FunctionSignature;
 import org.apache.asterix.common.metadata.DatasetFullyQualifiedName;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.AbstractExpression;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.IParserFactory;
@@ -552,20 +553,23 @@
     private Expression rewriteFunctionOrViewBody(String entityDatabaseName, DataverseName entityDataverseName,
             Object entityDisplayName, Expression bodyExpr, List<VarIdentifier> externalVars,
             boolean allowNonStoredUdfCalls, SourceLocation sourceLoc) throws CompilationException {
-        Dataverse defaultDataverse = metadataProvider.getDefaultDataverse();
-        Dataverse targetDataverse;
-        if (entityDataverseName == null || (entityDatabaseName.equals(defaultDataverse.getDatabaseName())
-                && entityDataverseName.equals(defaultDataverse.getDataverseName()))) {
-            targetDataverse = defaultDataverse;
+        Namespace defaultNamespace = metadataProvider.getDefaultNamespace();
+        Namespace targetNamespace = null;
+        if (entityDataverseName == null || (entityDatabaseName.equals(defaultNamespace.getDatabaseName())
+                && entityDataverseName.equals(defaultNamespace.getDataverseName()))) {
+            targetNamespace = defaultNamespace;
         } else {
             try {
-                targetDataverse = metadataProvider.findDataverse(entityDatabaseName, entityDataverseName);
+                Dataverse dv = metadataProvider.findDataverse(entityDatabaseName, entityDataverseName);
+                if (dv != null) {
+                    targetNamespace = new Namespace(dv.getDatabaseName(), dv.getDataverseName());
+                }
             } catch (AlgebricksException e) {
                 throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, e, sourceLoc, entityDataverseName);
             }
         }
 
-        metadataProvider.setDefaultDataverse(targetDataverse);
+        metadataProvider.setDefaultNamespace(targetNamespace);
         try {
             Query wrappedQuery = ExpressionUtils.createWrappedQuery(bodyExpr, sourceLoc);
             getFunctionAndViewBodyRewriter().rewrite(context, wrappedQuery, allowNonStoredUdfCalls, false,
@@ -575,7 +579,7 @@
             throw new CompilationException(ErrorCode.COMPILATION_BAD_FUNCTION_DEFINITION, e,
                     entityDisplayName.toString(), e.getMessage());
         } finally {
-            metadataProvider.setDefaultDataverse(defaultDataverse);
+            metadataProvider.setDefaultNamespace(defaultNamespace);
         }
     }
 
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/visitor/VariableCheckAndRewriteVisitor.java b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/visitor/VariableCheckAndRewriteVisitor.java
index 9c53a2b..27a63d2 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/visitor/VariableCheckAndRewriteVisitor.java
+++ b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/visitor/VariableCheckAndRewriteVisitor.java
@@ -33,6 +33,7 @@
 import org.apache.asterix.common.metadata.DatasetFullyQualifiedName;
 import org.apache.asterix.common.metadata.DataverseName;
 import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.base.Expression.Kind;
 import org.apache.asterix.lang.common.base.ILangExpression;
@@ -78,8 +79,9 @@
         if (resolveAsVariableReference(varExpr)) {
             return varExpr;
         }
-        DataverseName dataverseName = metadataProvider.getDefaultDataverseName();
-        String databaseName = metadataProvider.getDefaultDatabase();
+        Namespace defaultNamespace = metadataProvider.getDefaultNamespace();
+        DataverseName dataverseName = defaultNamespace.getDataverseName();
+        String databaseName = defaultNamespace.getDatabaseName();
         String datasetName = SqlppVariableUtil.toUserDefinedVariableName(varExpr.getVar().getValue()).getValue();
         CallExpr datasetExpr = resolveAsDataset(databaseName, dataverseName, datasetName, parent, varExpr);
         return datasetExpr != null ? datasetExpr : resolveAsFieldAccessOverContextVar(varExpr);
@@ -260,7 +262,7 @@
 
     private CompilationException createUnresolvableError(DataverseName dataverseName, String datasetName,
             SourceLocation sourceLoc) {
-        DataverseName defaultDataverseName = metadataProvider.getDefaultDataverseName();
+        DataverseName defaultDataverseName = metadataProvider.getDefaultNamespace().getDataverseName();
         if (dataverseName == null && defaultDataverseName == null) {
             return new CompilationException(ErrorCode.NAME_RESOLVE_UNKNOWN_DATASET, sourceLoc, datasetName);
         }
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
index 67596a9..62e4d23 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
+++ b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
@@ -21,7 +21,7 @@
 import java.util.Collections;
 
 import org.apache.asterix.common.metadata.DataverseName;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Expression;
 import org.apache.asterix.lang.common.clause.WhereClause;
 import org.apache.asterix.lang.common.expression.CallExpr;
@@ -54,10 +54,11 @@
     @Override
     public Void visit(DeleteStatement deleteStmt, MetadataProvider metadataProvider) {
         DataverseName dataverseName = deleteStmt.getDataverseName();
-        String databaseName = MetadataUtil.resolveDatabase(null, deleteStmt.getDataverseName());
+        String databaseName = deleteStmt.getDatabaseName();
         if (dataverseName == null) {
-            dataverseName = metadataProvider.getDefaultDataverseName();
-            databaseName = metadataProvider.getDefaultDatabase();
+            Namespace defaultNamespace = metadataProvider.getDefaultNamespace();
+            dataverseName = defaultNamespace.getDataverseName();
+            databaseName = defaultNamespace.getDatabaseName();
         }
         String datasetName = deleteStmt.getDatasetName();
         CallExpr callExpression = FunctionUtil.makeDatasetCallExpr(databaseName, dataverseName, datasetName);
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppSynonymRewriteVisitor.java b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppSynonymRewriteVisitor.java
index f50a63b..7c1c112 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppSynonymRewriteVisitor.java
+++ b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppSynonymRewriteVisitor.java
@@ -22,7 +22,7 @@
 import org.apache.asterix.common.exceptions.CompilationException;
 import org.apache.asterix.common.exceptions.ErrorCode;
 import org.apache.asterix.common.metadata.DataverseName;
-import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.statement.DeleteStatement;
 import org.apache.asterix.lang.common.statement.InsertStatement;
 import org.apache.asterix.lang.common.statement.LoadStatement;
@@ -44,11 +44,11 @@
 
     @Override
     public Void visit(LoadStatement loadStmt, MetadataProvider metadataProvider) throws CompilationException {
-        String database = MetadataUtil.resolveDatabase(null, loadStmt.getDataverseName());
-        Quadruple<DataverseName, String, Boolean, String> dsName = resolveDatasetNameUsingSynonyms(metadataProvider,
-                database, loadStmt.getDataverseName(), loadStmt.getDatasetName(), false, loadStmt.getSourceLocation());
+        Quadruple<DataverseName, String, Boolean, String> dsName =
+                resolveDatasetNameUsingSynonyms(metadataProvider, loadStmt.getDatabaseName(),
+                        loadStmt.getDataverseName(), loadStmt.getDatasetName(), false, loadStmt.getSourceLocation());
         if (dsName != null) {
-            loadStmt.setDataverseName(dsName.getFirst());
+            loadStmt.setNamespace(new Namespace(dsName.getFourth(), dsName.getFirst()));
             loadStmt.setDatasetName(dsName.getSecond());
         }
         return null;
@@ -56,12 +56,11 @@
 
     @Override
     public Void visit(InsertStatement insertStmt, MetadataProvider metadataProvider) throws CompilationException {
-        String database = MetadataUtil.resolveDatabase(null, insertStmt.getDataverseName());
-        Quadruple<DataverseName, String, Boolean, String> dsName =
-                resolveDatasetNameUsingSynonyms(metadataProvider, database, insertStmt.getDataverseName(),
-                        insertStmt.getDatasetName(), false, insertStmt.getSourceLocation());
+        Quadruple<DataverseName, String, Boolean, String> dsName = resolveDatasetNameUsingSynonyms(metadataProvider,
+                insertStmt.getDatabaseName(), insertStmt.getDataverseName(), insertStmt.getDatasetName(), false,
+                insertStmt.getSourceLocation());
         if (dsName != null) {
-            insertStmt.setDataverseName(dsName.getFirst());
+            insertStmt.setNamespace(new Namespace(dsName.getFourth(), dsName.getFirst()));
             insertStmt.setDatasetName(dsName.getSecond());
         }
         return null;
@@ -69,12 +68,11 @@
 
     @Override
     public Void visit(DeleteStatement deleteStmt, MetadataProvider metadataProvider) throws CompilationException {
-        String database = MetadataUtil.resolveDatabase(null, deleteStmt.getDataverseName());
-        Quadruple<DataverseName, String, Boolean, String> dsName =
-                resolveDatasetNameUsingSynonyms(metadataProvider, database, deleteStmt.getDataverseName(),
-                        deleteStmt.getDatasetName(), false, deleteStmt.getSourceLocation());
+        Quadruple<DataverseName, String, Boolean, String> dsName = resolveDatasetNameUsingSynonyms(metadataProvider,
+                deleteStmt.getDatabaseName(), deleteStmt.getDataverseName(), deleteStmt.getDatasetName(), false,
+                deleteStmt.getSourceLocation());
         if (dsName != null) {
-            deleteStmt.setDataverseName(dsName.getFirst());
+            deleteStmt.setNamespace(new Namespace(dsName.getFourth(), dsName.getFirst()));
             deleteStmt.setDatasetName(dsName.getSecond());
         }
         return null;
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
index b5dd4c4..0eb09a9 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
+++ b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
@@ -283,6 +283,8 @@
 
     private int externalVarCounter;
 
+    private Namespace defaultNamespace;
+
     private String defaultDatabase;
 
     private DataverseName defaultDataverse;
@@ -308,6 +310,7 @@
     }
 
     private static class FunctionName {
+       public Namespace namespace;
        public String database;
        public DataverseName dataverse;
        public String library;
@@ -899,6 +902,17 @@
       }
     }
 
+    private Namespace createNamespace(List<String> parts, int fromIndex, int toIndex, Token startToken)
+      throws SqlppParseException {
+      try {
+        return namespaceResolver.resolve(parts, fromIndex, toIndex);
+      } catch (AsterixException e) {
+        SqlppParseException pe = new SqlppParseException(getSourceLocation(startToken), e.getMessage());
+        pe.initCause(e);
+        throw pe;
+      }
+    }
+
     private Namespace createNamespace(List<String> parts, Token startToken) throws SqlppParseException {
       try {
         return namespaceResolver.resolve(parts);
@@ -999,6 +1013,7 @@
       ns = createNamespace(ident.first, ident.second);
       defaultDataverse = ns.getDataverseName();
       defaultDatabase = ns.getDatabaseName();
+      defaultNamespace = ns;
       DataverseDecl dvDecl = new DataverseDecl(ns);
       return addSourceLocation(dvDecl, startToken);
     }
@@ -1063,7 +1078,7 @@
 
 TypeDecl TypeSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifNotExists = false;
   TypeExpression typeExpr = null;
 }
@@ -1157,7 +1172,7 @@
 
 DatasetDecl DatasetSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifNotExists = false;
   TypeExpression typeExpr = null;
   TypeExpression metaTypeExpr = null;
@@ -1208,7 +1223,8 @@
           primaryKeyFieldsWithTypes.first, autogenerated, filterField == null? null : filterField.first,
           filterField == null? null : filterField.second, primaryKeyFieldsWithTypes.third);
         final TypeReferenceExpression anyObjectReference = new TypeReferenceExpression(
-          new Pair(MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDataverseName(),
+          new Pair(new Namespace(MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDatabaseName(),
+            MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDataverseName()),
             new Identifier(MetadataBuiltinEntities.ANY_OBJECT_DATATYPE.getDatatypeName())));
         stmt = new DatasetDecl(nameComponents.first, nameComponents.second, anyObjectReference, null, hints,
           DatasetType.INTERNAL, idd, withRecord, ifNotExists, query);
@@ -1234,7 +1250,7 @@
 
 DatasetDecl ExternalDatasetSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   TypeExpression typeExpr = null;
   boolean ifNotExists = false;
   String adapterName = null;
@@ -1350,7 +1366,7 @@
 
 CreateIndexStatement IndexSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   String indexName = null;
   IndexParams indexParams = null;
   CreateIndexStatement.IndexedElement indexedElement = null;
@@ -1532,7 +1548,7 @@
 
 CreateIndexStatement PrimaryIndexSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   String indexName = null;
   boolean ifNotExists = false;
 }
@@ -1640,13 +1656,13 @@
 
 CreateDataverseStatement DataverseSpecification(Token startStmtToken) throws ParseException :
 {
-  DataverseName dvName = null;
+  Namespace ns = null;
   boolean ifNotExists = false;
 }
 {
-  dvName = DataverseName() ifNotExists = IfNotExists()
+  ns = Namespace() ifNotExists = IfNotExists()
   {
-    CreateDataverseStatement stmt = new CreateDataverseStatement(dvName, null, ifNotExists);
+    CreateDataverseStatement stmt = new CreateDataverseStatement(ns, null, ifNotExists);
     return addSourceLocation(stmt, startStmtToken);
   }
 }
@@ -1664,8 +1680,8 @@
 
 CreateAdapterStatement AdapterSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> adapterName = null;
-  Pair<DataverseName,Identifier> libraryName = null;
+  Pair<Namespace,Identifier> adapterName = null;
+  Pair<Namespace,Identifier> libraryName = null;
   List<String> externalIdentifier = null;
   boolean ifNotExists = false;
 }
@@ -1694,7 +1710,7 @@
 
 CreateViewStatement ViewSpecification(Token startStmtToken, boolean orReplace) throws ParseException:
 {
-  Pair<DataverseName, Identifier> nameComponents = null;
+  Pair<Namespace, Identifier> nameComponents = null;
   TypeExpression typeExpr = null;
   boolean ifNotExists = false;
   Token beginPos = null, endPos = null;
@@ -1704,10 +1720,11 @@
   Map<String, String> viewConfig = null;
   Pair<List<Integer>, List<List<String>>> primaryKeyFields = null;
   Pair<List<Integer>, List<List<String>>> foreignKeyFields = null;
-  Pair<DataverseName, Identifier> refNameComponents = null;
+  Pair<Namespace, Identifier> refNameComponents = null;
   List<CreateViewStatement.ForeignKeyDecl> foreignKeyDecls = null;
   DataverseName currentDataverse = defaultDataverse;
   String currentDatabase = defaultDatabase;
+  Namespace currentNamespace = defaultNamespace;
 }
 {
   nameComponents = QualifiedName()
@@ -1750,8 +1767,9 @@
     beginPos = token;
     createNewScope();
     if (nameComponents.first != null) {
-      defaultDataverse = nameComponents.first;
-      defaultDatabase = MetadataUtil.databaseFor(nameComponents.first);
+      defaultNamespace = nameComponents.first;
+      defaultDataverse = nameComponents.first.getDataverseName();
+      defaultDatabase = nameComponents.first.getDatabaseName();
     }
   }
   viewBodyExpr = ViewBody()
@@ -1762,6 +1780,7 @@
     removeCurrentScope();
     defaultDataverse = currentDataverse;
     defaultDatabase = currentDatabase;
+    defaultNamespace = currentNamespace;
     if (typeExpr != null && primaryKeyFields != null) {
       DatasetDeclParametersUtil.adjustInlineTypeDecl(typeExpr, primaryKeyFields.second, primaryKeyFields.first, false);
     }
@@ -1831,19 +1850,21 @@
   TypeExpression returnType = null;
   Token beginPos = null, endPos = null;
   Expression functionBodyExpr = null;
-  Pair<DataverseName,Identifier> libraryName = null;
+  Pair<Namespace,Identifier> libraryName = null;
   List<String> externalIdentifier = null;
   RecordConstructor withOptions = null;
   boolean ifNotExists = false;
   CreateFunctionStatement stmt = null;
   DataverseName currentDataverse = defaultDataverse;
   String currentDatabase = defaultDatabase;
+  Namespace currentNamespace = defaultNamespace;
 }
 {
   fctName = FunctionName()
   {
      defaultDataverse = fctName.dataverse;
      defaultDatabase = fctName.database;
+     defaultNamespace = fctName.namespace;
   }
   paramsWithArity = FunctionParameters()
   {
@@ -1895,6 +1916,7 @@
   {
     defaultDataverse = currentDataverse;
     defaultDatabase = currentDatabase;
+    defaultNamespace = currentNamespace;
     return addSourceLocation(stmt, startStmtToken);
   }
 }
@@ -2012,7 +2034,7 @@
 
 CreateFeedStatement FeedSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifNotExists = false;
   String adapterName = null;
   Map<String,String> properties = null;
@@ -2091,7 +2113,7 @@
 CreateFullTextFilterStatement CreateFullTextFilterSpec(Token startStmtToken) throws ParseException:
 {
   CreateFullTextFilterStatement stmt = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifNotExists = false;
   RecordConstructor expr = null;
 }
@@ -2114,7 +2136,7 @@
 CreateFullTextConfigStatement CreateFullTextConfigSpec(Token startStmtToken) throws ParseException:
 {
   CreateFullTextConfigStatement stmt = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifNotExists = false;
   RecordConstructor expr = null;
 }
@@ -2147,8 +2169,8 @@
 
 CreateSynonymStatement SynonymSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> nameComponents = null;
-  Pair<DataverseName,Identifier> objectNameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> objectNameComponents = null;
   boolean ifNotExists = false;
 }
 {
@@ -2357,7 +2379,7 @@
 
 DropDatasetStatement DropDatasetSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2381,7 +2403,7 @@
 
 ViewDropStatement DropViewSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2405,7 +2427,7 @@
 
 IndexDropStatement DropIndexSpecification(Token startStmtToken) throws ParseException:
 {
-  Triple<DataverseName,Identifier,Identifier> tripleId = null;
+  Triple<Namespace,Identifier,Identifier> tripleId = null;
   boolean ifExists = false;
 }
 {
@@ -2434,7 +2456,7 @@
 FullTextFilterDropStatement DropFullTextFilterSpec(Token startStmtToken) throws ParseException:
 {
   FullTextFilterDropStatement stmt = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifExists = false;
 }
 {
@@ -2448,7 +2470,7 @@
 FullTextConfigDropStatement DropFullTextConfigSpec(Token startStmtToken) throws ParseException:
 {
   FullTextConfigDropStatement stmt = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   boolean ifExists = false;
 }
 {
@@ -2497,7 +2519,7 @@
 
 TypeDropStatement DropTypeSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2545,13 +2567,13 @@
 
 DataverseDropStatement DropDataverseSpecification(Token startStmtToken) throws ParseException:
 {
-  DataverseName dvName = null;
+  Namespace ns = null;
   boolean ifExists = false;
 }
 {
-  dvName = DataverseName() ifExists = IfExists()
+  ns = Namespace() ifExists = IfExists()
   {
-    DataverseDropStatement stmt = new DataverseDropStatement(dvName, ifExists);
+    DataverseDropStatement stmt = new DataverseDropStatement(ns, ifExists);
     return addSourceLocation(stmt, startStmtToken);
   }
 }
@@ -2569,7 +2591,7 @@
 
 AdapterDropStatement DropAdapterSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> adapterName = null;
+  Pair<Namespace,Identifier> adapterName = null;
   boolean ifExists = false;
 }
 {
@@ -2617,7 +2639,7 @@
 
 FeedDropStatement DropFeedSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2641,7 +2663,7 @@
 
 FeedPolicyDropStatement DropFeedPolicySpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2665,7 +2687,7 @@
 
 SynonymDropStatement DropSynonymSpecification(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> pairId = null;
+  Pair<Namespace,Identifier> pairId = null;
   boolean ifExists = false;
 }
 {
@@ -2693,7 +2715,7 @@
 InsertStatement InsertStatement() throws ParseException:
 {
   Token startToken = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   VariableExpr var = null;
   Query query = null;
   Expression returnExpression = null;
@@ -2717,7 +2739,7 @@
 UpsertStatement UpsertStatement() throws ParseException:
 {
   Token startToken = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
   VariableExpr var = null;
   Query query = null;
   Expression returnExpression = null;
@@ -2743,7 +2765,7 @@
   Token startToken = null;
   VariableExpr var = null;
   Expression condition = null;
-  Pair<DataverseName, Identifier> nameComponents;
+  Pair<Namespace, Identifier> nameComponents;
 }
 {
   <DELETE> { startToken = token; }
@@ -2829,18 +2851,18 @@
 CopyStatement CopyStatement() throws ParseException:
 {
   Token startToken = null;
-  DataverseName dataverseName = null;
+  Namespace namespace = null;
   Identifier datasetName = null;
   TypeExpression typeExpr = null;
   boolean alreadySorted = false;
   String adapterName;
   Map<String,String> properties;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
 }
 {
   <COPY> (<INTO>)? { startToken = token; } nameComponents = QualifiedName()
     {
-      dataverseName = nameComponents.first;
+      namespace = nameComponents.first;
       datasetName = nameComponents.second;
     }
   (<AS> typeExpr = DatasetTypeSpecification())?
@@ -2850,7 +2872,7 @@
        edd.setAdapter(adapterName);
        edd.setProperties(properties);
        try {
-         CopyStatement stmt = new CopyStatement(dataverseName, datasetName.getValue(), typeExpr, edd, null);
+         CopyStatement stmt = new CopyStatement(namespace, datasetName.getValue(), typeExpr, edd, null);
          return addSourceLocation(stmt, startToken);
        } catch (CompilationException e){
            throw new SqlppParseException(getSourceLocation(startToken), e.getMessage());
@@ -2861,17 +2883,17 @@
 LoadStatement LoadStatement() throws ParseException:
 {
   Token startToken = null;
-  DataverseName dataverseName = null;
+  Namespace namespace = null;
   Identifier datasetName = null;
   boolean alreadySorted = false;
   String adapterName;
   Map<String,String> properties;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
 }
 {
   <LOAD> { startToken = token; } Dataset() nameComponents = QualifiedName()
     {
-      dataverseName = nameComponents.first;
+      namespace = nameComponents.first;
       datasetName = nameComponents.second;
     }
   <USING> adapterName = AdapterName() properties = Configuration()
@@ -2881,7 +2903,7 @@
     }
   )?
     {
-      LoadStatement stmt = new LoadStatement(dataverseName, datasetName.getValue(), adapterName, properties,
+      LoadStatement stmt = new LoadStatement(namespace, datasetName.getValue(), adapterName, properties,
         alreadySorted);
       return addSourceLocation(stmt, startToken);
     }
@@ -2902,7 +2924,7 @@
 {
   Token startToken = null;
   Statement stmt = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
 }
 {
   <ANALYZE> { startToken = token; } DatasetToken() nameComponents = QualifiedName()
@@ -2915,7 +2937,7 @@
   }
 }
 
-Statement AnalyzeDatasetStatement(Token startToken, DataverseName dvName, Identifier identifier) throws ParseException:
+Statement AnalyzeDatasetStatement(Token startToken, Namespace namespace, Identifier identifier) throws ParseException:
 {
   RecordConstructor withRecord = null;
 }
@@ -2923,7 +2945,7 @@
   ( <WITH> withRecord = RecordConstructor() )?
   {
     try {
-    AnalyzeStatement stmt = new AnalyzeStatement(dvName, identifier.getValue(), withRecord);
+    AnalyzeStatement stmt = new AnalyzeStatement(namespace, identifier.getValue(), withRecord);
     return addSourceLocation(stmt, startToken);
     } catch (CompilationException e) {
        throw new SqlppParseException(getSourceLocation(startToken), e.getMessage());
@@ -2931,13 +2953,13 @@
   }
 }
 
-Statement AnalyzeDatasetDropStatement(Token startToken, DataverseName dvName, Identifier identifier) throws ParseException:
+Statement AnalyzeDatasetDropStatement(Token startToken, Namespace namespace, Identifier identifier) throws ParseException:
 {
 }
 {
   <DROP> <IDENTIFIER> { expectToken(STATISTICS); }
   {
-    AnalyzeDropStatement stmt = new AnalyzeDropStatement(dvName, identifier.getValue());
+    AnalyzeDropStatement stmt = new AnalyzeDropStatement(namespace, identifier.getValue());
     return addSourceLocation(stmt, startToken);
   }
 }
@@ -2945,7 +2967,7 @@
 Statement CompactStatement() throws ParseException:
 {
   Token startToken = null;
-  Pair<DataverseName,Identifier> nameComponents = null;
+  Pair<Namespace,Identifier> nameComponents = null;
 }
 {
   <COMPACT> { startToken = token; } Dataset() nameComponents = QualifiedName()
@@ -2974,7 +2996,7 @@
 
 Statement StartStatement(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> feedNameComponents = null;
+  Pair<Namespace,Identifier> feedNameComponents = null;
   AbstractStatement stmt = null;
 }
 {
@@ -2987,7 +3009,7 @@
 
 AbstractStatement StopStatement(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> feedNameComponents = null;
+  Pair<Namespace,Identifier> feedNameComponents = null;
   AbstractStatement stmt = null;
 }
 {
@@ -3000,8 +3022,8 @@
 
 AbstractStatement DisconnectStatement(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> feedNameComponents = null;
-  Pair<DataverseName,Identifier> datasetNameComponents = null;
+  Pair<Namespace,Identifier> feedNameComponents = null;
+  Pair<Namespace,Identifier> datasetNameComponents = null;
 
   AbstractStatement stmt = null;
 }
@@ -3019,8 +3041,8 @@
 
 AbstractStatement ConnectStatement(Token startStmtToken) throws ParseException:
 {
-  Pair<DataverseName,Identifier> feedNameComponents = null;
-  Pair<DataverseName,Identifier> datasetNameComponents = null;
+  Pair<Namespace,Identifier> feedNameComponents = null;
+  Pair<Namespace,Identifier> datasetNameComponents = null;
 
   Map<String,String> configuration = null;
   List<FunctionSignature> appliedFunctions = new ArrayList<FunctionSignature>();
@@ -3255,7 +3277,7 @@
 
 TypeReferenceExpression TypeReference() throws ParseException:
 {
-  Pair<DataverseName,Identifier> id = null;
+  Pair<Namespace,Identifier> id = null;
 }
 {
   id = QualifiedName()
@@ -3331,11 +3353,12 @@
       result.function = suffix;
     }
     if (ln > 1) {
-      result.dataverse = createDataverseName(list, 0, ln - 1, startToken);
+      result.namespace = createNamespace(list, 0, ln - 1, startToken);
     } else {
-      result.dataverse = defaultDataverse;
+      result.namespace = defaultNamespace;
     }
-    result.database = MetadataUtil.databaseFor(result.dataverse);
+    result.dataverse = result.namespace == null ? null : result.namespace.getDataverseName();
+    result.database = result.namespace == null ? null : result.namespace.getDatabaseName();
 
     if (result.function.equalsIgnoreCase(INT_TYPE_NAME)) {
        result.function = BuiltinType.AINT64.getTypeName();
@@ -3344,15 +3367,15 @@
   }
 }
 
-Pair<DataverseName,Identifier> TypeName() throws ParseException:
+Pair<Namespace,Identifier> TypeName() throws ParseException:
 {
-  Pair<DataverseName,Identifier> name = null;
+  Pair<Namespace,Identifier> name = null;
 }
 {
   name = QualifiedName()
     {
       if (name.first == null) {
-        name.first = defaultDataverse;
+        name.first = defaultNamespace;
       }
       return name;
     }
@@ -3620,6 +3643,19 @@
   }
 }
 
+Namespace Namespace() throws ParseException:
+{
+  Triple<List<String>, Token, Token> ident = null;
+}
+{
+  ident = MultipartIdentifier()
+  {
+    List<String> list = ident.first;
+    Token startToken = ident.second;
+    return createNamespace(list, startToken);
+  }
+}
+
 DataverseName DataverseName() throws ParseException:
 {
   Triple<List<String>, Token, Token> ident = null;
@@ -3633,7 +3669,7 @@
   }
 }
 
-Pair<DataverseName,Identifier> QualifiedName() throws ParseException:
+Pair<Namespace,Identifier> QualifiedName() throws ParseException:
 {
   Triple<List<String>, Token, Token> ident = null;
 }
@@ -3643,13 +3679,13 @@
     List<String> list = ident.first;
     Token startToken = ident.second;
     int len = list.size();
-    DataverseName id1 = len > 1 ? createDataverseName(list, 0, len - 1, startToken) : null;
+    Namespace id1 = len > 1 ? createNamespace(list, 0, len - 1, startToken) : null;
     Identifier id2 = new Identifier(list.get(len - 1));
-    return new Pair<DataverseName,Identifier>(id1, id2);
+    return new Pair<Namespace,Identifier>(id1, id2);
   }
 }
 
-Triple<DataverseName, Identifier, Identifier> DoubleQualifiedName() throws ParseException:
+Triple<Namespace, Identifier, Identifier> DoubleQualifiedName() throws ParseException:
 {
   List<String> list = new ArrayList<String>();
   String item = null;
@@ -3660,10 +3696,10 @@
   (<DOT> item = Identifier() { list.add(item); } )+
   {
     int len = list.size();
-    DataverseName id1 = len > 2 ? createDataverseName(list, 0, len - 2, startToken) : null;
+    Namespace id1 = len > 2 ? createNamespace(list, 0, len - 2, startToken) : null;
     Identifier id2 = new Identifier(list.get(len - 2));
     Identifier id3 = new Identifier(list.get(len - 1));
-    return new Triple<DataverseName,Identifier,Identifier>(id1, id2, id3);
+    return new Triple<Namespace,Identifier,Identifier>(id1, id2, id3);
   }
 }
 
diff --git a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/bootstrap/MetadataBuiltinEntities.java b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/bootstrap/MetadataBuiltinEntities.java
index 8f79f0c..7b33682 100644
--- a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/bootstrap/MetadataBuiltinEntities.java
+++ b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/bootstrap/MetadataBuiltinEntities.java
@@ -20,6 +20,7 @@
 
 import org.apache.asterix.common.metadata.MetadataConstants;
 import org.apache.asterix.common.metadata.MetadataUtil;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.metadata.entities.Database;
 import org.apache.asterix.metadata.entities.Datatype;
 import org.apache.asterix.metadata.entities.Dataverse;
@@ -48,6 +49,10 @@
             new Datatype(MetadataConstants.SYSTEM_DATABASE, MetadataConstants.METADATA_DATAVERSE_NAME,
                     RecordUtil.FULLY_OPEN_RECORD_TYPE.getTypeName(), RecordUtil.FULLY_OPEN_RECORD_TYPE, false);
 
+    public static final Namespace DEFAULT_NAMESPACE =
+            new Namespace(MetadataBuiltinEntities.DEFAULT_DATAVERSE.getDatabaseName(),
+                    MetadataBuiltinEntities.DEFAULT_DATAVERSE.getDataverseName());
+
     private MetadataBuiltinEntities() {
     }
 }
diff --git a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/declared/MetadataProvider.java b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/declared/MetadataProvider.java
index f37e79e..a5e7f15 100644
--- a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/declared/MetadataProvider.java
+++ b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/declared/MetadataProvider.java
@@ -72,7 +72,6 @@
 import org.apache.asterix.metadata.MetadataManager;
 import org.apache.asterix.metadata.MetadataTransactionContext;
 import org.apache.asterix.metadata.api.ICCExtensionManager;
-import org.apache.asterix.metadata.bootstrap.MetadataBuiltinEntities;
 import org.apache.asterix.metadata.dataset.hints.DatasetHints.DatasetCardinalityHint;
 import org.apache.asterix.metadata.entities.Dataset;
 import org.apache.asterix.metadata.entities.DatasourceAdapter;
@@ -180,7 +179,7 @@
     private final LockList locks;
     private final Map<String, Object> config;
 
-    private Dataverse defaultDataverse;
+    private Namespace defaultNamespace;
     private MetadataTransactionContext mdTxnCtx;
     private boolean isWriteTransaction;
     private FileSplit outputFile;
@@ -195,11 +194,19 @@
     private final INamespaceResolver namespaceResolver;
     private IDataFormat dataFormat = FormatUtils.getDefaultFormat();
 
-    public static MetadataProvider create(ICcApplicationContext appCtx, Dataverse defaultDataverse) {
+    public static MetadataProvider createWithDefaultNamespace(ICcApplicationContext appCtx) {
         java.util.function.Function<ICcApplicationContext, IMetadataProvider<?, ?>> factory =
                 ((ICCExtensionManager) appCtx.getExtensionManager()).getMetadataProviderFactory();
         MetadataProvider mp = factory != null ? (MetadataProvider) factory.apply(appCtx) : new MetadataProvider(appCtx);
-        mp.setDefaultDataverse(defaultDataverse);
+        mp.setDefaultNamespace(MetadataConstants.DEFAULT_NAMESPACE);
+        return mp;
+    }
+
+    public static MetadataProvider create(ICcApplicationContext appCtx, Namespace defaultNamespace) {
+        java.util.function.Function<ICcApplicationContext, IMetadataProvider<?, ?>> factory =
+                ((ICCExtensionManager) appCtx.getExtensionManager()).getMetadataProviderFactory();
+        MetadataProvider mp = factory != null ? (MetadataProvider) factory.apply(appCtx) : new MetadataProvider(appCtx);
+        mp.setDefaultNamespace(defaultNamespace);
         return mp;
     }
 
@@ -212,6 +219,7 @@
         dataPartitioningProvider = (DataPartitioningProvider) appCtx.getDataPartitioningProvider();
         locks = new LockList();
         config = new HashMap<>();
+        setDefaultNamespace(MetadataConstants.DEFAULT_NAMESPACE);
     }
 
     @SuppressWarnings("unchecked")
@@ -251,20 +259,12 @@
         this.txnId = txnId;
     }
 
-    public void setDefaultDataverse(Dataverse defaultDataverse) {
-        this.defaultDataverse = defaultDataverse == null ? MetadataBuiltinEntities.DEFAULT_DATAVERSE : defaultDataverse;
+    public void setDefaultNamespace(Namespace namespace) {
+        this.defaultNamespace = namespace == null ? MetadataConstants.DEFAULT_NAMESPACE : namespace;
     }
 
-    public Dataverse getDefaultDataverse() {
-        return defaultDataverse;
-    }
-
-    public String getDefaultDatabase() {
-        return defaultDataverse.getDatabaseName();
-    }
-
-    public DataverseName getDefaultDataverseName() {
-        return defaultDataverse.getDataverseName();
+    public Namespace getDefaultNamespace() {
+        return defaultNamespace;
     }
 
     public void setWriteTransaction(boolean writeTransaction) {
@@ -344,17 +344,16 @@
         return storageProperties;
     }
 
-    private DataverseName getActiveDataverseName(DataverseName dataverseName) {
-        return dataverseName != null ? dataverseName
-                : defaultDataverse != null ? defaultDataverse.getDataverseName() : null;
-    }
-
     /**
      * Retrieve the Output RecordType, as defined by "set output-record-type".
      */
     public ARecordType findOutputRecordType() throws AlgebricksException {
-        String database = defaultDataverse == null ? null : defaultDataverse.getDatabaseName();
-        DataverseName dataverseName = defaultDataverse == null ? null : defaultDataverse.getDataverseName();
+        String database = null;
+        DataverseName dataverseName = null;
+        if (defaultNamespace != null) {
+            database = defaultNamespace.getDatabaseName();
+            dataverseName = defaultNamespace.getDataverseName();
+        }
         return MetadataManagerUtil.findOutputRecordType(mdTxnCtx, database, dataverseName,
                 getProperty("output-record-type"));
     }
@@ -369,11 +368,11 @@
         String dbName = database;
         DataverseName dvName = dataverseName;
         if (dbName == null && dvName == null) {
-            if (defaultDataverse == null) {
+            if (defaultNamespace == null) {
                 return null;
             }
-            dbName = defaultDataverse.getDatabaseName();
-            dvName = defaultDataverse.getDataverseName();
+            dbName = defaultNamespace.getDatabaseName();
+            dvName = defaultNamespace.getDataverseName();
         } else if (dbName == null || dvName == null) {
             return null;
         }
@@ -477,11 +476,11 @@
         String dbName = databaseName;
         DataverseName dvName = dataverseName;
         if (dbName == null && dvName == null) {
-            if (defaultDataverse == null) {
+            if (defaultNamespace == null) {
                 return null;
             }
-            dbName = defaultDataverse.getDatabaseName();
-            dvName = defaultDataverse.getDataverseName();
+            dbName = defaultNamespace.getDatabaseName();
+            dvName = defaultNamespace.getDataverseName();
         } else if (dbName == null || dvName == null) {
             return null;
         }
diff --git a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/entitytupletranslators/FunctionTupleTranslator.java b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/entitytupletranslators/FunctionTupleTranslator.java
index 309decb..8191212 100644
--- a/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/entitytupletranslators/FunctionTupleTranslator.java
+++ b/asterixdb/asterix-metadata/src/main/java/org/apache/asterix/metadata/entitytupletranslators/FunctionTupleTranslator.java
@@ -266,7 +266,7 @@
             }
         }
 
-        return new TypeSignature(typeDataverseName, typeName);
+        return new TypeSignature(typeDatabaseName, typeDataverseName, typeName);
     }
 
     private Map<String, String> getResources(ARecord functionRecord, String resourcesFieldName) {
diff --git a/asterixdb/asterix-om/src/main/java/org/apache/asterix/om/types/TypeSignature.java b/asterixdb/asterix-om/src/main/java/org/apache/asterix/om/types/TypeSignature.java
index e08eff5..a61136f 100644
--- a/asterixdb/asterix-om/src/main/java/org/apache/asterix/om/types/TypeSignature.java
+++ b/asterixdb/asterix-om/src/main/java/org/apache/asterix/om/types/TypeSignature.java
@@ -22,22 +22,23 @@
 import java.util.Objects;
 
 import org.apache.asterix.common.metadata.DataverseName;
-import org.apache.asterix.common.metadata.MetadataUtil;
 
 public class TypeSignature implements Serializable {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 2L;
 
+    private final String databaseName;
     private final DataverseName dataverseName;
     private final String name;
 
-    public TypeSignature(DataverseName dataverseName, String name) {
+    public TypeSignature(String databaseName, DataverseName dataverseName, String name) {
+        this.databaseName = databaseName;
         this.dataverseName = dataverseName;
         this.name = name;
     }
 
     public TypeSignature(BuiltinType builtinType) {
-        this(null, builtinType.getTypeName());
+        this(null, null, builtinType.getTypeName());
     }
 
     @Override
@@ -46,8 +47,8 @@
             return false;
         } else {
             TypeSignature f = ((TypeSignature) o);
-            return Objects.equals(getDatabaseName(), f.getDatabaseName())
-                    && Objects.equals(dataverseName, f.getDataverseName()) && name.equals(f.getName());
+            return Objects.equals(databaseName, f.databaseName) && Objects.equals(dataverseName, f.getDataverseName())
+                    && name.equals(f.getName());
         }
     }
 
@@ -58,11 +59,11 @@
 
     @Override
     public int hashCode() {
-        return Objects.hash(getDatabaseName(), dataverseName, name);
+        return Objects.hash(databaseName, dataverseName, name);
     }
 
     public String getDatabaseName() {
-        return MetadataUtil.databaseFor(dataverseName);
+        return databaseName;
     }
 
     public DataverseName getDataverseName() {
diff --git a/asterixdb/asterix-tools/src/test/java/org/apache/asterix/tools/translator/ADGenDmlTranslator.java b/asterixdb/asterix-tools/src/test/java/org/apache/asterix/tools/translator/ADGenDmlTranslator.java
index 07a7234..f155161 100644
--- a/asterixdb/asterix-tools/src/test/java/org/apache/asterix/tools/translator/ADGenDmlTranslator.java
+++ b/asterixdb/asterix-tools/src/test/java/org/apache/asterix/tools/translator/ADGenDmlTranslator.java
@@ -24,6 +24,7 @@
 
 import org.apache.asterix.common.annotations.TypeDataGen;
 import org.apache.asterix.common.metadata.DataverseName;
+import org.apache.asterix.common.metadata.Namespace;
 import org.apache.asterix.lang.common.base.Statement;
 import org.apache.asterix.lang.common.statement.DataverseDecl;
 import org.apache.asterix.lang.common.statement.TypeDecl;
@@ -47,19 +48,27 @@
     }
 
     public void translate() throws AlgebricksException {
-        DataverseName defaultDataverse = getDefaultDataverse();
+        Namespace defaultNs = getDefaultDataverse();
+        DataverseName defaultDv = null;
+        String defaultDb = null;
+        if (defaultNs != null) {
+            defaultDv = defaultNs.getDataverseName();
+            defaultDb = defaultNs.getDatabaseName();
+        }
         types = new HashMap<>();
         typeDataGenMap = new HashMap<>();
 
         for (Statement stmt : statements) {
             if (stmt.getKind() == Statement.Kind.TYPE_DECL) {
                 TypeDecl td = (TypeDecl) stmt;
-                DataverseName typeDataverse = td.getDataverseName() == null ? defaultDataverse : td.getDataverseName();
+                DataverseName typeDataverse =
+                        td.getNamespace() == null ? defaultDv : td.getNamespace().getDataverseName();
+                String typeDatabaseName = td.getNamespace() == null ? defaultDb : td.getNamespace().getDatabaseName();
 
-                TypeTranslator.computeTypes(typeDataverse, td.getIdent().getValue(), td.getTypeDef(), defaultDataverse,
-                        mdTxnCtx, types);
+                TypeTranslator.computeTypes(typeDatabaseName, typeDataverse, td.getIdent().getValue(), td.getTypeDef(),
+                        defaultDb, defaultDv, mdTxnCtx, types);
 
-                TypeSignature signature = new TypeSignature(typeDataverse, td.getIdent().getValue());
+                TypeSignature signature = new TypeSignature(typeDatabaseName, typeDataverse, td.getIdent().getValue());
                 TypeDataGen tdg = td.getDatagenAnnotation();
                 if (tdg != null) {
                     typeDataGenMap.put(signature, tdg);
@@ -68,10 +77,10 @@
         }
     }
 
-    private DataverseName getDefaultDataverse() {
+    private Namespace getDefaultDataverse() {
         for (Statement stmt : statements) {
             if (stmt.getKind() == Statement.Kind.DATAVERSE_DECL) {
-                return ((DataverseDecl) stmt).getDataverseName();
+                return ((DataverseDecl) stmt).getNamespace();
             }
         }
         return null;