From 87f437380c1dd8f420437cddc028c0f3174ee1c9 Mon Sep 17 00:00:00 2001
From: Matthias Baumgartner <dev@igsor.net>
Date: Thu, 2 Mar 2023 12:19:58 +0100
Subject: Node getters in bsfs.Graph:

* Empty nodes instance (Graph.empty)
* Order-preserving get query (Graph.sorted)
* Collect common code in private Graph.__get
* Empty query in Graph.get
* Empty query in Graph.resolve.Filter
* Empty query in AC: filter_read
---
 bsfs/graph/graph.py | 60 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 44 insertions(+), 16 deletions(-)

(limited to 'bsfs/graph/graph.py')

diff --git a/bsfs/graph/graph.py b/bsfs/graph/graph.py
index a356533..11fe835 100644
--- a/bsfs/graph/graph.py
+++ b/bsfs/graph/graph.py
@@ -113,6 +113,7 @@ class Graph():
         *node_type*) once some data is assigned to them.
 
         """
+        # get node type
         type_ = self.schema.node(node_type)
         # NOTE: Nodes constructor materializes guids.
         return _nodes.Nodes(self._backend, self._ac, type_, guids)
@@ -120,15 +121,51 @@ class Graph():
     def node(self, node_type: URI, guid: URI) -> _nodes.Nodes:
         """Return node *guid* of type *node_type* as a `bsfs.graph.Nodes` instance.
 
-        Note that the *guids* need not to exist (however, the *node_type* has
+        Note that the *guid* need not to exist (however, the *node_type* has
         to be part of the schema). An inexistent guid will be created (using
         *node_type*) once some data is assigned to them.
 
         """
         return self.nodes(node_type, {guid})
 
-    def get(self, node_type: URI, query: ast.filter.FilterExpression) -> _nodes.Nodes: # FIXME: How about empty query?
-        """Return a `Nodes` instance over all nodes of type *node_type* that match the *subject* query."""
+    def empty(self, node_type: URI) -> _nodes.Nodes:
+        """Return a `Nodes` instance with type *node_type* but no nodes."""
+        return self.nodes(node_type, set())
+
+    def get(
+            self,
+            node_type: URI,
+            query: typing.Optional[ast.filter.FilterExpression],
+            ) -> _nodes.Nodes:
+        """Return a `Nodes` instance over all nodes of type *node_type* that match the *query*."""
+        # return Nodes instance
+        type_ = self.schema.node(node_type)
+        return _nodes.Nodes(self._backend, self._ac, type_, self.__get(node_type, query))
+
+    def sorted(
+            self,
+            node_type: URI,
+            query: typing.Optional[ast.filter.FilterExpression],
+            # FIXME: sort ast
+            ) -> typing.Iterator[_nodes.Nodes]:
+        """Return a iterator over `Nodes` instances over all nodes of type *node_type* that match the *query*."""
+        # FIXME: Order should be a parameter
+        # return iterator over Nodes instances
+        type_ = self.schema.node(node_type)
+        for guid in self.__get(node_type, query):
+            yield _nodes.Nodes(self._backend, self._ac, type_, {guid})
+
+    def all(self, node_type: URI) -> _nodes.Nodes:
+        """Return all instances of type *node_type*."""
+        type_ = self.schema.node(node_type)
+        return _nodes.Nodes(self._backend, self._ac, type_, self.__get(node_type, None))
+
+    def __get(
+            self,
+            node_type: URI,
+            query: typing.Optional[ast.filter.FilterExpression],
+            ) -> typing.Iterator[URI]:
+        """Build and execute a get query."""
         # get node type
         type_ = self.schema.node(node_type)
         # resolve Nodes instances
@@ -136,18 +173,9 @@ class Graph():
         # add access controls to query
         query = self._ac.filter_read(type_, query)
         # validate query
-        self._validate(type_, query)
-        # query the backend
-        guids = self._backend.get(type_, query) # no need to materialize
-        # return Nodes instance
-        return _nodes.Nodes(self._backend, self._ac, type_, guids)
-
-    def all(self, node_type: URI) -> _nodes.Nodes:
-        """Return all instances of type *node_type*."""
-        # get node type
-        type_ = self.schema.node(node_type)
-        guids = self._backend.get(type_, None) # no need to materialize
-        return _nodes.Nodes(self._backend, self._ac, type_, guids)
-
+        if query is not None:
+            self._validate(type_, query)
+        # query the backend and return the (non-materialized) result
+        return self._backend.get(type_, query)
 
 ## EOF ##
-- 
cgit v1.2.3