@lde/pipeline-void 0.37.0 → 0.37.1

package/dist/stage.js

@@ -119,7 +119,7 @@ export function subjectUriSpaces(options) {
 export function classPartitions(options) {
     return createVoidStage(VOID_STAGE_NAMES.classPartitions, options);
 }
-// Scalar-aggregate counts: each query is a single COUNT with no GROUP BY/HAVING,
+// Scalar-aggregate counts: each query ends in one COUNT without GROUP BY/HAVING,
 // so it always returns exactly one row. Zero output therefore means the endpoint
 // truncated the response, so they set `expectsOutput` to fail (and trigger the
 // reactive dump fallback) rather than store a missing count.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline-void",
-  "version": "0.37.0",
+  "version": "0.37.1",
   "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -29,11 +29,11 @@
     "@rdfjs/types": "^2.0.1",
     "@tpluscode/rdf-ns-builders": "^5.0.0",
     "@zazuko/prefixes": "^2.6.1",
-    "n3": "^2.7.12",
+    "n3": "^2.13.12",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
     "@lde/dataset": "^0.8.0",
-    "@lde/pipeline": "^0.38.0"
+    "@lde/pipeline": "^0.38.1"
   }
 }

package/queries/object-literals.rq

@@ -6,9 +6,14 @@ CONSTRUCT {
         void-ext:distinctLiterals ?distinctLiterals .
 }
 WHERE {
-    SELECT (COUNT(DISTINCT ?o) AS ?distinctLiterals) {
-        #subjectFilter#
-        ?s ?p ?o .
-        FILTER(ISLITERAL(?o))
+    # Count groups instead of COUNT(DISTINCT): QLever then needs far less memory,
+    # and Fuseki and Virtuoso are as fast. A DISTINCT subquery ran Fuseki out of memory.
+    SELECT (COUNT(*) AS ?distinctLiterals) {
+        SELECT ?o {
+            #subjectFilter#
+            ?s ?p ?o .
+            FILTER(ISLITERAL(?o))
+        }
+        GROUP BY ?o
     }
 }

package/queries/object-uris.rq

@@ -6,9 +6,14 @@ CONSTRUCT {
         void-ext:distinctIRIReferenceObjects ?distinctIRIReferenceObjects .
 }
 WHERE {
-    SELECT (COUNT(DISTINCT ?o) AS ?distinctIRIReferenceObjects) {
-        #subjectFilter#
-        ?s ?p ?o .
-        FILTER(ISIRI(?o))
+    # Count groups instead of COUNT(DISTINCT): QLever then needs far less memory,
+    # and Fuseki and Virtuoso are as fast.
+    SELECT (COUNT(*) AS ?distinctIRIReferenceObjects) {
+        SELECT ?o {
+            #subjectFilter#
+            ?s ?p ?o .
+            FILTER(ISIRI(?o))
+        }
+        GROUP BY ?o
     }
 }

package/queries/subject-uri-space.rq

@@ -10,31 +10,41 @@ WHERE {
     {
         SELECT ?uriSpace (SUM(?groupCount) AS ?count) {
             {
-                # Group subjects by the directory of their document (the IRI without fragment),
-                # keeping hash IRIs apart. MIN = MAX tells whether a hash group holds a single
-                # document, without the cost of COUNT(DISTINCT ?document).
-                SELECT ?directory ?isHash (COUNT(*) AS ?groupCount)
-                    (MIN(?document) AS ?firstDocument) (MAX(?document) AS ?lastDocument) {
+                # Group the keys by directory, keeping hash IRIs apart. The number of keys in a
+                # hash group is the number of documents it holds.
+                SELECT ?directory ?isHash (SUM(?keyCount) AS ?groupCount)
+                    (COUNT(*) AS ?documents) (MIN(?key) AS ?firstKey) {
                     {
-                        # Pre-group distinct subjects before computing namespace to avoid regex on every triple.
-                        SELECT DISTINCT ?s {
-                            #subjectFilter#
-                            ?s ?p ?o .
-                            FILTER(ISIRI(?s))
+                        # Reduce each distinct subject to one key with a single REPLACE: its
+                        # document followed by "#" for a hash IRI, its directory otherwise.
+                        # Grouping on that key first keeps the per-subject strings to one. The
+                        # pattern uses + rather than *, because Virtuoso rejects a pattern that
+                        # matches the empty string; an IRI ending in / is its own key either way.
+                        SELECT ?key (COUNT(*) AS ?keyCount) {
+                            {
+                                SELECT DISTINCT ?s {
+                                    #subjectFilter#
+                                    ?s ?p ?o .
+                                    FILTER(ISIRI(?s))
+                                }
+                            }
+                            BIND(REPLACE(STR(?s), "(#).*$|[^/#]+$", "$1") AS ?key)
                         }
+                        GROUP BY ?key
                     }
-                    BIND(STR(?s) AS ?iri)
-                    BIND(CONTAINS(?iri, "#") AS ?isHash)
-                    BIND(IF(?isHash, STRBEFORE(?iri, "#"), ?iri) AS ?document)
-                    BIND(REPLACE(?document, "[^/]*$", "") AS ?prefix)
-                    # A document without path (http://host, urn:…) is its own directory.
-                    BIND(IF(?prefix = "" || STRENDS(?prefix, "//"), ?document, ?prefix) AS ?directory)
+                    BIND(STRENDS(?key, "#") AS ?isHash)
+                    BIND(IF(?isHash, REPLACE(?key, "[^/]*#$", ""), ?key) AS ?prefix)
+                    # A subject without hash and without path (http://host, urn:…) is a URI
+                    # space of its own with one entity, which the count filter below drops.
+                    FILTER(?isHash || (?prefix != "" && !STRENDS(?prefix, "//")))
+                    # A hash document without path is its own directory.
+                    BIND(IF(?prefix = "" || STRENDS(?prefix, "//"), STRBEFORE(?key, "#"), ?prefix) AS ?directory)
                 }
                 GROUP BY ?directory ?isHash
             }
             # A hash vocabulary (…/skos/core#) keeps its document as namespace; hash IRIs spread
             # over several documents (…/record1#media, …/record2#media) share their directory.
-            BIND(IF(?isHash && ?firstDocument = ?lastDocument, CONCAT(?firstDocument, "#"), ?directory) AS ?uriSpace)
+            BIND(IF(?isHash && ?documents = 1, ?firstKey, ?directory) AS ?uriSpace)
         }
         GROUP BY ?uriSpace
         ORDER BY DESC(?count)
@@ -43,4 +53,3 @@ WHERE {
     FILTER(?count > 1)  # Only include namespaces with more than 1 entity
     BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#subject-uri-space-", MD5(?uriSpace))) AS ?subset)
 }
-

package/queries/subjects.rq

@@ -5,9 +5,14 @@ CONSTRUCT {
         void:distinctSubjects ?count .
 }
 WHERE {
-    SELECT (COUNT(DISTINCT ?s) as ?count) {
-        #subjectFilter#
-        ?s ?p ?o .
-        FILTER(!ISBLANK(?s))
+    # Count groups instead of COUNT(DISTINCT): QLever then needs far less memory,
+    # Virtuoso half the time, and Fuseki is as fast.
+    SELECT (COUNT(*) AS ?count) {
+        SELECT ?s {
+            #subjectFilter#
+            ?s ?p ?o .
+            FILTER(!ISBLANK(?s))
+        }
+        GROUP BY ?s
     }
 }