Dp/namespace

edb/edgeql-parser/src/keywords.rs

@@ -20,6 +20,7 @@ pub const UNRESERVED_KEYWORDS: &[&str] = &[
     "cube",
     "current",
     "database",
+    "namespace",
     "ddl",
     "declare",
     "default",
@@ -99,6 +100,8 @@ pub const UNRESERVED_KEYWORDS: &[&str] = &[
     "version",
     "view",
     "write",
+    "use",
+    "show",
 ];
 
 

edb/edgeql/ast.py

@@ -226,6 +226,10 @@ class SessionResetAllAliases(BaseSessionReset):
     pass
 
 
+class UseNameSpaceCommand(BaseSessionCommand):
+    name: str
+
+
 class BaseObjectRef(Base):
     __abstract_node__ = True
 
@@ -836,6 +840,20 @@ class DropDatabase(DropObject, DatabaseCommand):
     pass
 
 
+class NameSpaceCommand(ExternalObjectCommand):
+    __abstract_node__ = True
+    object_class: qltypes.SchemaObjectClass = (
+        qltypes.SchemaObjectClass.NAMESPACE)
+
+
+class CreateNameSpace(CreateObject, NameSpaceCommand):
+    pass
+
+
+class DropNameSpace(DropObject, NameSpaceCommand):
+    pass
+
+
 class ExtensionPackageCommand(GlobalObjectCommand):
     __abstract_node__ = True
     object_class: qltypes.SchemaObjectClass = (

edb/edgeql/codegen.py

@@ -1033,6 +1033,12 @@ def visit_AlterDatabase(self, node: qlast.AlterDatabase) -> None:
     def visit_DropDatabase(self, node: qlast.DropDatabase) -> None:
         self._visit_DropObject(node, 'DATABASE')
 
+    def visit_CreateNameSpace(self, node: qlast.CreateNameSpace) -> None:
+        self._visit_CreateObject(node, 'NAMESPACE')
+
+    def visit_DropNameSpace(self, node: qlast.DropNameSpace) -> None:
+        self._visit_DropObject(node, 'NAMESPACE')
+
     def visit_CreateRole(self, node: qlast.CreateRole) -> None:
         after_name = lambda: self._ddl_visit_bases(node)
         keywords = []
@@ -2185,6 +2191,13 @@ def visit_SessionResetAliasDecl(
         self._write_keywords('RESET ALIAS ')
         self.write(node.alias)
 
+    def visit_UseNameSpaceCommand(
+        self,
+        node: qlast.UseNameSpaceCommand
+    ) -> None:
+        self._write_keywords('USE NAMESPACE ')
+        self.write(node.name)
+
     def visit_StartTransaction(self, node: qlast.StartTransaction) -> None:
         self._write_keywords('START TRANSACTION')
 

edb/edgeql/parser/grammar/ddl.py

@@ -56,6 +56,9 @@ class DDLStmt(Nonterm):
     def reduce_DatabaseStmt(self, *kids):
         self.val = kids[0].val
 
+    def reduce_NameSpaceStmt(self, *kids):
+        self.val = kids[0].val
+
     def reduce_RoleStmt(self, *kids):
         self.val = kids[0].val
 
@@ -665,6 +668,38 @@ def reduce_DROP_DATABASE_DatabaseName(self, *kids):
         self.val = qlast.DropDatabase(name=kids[2].val)
 
 
+#
+# NAMESPACE
+#
+class NameSpaceStmt(Nonterm):
+
+    def reduce_CreateNameSpaceStmt(self, *kids):
+        self.val = kids[0].val
+
+    def reduce_DropNameSpaceStmt(self, *kids):
+        self.val = kids[0].val
+
+
+class CreateNameSpaceStmt(Nonterm):
+    def reduce_CREATE_NAMESPACE_Identifier(self, *kids):
+        self.val = qlast.CreateNameSpace(
+            name=qlast.ObjectRef(
+                module=None,
+                name=kids[2].val
+            )
+        )
+
+
+class DropNameSpaceStmt(Nonterm):
+    def reduce_DROP_NAMESPACE_Identifier(self, *kids):
+        self.val = qlast.DropNameSpace(
+            name=qlast.ObjectRef(
+                module=None,
+                name=kids[2].val
+            )
+        )
+
+
 #
 # EXTENSION PACKAGE
 #

edb/edgeql/parser/grammar/session.py

@@ -18,9 +18,7 @@
 
 from __future__ import annotations
 
-from edb.edgeql import ast as qlast
-
-from .expressions import Nonterm
+from edb.pgsql import common as pg_common
 from .tokens import *  # NOQA
 from .expressions import *  # NOQA
 
@@ -32,6 +30,12 @@ def reduce_SetStmt(self, *kids):
     def reduce_ResetStmt(self, *kids):
         self.val = kids[0].val
 
+    def reduce_UseNameSpaceStmt(self, *kids):
+        self.val = kids[0].val
+
+    def reduce_ShowNameSpaceStmt(self, *kids):
+        self.val = kids[0].val
+
 
 class SetStmt(Nonterm):
     def reduce_SET_ALIAS_Identifier_AS_MODULE_ModuleName(self, *kids):
@@ -54,3 +58,15 @@ def reduce_RESET_MODULE(self, *kids):
 
     def reduce_RESET_ALIAS_STAR(self, *kids):
         self.val = qlast.SessionResetAllAliases()
+
+
+class UseNameSpaceStmt(Nonterm):
+    def reduce_USE_NAMESPACE_Identifier(self, *kids):
+        self.val = qlast.UseNameSpaceCommand(name=kids[2].val)
+
+
+class ShowNameSpaceStmt(Nonterm):
+    def reduce_SHOW_NAMESPACE(self, *kids):
+        self.val = qlast.SelectQuery(
+            result=qlast.StringConstant(value=pg_common.NAMESPACE)
+        )

edb/edgeql/qltypes.py

@@ -237,6 +237,7 @@ class SchemaObjectClass(s_enum.StrEnum):
     SCALAR_TYPE = 'SCALAR TYPE'
     TUPLE_TYPE = 'TUPLE TYPE'
     TYPE = 'TYPE'
+    NAMESPACE = 'NAMESPACE'
 
 
 class LinkTargetDeleteAction(s_enum.StrEnum):

edb/errors/__init__.py

@@ -213,6 +213,10 @@ class UnknownParameterError(InvalidReferenceError):
     _code = 0x_04_03_00_06
 
 
+class UnknownSchemaError(InvalidReferenceError):
+    _code = 0x_04_03_00_07
+
+
 class SchemaError(QueryError):
     _code = 0x_04_04_00_00
 
@@ -309,6 +313,10 @@ class DuplicateCastDefinitionError(DuplicateDefinitionError):
     _code = 0x_04_05_02_0A
 
 
+class DuplicateNameSpaceDefinitionError(DuplicateDefinitionError):
+    _code = 0x_04_05_02_0B
+
+
 class SessionTimeoutError(QueryError):
     _code = 0x_04_06_00_00
 

edb/graphql/compiler.py

@@ -30,7 +30,7 @@
 
 
 GQLCoreCache: Dict[
-    str,
+    Tuple[str, str],
     Dict[
         (s_schema.FlatSchema, uuid.UUID, s_schema.FlatSchema, str),
         graphql.GQLCoreSchema
@@ -40,19 +40,20 @@
 
 def _get_gqlcore(
     dbname: str,
+    namespace: str,
     std_schema: s_schema.FlatSchema,
     user_schema: s_schema.FlatSchema,
     global_schema: s_schema.FlatSchema,
     module: str = None
 ) -> graphql.GQLCoreSchema:
     key = (std_schema, user_schema.version_id, global_schema, module)
-    if cache := GQLCoreCache.get(dbname):
+    if cache := GQLCoreCache.get((dbname, namespace)):
         if key in cache:
             return cache[key]
         else:
             cache.clear()
     else:
-        cache = GQLCoreCache.setdefault(dbname, {})
+        cache = GQLCoreCache.setdefault((dbname, namespace), {})
 
     core = graphql.GQLCoreSchema(
         s_schema.ChainedSchema(
@@ -68,6 +69,7 @@ def _get_gqlcore(
 
 def compile_graphql(
     dbname: str,
+    namespace: str,
     std_schema: s_schema.FlatSchema,
     user_schema: s_schema.FlatSchema,
     global_schema: s_schema.FlatSchema,
@@ -88,7 +90,7 @@ def compile_graphql(
     else:
         ast = graphql.parse_tokens(gql, tokens)
 
-    gqlcore = _get_gqlcore(dbname, std_schema, user_schema, global_schema, module)
+    gqlcore = _get_gqlcore(dbname, namespace, std_schema, user_schema, global_schema, module)
 
     return graphql.translate_ast(
         gqlcore,

edb/graphql/extension.pyx

@@ -97,6 +97,7 @@ async def handle_request(
     globals = None
     query = None
     module = None
+    namespace = edbdef.DEFAULT_NS
     limit = 0
 
     try:
@@ -111,6 +112,7 @@ async def handle_request(
                 variables = body.get('variables')
                 module = body.get('module')
                 limit = body.get('limit', 0)
+                namespace = body.get('namespace', edbdef.DEFAULT_NS)
                 globals = body.get('globals')
             elif request.content_type == 'application/graphql':
                 query = request.body.decode('utf-8')
@@ -157,6 +159,12 @@ async def handle_request(
                 else:
                     limit = 0
 
+                namespace = qs.get('namespace')
+                if namespace is not None:
+                    namespace = namespace[0]
+                else:
+                    namespace = edbdef.DEFAULT_NS
+
         else:
             raise TypeError('expected a GET or a POST request')
 
@@ -186,7 +194,7 @@ async def handle_request(
     response.content_type = b'application/json'
     try:
         result = await _execute(
-            db, server, query,
+            db, namespace, server, query,
             operation_name, variables, globals,
             query_only, module or None, limit
         )
@@ -216,6 +224,7 @@ async def handle_request(
 
 async def compile(
     db,
+    ns,
     server,
     query: str,
     tokens: Optional[List[Tuple[int, int, int, str]]],
@@ -229,9 +238,10 @@ async def compile(
     compiler_pool = server.get_compiler_pool()
     return await compiler_pool.compile_graphql(
         db.name,
-        db.user_schema,
+        ns.name,
+        ns.user_schema,
         server.get_global_schema(),
-        db.reflection_cache,
+        ns.reflection_cache,
         db.db_config,
         server.get_compilation_system_config(),
         query,
@@ -246,9 +256,17 @@ async def compile(
 
 
 async def _execute(
-    db, server, query, operation_name, variables,
+    db, namespace, server, query, operation_name, variables,
     globals, query_only, module, limit
 ):
+
+    if namespace not in db.ns_map:
+        raise errors.QueryError(
+            f'NameSpace: [{namespace}] not in current db [{db.name}](ver:{db.dbver}).'
+            f'Current NameSpace(s): [{", ".join(db.ns_map.keys())}]'
+        )
+    ns = db.ns_map[namespace]
+
     dbver = db.dbver
     query_cache = server._http_query_cache
 
@@ -298,7 +316,7 @@ async def _execute(
             print(f'key_vars: {key_var_names}')
             print(f'variables: {vars}')
 
-    cache_key = ('graphql', prepared_query, key_vars, operation_name, dbver, query_only, module, limit)
+    cache_key = ('graphql', prepared_query, key_vars, operation_name, dbver, query_only, namespace, module, limit)
     use_prep_stmt = False
 
     entry: CacheEntry = None
@@ -307,13 +325,14 @@ async def _execute(
 
     if isinstance(entry, CacheRedirect):
         key_vars2 = tuple(vars[k] for k in entry.key_vars)
-        cache_key2 = (prepared_query, key_vars2, operation_name, dbver, query_only, module, limit)
+        cache_key2 = (prepared_query, key_vars2, operation_name, dbver, query_only, namespace, module, limit)
         entry = query_cache.get(cache_key2, None)
 
     if entry is None:
         if rewritten is not None:
             qug, gql_op = await compile(
                 db,
+                ns,
                 server,
                 query,
                 rewritten.tokens(gql_lexer.TokenKind),
@@ -327,6 +346,7 @@ async def _execute(
         else:
             qug, gql_op = await compile(
                 db,
+                ns,
                 server,
                 query,
                 None,
@@ -349,7 +369,7 @@ async def _execute(
             query_cache[cache_key] = redir
             key_vars2 = tuple(vars[k] for k in key_var_names)
             cache_key2 = (
-                'graphql', prepared_query, key_vars2, operation_name, dbver, query_only, module, limit
+                'graphql', prepared_query, key_vars2, operation_name, dbver, query_only, namespace, module, limit
             )
             query_cache[cache_key2] = qug, gql_op
             if gql_op.is_introspection:
@@ -372,7 +392,7 @@ async def _execute(
     dbv = await server.new_dbview(
         dbname=db.name,
         query_cache=False,
-        protocol_version=edbdef.CURRENT_PROTOCOL,
+        protocol_version=edbdef.CURRENT_PROTOCOL
     )
 
     pgcon = await server.acquire_pgcon(db.name)

edb/ir/ast.py

@@ -162,6 +162,8 @@ class TypeRef(ImmutableBase):
     is_opaque_union: bool = False
     # True, if this describes an sequnce type
     is_sequence: bool = False
+    # True, if this contains enums
+    has_enum: bool = False
 
     def __repr__(self) -> str:
         return f'<ir.TypeRef \'{self.name_hint}\' at 0x{id(self):x}>'