iris-vector-graph 4.3.0__tar.gz → 4.4.0__tar.gz

{iris_vector_graph-4.3.0 → iris_vector_graph-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: iris-vector-graph
-Version: 4.3.0
+Version: 4.4.0
 Summary: Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs
@@ -165,22 +165,22 @@ print(result["rows"])  # [['Bob']]
 
 ## What It Does
 
-| Feature                     | Notes                                                                                                                                                                        |
-| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **openCypher**              | `MATCH`, `CREATE`, `MERGE`, `DELETE`, `WITH`, `UNWIND`, variable-length paths, subqueries                                                                                    |
-| **Temporal property graph** | Time-windowed edges, pre-aggregated bucket analytics, O(1) window queries                                                                                                    |
-| **Vector search**           | HNSW (native IRIS VECTOR), IVFFlat, PLAID multi-vector, BM25 full-text                                                                                                       |
-| **Graph analytics**         | Betweenness, closeness, eigenvector, degree centrality; Leiden community detection; SCC; k-core; PPR                                                                         |
-| **Shortest path**           | Unweighted BFS (`shortestPath`), weighted Dijkstra (`ivg.shortestPath.weighted`)                                                                                             |
-| **Native Cypher**           | Supported reads, most variable-length included, run inside IRIS over `^KG` (on by default); openCypher TCK 3896/3896; shadow mode holds each native answer to the SQL path's |
-| **Bulk loader**             | Writes rows, 6–14K edges/s ([chunk sizes](docs/OPERATIONS.md#bulk-ingest-choose-a-chunk-size)); `^KG` follows via the adjacency index; incremental `^NKG` rebuild            |
-| **FHIR graph**              | An ISC FHIR repository as a named graph; concept → resource → patient ranking ([guide](docs/FHIR_GRAPH.md))                                                                  |
-| **Bolt protocol**           | neo4j-driver compatible wire protocol (TCP + WebSocket)                                                                                                                      |
-| **Embedded Python**         | Graph algorithms run server-side via IRIS embedded Python (igraph, leidenalg)                                                                                                |
-| **IPM / ZPM**               | ObjectScript-only install via InterSystems Package Manager                                                                                                                   |
-| **RDF export**              | `export_rdf()` — full or filtered graph to Turtle/NT/NQuads/JSON-LD                                                                                                          |
-| **SHACL validation**        | `validate_shacl()` — SHACL Core via PySHACL; `ValidationReport` dataclass                                                                                                    |
-| **PROV-O**                  | `prov_export()` — temporal edges as W3C PROV-O provenance graph                                                                                                              |
+| Feature                     | Notes                                                                                                                                                                            |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **openCypher**              | `MATCH`, `CREATE`, `MERGE`, `DELETE`, `WITH`, `UNWIND`, variable-length paths, subqueries                                                                                        |
+| **Temporal property graph** | Time-windowed edges, pre-aggregated bucket analytics, O(1) window queries                                                                                                        |
+| **Vector search**           | HNSW (native IRIS VECTOR), IVFFlat, PLAID multi-vector, BM25 full-text                                                                                                           |
+| **Graph analytics**         | Betweenness, closeness, eigenvector, degree centrality; Leiden community detection; SCC; k-core; PPR                                                                             |
+| **Shortest path**           | Unweighted BFS (`shortestPath`), weighted Dijkstra (`ivg.shortestPath.weighted`)                                                                                                 |
+| **Native Cypher**           | Supported reads, most variable-length included, run inside IRIS over `^KG` (on by default), a read with hops as a class compiled for its shape (4.4.0); openCypher TCK 3896/3896 |
+| **Bulk loader**             | Writes rows, 6–14K edges/s ([chunk sizes](docs/OPERATIONS.md#bulk-ingest-choose-a-chunk-size)); `^KG` follows via the adjacency index; incremental `^NKG` rebuild                |
+| **FHIR graph**              | An ISC FHIR repository as a named graph; concept → resource → patient ranking ([guide](docs/FHIR_GRAPH.md))                                                                      |
+| **Bolt protocol**           | neo4j-driver compatible wire protocol (TCP + WebSocket)                                                                                                                          |
+| **Embedded Python**         | Graph algorithms run server-side via IRIS embedded Python (igraph, leidenalg)                                                                                                    |
+| **IPM / ZPM**               | ObjectScript-only install via InterSystems Package Manager                                                                                                                       |
+| **RDF export**              | `export_rdf()` — full or filtered graph to Turtle/NT/NQuads/JSON-LD                                                                                                              |
+| **SHACL validation**        | `validate_shacl()` — SHACL Core via PySHACL; `ValidationReport` dataclass                                                                                                        |
+| **PROV-O**                  | `prov_export()` — temporal edges as W3C PROV-O provenance graph                                                                                                                  |
 
 ---
 
@@ -202,8 +202,9 @@ Hardware: M3 Ultra, Community IRIS 2026.1, ARM64 Docker.
 | Pre-aggregated bucket (24hr/288 buckets)                                          | 0.16ms    | O(buckets), not O(edges)                |
 
 Against Neo4j and Memgraph on the LDBC Social Network Benchmark at scale factor 10 (AWS `r7g.8xlarge`,
-2026-10-22, native Cypher), IVG's median time over 39 queries is 1.13x Neo4j's and 0.73x Memgraph's
-([report](docs/performance/alt-bench/REPORT_TEMPLATE.md#sf10-on-all-three-engines-aws-2026-10-22)).
+2026-10-23, native Cypher with compiled plans), IVG's median time over 39 queries is 0.90x Neo4j's and 0.57x
+Memgraph's (Memgraph from the previous SF10 run on the same instance type)
+([report](docs/performance/alt-bench/REPORT_TEMPLATE.md#sf10-after-spec-257-aws-2026-10-23)).
 
 ### Algorithm comparison (vs Neo4j GDS and networkx)
 

{iris_vector_graph-4.3.0 → iris_vector_graph-4.4.0}/README.md

@@ -63,22 +63,22 @@ print(result["rows"])  # [['Bob']]
 
 ## What It Does
 
-| Feature                     | Notes                                                                                                                                                                        |
-| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **openCypher**              | `MATCH`, `CREATE`, `MERGE`, `DELETE`, `WITH`, `UNWIND`, variable-length paths, subqueries                                                                                    |
-| **Temporal property graph** | Time-windowed edges, pre-aggregated bucket analytics, O(1) window queries                                                                                                    |
-| **Vector search**           | HNSW (native IRIS VECTOR), IVFFlat, PLAID multi-vector, BM25 full-text                                                                                                       |
-| **Graph analytics**         | Betweenness, closeness, eigenvector, degree centrality; Leiden community detection; SCC; k-core; PPR                                                                         |
-| **Shortest path**           | Unweighted BFS (`shortestPath`), weighted Dijkstra (`ivg.shortestPath.weighted`)                                                                                             |
-| **Native Cypher**           | Supported reads, most variable-length included, run inside IRIS over `^KG` (on by default); openCypher TCK 3896/3896; shadow mode holds each native answer to the SQL path's |
-| **Bulk loader**             | Writes rows, 6–14K edges/s ([chunk sizes](docs/OPERATIONS.md#bulk-ingest-choose-a-chunk-size)); `^KG` follows via the adjacency index; incremental `^NKG` rebuild            |
-| **FHIR graph**              | An ISC FHIR repository as a named graph; concept → resource → patient ranking ([guide](docs/FHIR_GRAPH.md))                                                                  |
-| **Bolt protocol**           | neo4j-driver compatible wire protocol (TCP + WebSocket)                                                                                                                      |
-| **Embedded Python**         | Graph algorithms run server-side via IRIS embedded Python (igraph, leidenalg)                                                                                                |
-| **IPM / ZPM**               | ObjectScript-only install via InterSystems Package Manager                                                                                                                   |
-| **RDF export**              | `export_rdf()` — full or filtered graph to Turtle/NT/NQuads/JSON-LD                                                                                                          |
-| **SHACL validation**        | `validate_shacl()` — SHACL Core via PySHACL; `ValidationReport` dataclass                                                                                                    |
-| **PROV-O**                  | `prov_export()` — temporal edges as W3C PROV-O provenance graph                                                                                                              |
+| Feature                     | Notes                                                                                                                                                                            |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **openCypher**              | `MATCH`, `CREATE`, `MERGE`, `DELETE`, `WITH`, `UNWIND`, variable-length paths, subqueries                                                                                        |
+| **Temporal property graph** | Time-windowed edges, pre-aggregated bucket analytics, O(1) window queries                                                                                                        |
+| **Vector search**           | HNSW (native IRIS VECTOR), IVFFlat, PLAID multi-vector, BM25 full-text                                                                                                           |
+| **Graph analytics**         | Betweenness, closeness, eigenvector, degree centrality; Leiden community detection; SCC; k-core; PPR                                                                             |
+| **Shortest path**           | Unweighted BFS (`shortestPath`), weighted Dijkstra (`ivg.shortestPath.weighted`)                                                                                                 |
+| **Native Cypher**           | Supported reads, most variable-length included, run inside IRIS over `^KG` (on by default), a read with hops as a class compiled for its shape (4.4.0); openCypher TCK 3896/3896 |
+| **Bulk loader**             | Writes rows, 6–14K edges/s ([chunk sizes](docs/OPERATIONS.md#bulk-ingest-choose-a-chunk-size)); `^KG` follows via the adjacency index; incremental `^NKG` rebuild                |
+| **FHIR graph**              | An ISC FHIR repository as a named graph; concept → resource → patient ranking ([guide](docs/FHIR_GRAPH.md))                                                                      |
+| **Bolt protocol**           | neo4j-driver compatible wire protocol (TCP + WebSocket)                                                                                                                          |
+| **Embedded Python**         | Graph algorithms run server-side via IRIS embedded Python (igraph, leidenalg)                                                                                                    |
+| **IPM / ZPM**               | ObjectScript-only install via InterSystems Package Manager                                                                                                                       |
+| **RDF export**              | `export_rdf()` — full or filtered graph to Turtle/NT/NQuads/JSON-LD                                                                                                              |
+| **SHACL validation**        | `validate_shacl()` — SHACL Core via PySHACL; `ValidationReport` dataclass                                                                                                        |
+| **PROV-O**                  | `prov_export()` — temporal edges as W3C PROV-O provenance graph                                                                                                                  |
 
 ---
 
@@ -100,8 +100,9 @@ Hardware: M3 Ultra, Community IRIS 2026.1, ARM64 Docker.
 | Pre-aggregated bucket (24hr/288 buckets)                                          | 0.16ms    | O(buckets), not O(edges)                |
 
 Against Neo4j and Memgraph on the LDBC Social Network Benchmark at scale factor 10 (AWS `r7g.8xlarge`,
-2026-10-22, native Cypher), IVG's median time over 39 queries is 1.13x Neo4j's and 0.73x Memgraph's
-([report](docs/performance/alt-bench/REPORT_TEMPLATE.md#sf10-on-all-three-engines-aws-2026-10-22)).
+2026-10-23, native Cypher with compiled plans), IVG's median time over 39 queries is 0.90x Neo4j's and 0.57x
+Memgraph's (Memgraph from the previous SF10 run on the same instance type)
+([report](docs/performance/alt-bench/REPORT_TEMPLATE.md#sf10-after-spec-257-aws-2026-10-23)).
 
 ### Algorithm comparison (vs Neo4j GDS and networkx)
 

{iris_vector_graph-4.3.0 → iris_vector_graph-4.4.0}/iris_src/src/Graph/KG/Cypher/Exec.cls

@@ -21,6 +21,13 @@ ClassMethod PlanVersion() As %Integer
 	Quit ..#PLANVERSION
 }
 
+/// When this class was compiled: part of the stamp of every plan compiled against it (Graph.KG.Cypher.Gen).
+ClassMethod BuiltAt() As %String [ CodeMode = objectgenerator ]
+{
+	Do %code.WriteLine(" Quit """_$ZDateTime($ZTimestamp, 3, 1, 6)_"""")
+	Quit $$$OK
+}
+
 /// Run pPlan (JSON) with pParams (JSON object); returns Head's {"tag", "count"[, "rows"]}.
 ClassMethod Run(pPlan As %String, pParams As %String = "{}") As %String
 {
@@ -142,6 +149,22 @@ ClassMethod RunA(pPlan As %DynamicObject, pTag As %Integer, Output pWorkers As %
 	}
 	// the node the shares are split on: no two workers bind it to the same node
 	Set tQ("splitvar") = $Case(tQ("split"), "scan": tAnchor, "vl": $List(tQ("h", 1), 2), : "")
+	// a walk of one hop or more compiled to a class of its own (spec 257), whose Walk1 replaces Walk from the first
+	// hop; a worker runs in its coordinator's mode. A process that cannot record the shape (a role that may only
+	// read the database, a read-only database) is interpreted: the read must not fail for the cache's sake
+	Set tQ("genmode") = pPlan.%Get("genmode")
+	Try {
+		Set tGen = ##class(Graph.KG.Cypher.Gen).For(.tQ, tAnchor)
+	} Catch tEx {
+		// logged by the coordinator (a worker repeats its error), once a process for each kind of error
+		Set tGen = ""
+		If (pShare = "") && '$Data(^||IVG.CypherGenFailed(tEx.Name)) {
+			Set ^||IVG.CypherGenFailed(tEx.Name) = 1
+			Do ##class(%SYS.System).WriteToConsoleLog("IVG native plans not compiled in this process, interpreted instead: "_tEx.DisplayString(), 0, 1)
+		}
+	}
+	// counted for the tests (spec 257): which runs walked compiled
+	Do:tGen'="" $Increment(^||IVG.CypherCompiledRuns)
 	// ^||IVG.CypherRun: the walk's scratch (candidates, distinct keys, the sort tree), killed before and after
 	Kill ^||IVG.CypherRun
 	Set tSpec = pPlan.%Get("nodes").%Get(tAnchor)
@@ -169,7 +192,13 @@ ClassMethod RunA(pPlan As %DynamicObject, pTag As %Integer, Output pWorkers As %
 			Continue:'..NodeOK(.tQ, tAnchor, tKey, tGName, tS)
 			Kill tB
 			Set tB(tAnchor) = tS, tQ("accw") = 0
-			If tAcc0 { Set tQ("accw") = 1 } Else { Do ..Walk(.tQ, 1, tKey, tGName, .tB, ",") }
+			If tAcc0 {
+				Set tQ("accw") = 1
+			} ElseIf tGen '= "" {
+				Do $ClassMethod(tGen, "Walk1", .tQ, tKey, tGName, .tB)
+			} Else {
+				Do ..Walk(.tQ, 1, tKey, tGName, .tB, ",")
+			}
 			// every match of this anchor falls in one group: Emit summed them into tQ("accw"), grouped once here
 			Do:tQ("acc")&&(tQ("accw")>0) ..Group(.tQ, tGName, .tB, tQ("accw"))
 		}
@@ -222,13 +251,22 @@ ClassMethod RunA(pPlan As %DynamicObject, pTag As %Integer, Output pWorkers As %
 						}
 						Kill tB
 						Set tB(tAnchor) = tS, tQ("accw") = 0
-						If tAcc0 { Set tQ("accw") = 1 } Else { Do ..Walk(.tQ, 1, g, tGName, .tB, ",") }
+						If tAcc0 {
+							Set tQ("accw") = 1
+						} ElseIf tGen '= "" {
+							Do $ClassMethod(tGen, "Walk1", .tQ, g, tGName, .tB)
+						} Else {
+							Do ..Walk(.tQ, 1, g, tGName, .tB, ",")
+						}
 						Do:tQ("acc")&&(tQ("accw")>0) ..Group(.tQ, tGName, .tB, tQ("accw"))
 					}
 				}
 			}
 		}
 	}
+	// a worker's compiled-walk count(DISTINCT) members, kept in the run's arrays, go where Export reads them; nothing
+	// else reads them (EmitGroups reads the counts), so a run with no share leaves them (BI04: 75 ms to move them)
+	Do:(pShare'="")&&$Data(tQ("cgd")) ..SpillDistinct(.tQ)
 	If (pShare '= "") && tQ("agg") {
 		Do ..Export(.tQ, pShare)
 	} ElseIf tQ("agg") {
@@ -413,6 +451,7 @@ ClassMethod Parallel(pPlan As %DynamicObject, pLabel As %String, ByRef pQ, pSpli
 	Kill ^IRIS.Temp.IVG.Cypher(tShare)
 	// the workers run the plan as this process chose it: its anchor and the label it scans
 	Do pPlan.%Set("alts", ##class(%Library.DynamicArray).%New()), pPlan.%Set("scan_label", pLabel), pPlan.%Set("split", pSplit)
+	Do pPlan.%Set("genmode", ##class(Graph.KG.Cypher.Gen).ModeOf(.pQ))
 	If pSplit = "scan" {
 		// one graph key scanned: each worker gets key ranges of the label (Bounds, RunA), not every tN-th member of all of it
 		Set tScoped = (pPlan.%GetTypeOf("graph") = "string")
@@ -903,7 +942,7 @@ ClassMethod SortKey(pGName As %String, pS As %String, pKey As %String, pVal As %
 {
 	Set tNode = $ListBuild(pGName, pS, pKey)
 	Quit:$Data(^||IVG.CypherRun("sk", tNode), tK) tK
-	Set tK = ##class(User.funcCYSORTKEY).CYSORTKEY(pVal, "x"), ^||IVG.CypherRun("sk", tNode) = tK
+	Set tK = ##class(Graph.KG.Cypher.SortKey).Key(pVal, "x"), ^||IVG.CypherRun("sk", tNode) = tK
 	Quit tK
 }
 
@@ -1086,7 +1125,7 @@ ClassMethod GroupCount(ByRef pQ, pN As %Integer) [ Private ]
 	}
 }
 
-/// Whether node pI of the chain is checked for nothing: no label, property, comparison, cross filter or id, and not
+/// Whether node pI of the chain is checked for nothing (Graph.KG.Cypher.Gen.Unchecked keeps a copy in step): no label, property, comparison, cross filter or id, and not
 /// bound already (a hop closing a cycle on it).
 ClassMethod Unchecked(ByRef pQ, pI As %Integer, ByRef pB) As %Boolean [ Private ]
 {
@@ -1231,6 +1270,53 @@ ClassMethod Seen(ByRef pQ, pJSON As %String) As %Boolean [ Private ]
 /// Add one match to its group: ^||IVG.CypherRun("g", group) = the keys' JSON, or for a short key $Char(1) and its
 /// values (KeysJSON); ("g", group, j) = aggregate j.
 ClassMethod Group(ByRef pQ, pGName As %String, ByRef pB, pW As %Integer = 1) [ Private ]
+{
+	Set tG = ..GroupOf(.pQ, pGName, .pB)
+	Set tAggs = pQ("aggs")
+	For tJ = 1:1:$ListLength(tAggs) {
+		Set tA = $List(tAggs, tJ), tW = pW
+		If $List(tA, 1) = "count_distinct" {
+			// a node is (graph, id): one subscript holding both, which needs no stand-in for the default graph's ""
+			Set tNode = $ListBuild(pGName, pB($List(tA, 2))), tW = 1
+			Continue:$Data(^||IVG.CypherRun("gd", tG, tJ, tNode))
+			Set ^||IVG.CypherRun("gd", tG, tJ, tNode) = ""
+		}
+		Do $Increment(^||IVG.CypherRun("g", tG, tJ), tW)
+	}
+}
+
+/// Move a compiled walk's count(DISTINCT) members (Graph.KG.Cypher.Gen: pQ("cgd", group, j, graph subscript, node))
+/// to Group's own ^||IVG.CypherRun("gd", group, j, $ListBuild(graph, node)), which spills to IRISTEMP: once the run's
+/// arrays hold 200,000 of them, and before Export reads them. From then on the walk adds members there (pQ("cgds")).
+ClassMethod SpillDistinct(ByRef pQ) [ Private ]
+{
+	Set tG = ""
+	For {
+		Set tG = $Order(pQ("cgd", tG))
+		Quit:tG=""
+		Set tJ = ""
+		For {
+			Set tJ = $Order(pQ("cgd", tG, tJ))
+			Quit:tJ=""
+			Set tK = ""
+			For {
+				Set tK = $Order(pQ("cgd", tG, tJ, tK))
+				Quit:tK=""
+				Set tGName = $Select(tK = $Char(0): "", 1: tK), tN = ""
+				For {
+					Set tN = $Order(pQ("cgd", tG, tJ, tK, tN))
+					Quit:tN=""
+					Set ^||IVG.CypherRun("gd", tG, tJ, $ListBuild(tGName, tN)) = ""
+				}
+			}
+		}
+	}
+	Kill pQ("cgd"), pQ("cgdn")
+	Set pQ("cgds") = 1
+}
+
+/// The group one match falls in (Group's, and a compiled walk's, Graph.KG.Cypher.Gen).
+ClassMethod GroupOf(ByRef pQ, pGName As %String, ByRef pB) As %Integer [ Private ]
 {
 	// the group is a function of the nodes its keys read: projected once per such binding, not once per match;
 	// with no key, one group for the whole query, remembered in pQ("g0")
@@ -1273,17 +1359,7 @@ ClassMethod Group(ByRef pQ, pGName As %String, ByRef pB, pW As %Integer = 1) [ P
 			Set:pQ("hops")>0 ^||IVG.CypherRun("gc", tSig) = tG
 		}
 	}
-	Set tAggs = pQ("aggs")
-	For tJ = 1:1:$ListLength(tAggs) {
-		Set tA = $List(tAggs, tJ), tW = pW
-		If $List(tA, 1) = "count_distinct" {
-			// a node is (graph, id): one subscript holding both, which needs no stand-in for the default graph's ""
-			Set tNode = $ListBuild(pGName, pB($List(tA, 2))), tW = 1
-			Continue:$Data(^||IVG.CypherRun("gd", tG, tJ, tNode))
-			Set ^||IVG.CypherRun("gd", tG, tJ, tNode) = ""
-		}
-		Do $Increment(^||IVG.CypherRun("g", tG, tJ), tW)
-	}
+	Quit tG
 }
 
 /// A label scan with no hop whose matches are only counted, grouped by the scanned node's properties (BI01's shape),
@@ -1483,8 +1559,7 @@ ClassMethod EmitGroups(ByRef pQ) [ Private ]
 				Set tSub(tJ) = +$Get(^||IVG.CypherRun("g", tG, tI + 1))
 				Continue
 			}
-			Set:tKeys="" tKeys = ##class(%Library.DynamicArray).%FromJSON(..KeysJSON(.pQ, tKeyJSON))
-			Set tSub(tJ) = ##class(User.funcCYSORTKEY).CYSORTKEY($Select(tKeys.%GetTypeOf(tI) = "null": "", 1: tKeys.%Get(tI)), "x")
+			Set tSub(tJ) = ##class(Graph.KG.Cypher.SortKey).Key(..KeyValue(.pQ, tKeyJSON, tI, .tKeys), "x")
 		}
 		Set tSeq = $Increment(pQ("seq")), tEntry = $ListBuild("g", tG)
 		If tN = 1 {
@@ -1507,6 +1582,24 @@ ClassMethod EmitGroups(ByRef pQ) [ Private ]
 /// A group's keys as JSON, the form Project makes, from what Group stored: the JSON itself, or $Char(1) and the keys'
 /// values as KeyValues lists them (a node as $ListBuild(graph, id), a substring "s" and its text, a missing value an
 /// empty element), which keep a number a number and a string a string.
+/// Key pI (0-based) of a group stored as pStored (Group's form: JSON, or $Char(1) and the keys' $List), as the value
+/// KeysJSON's row holds there ("" for null): for a stored $List read from it, with no JSON made and parsed again
+/// (BI04's 11,802 groups: half its time), else from the parsed row, kept in pKeys for the group's other keys.
+ClassMethod KeyValue(ByRef pQ, pStored As %String, pI As %Integer, ByRef pKeys) As %String [ Private ]
+{
+	// only Group stores the $List form, with pQ("ret") its keys (a second stage's groups are JSON: Stage2)
+	Set tItem = $Select($Extract(pStored) = $Char(1): $List(pQ("ret"), pI + 1), 1: "")
+	If (tItem '= "") && ($List(tItem, 2) '= "__node") {
+		Set tVals = $Extract(pStored, 2, *)
+		Quit:'$ListData(tVals,pI+1) ""
+		// a substring key is stored marked as a string ("s" and its value)
+		Quit:$ListGet(tItem,3)'="" $Extract($List(tVals, pI + 1), 2, *)
+		Quit $List(tVals, pI + 1)
+	}
+	Set:'$IsObject($Get(pKeys)) pKeys = ##class(%Library.DynamicArray).%FromJSON(..KeysJSON(.pQ, pStored))
+	Quit $Select(pKeys.%GetTypeOf(pI) = "null": "", 1: pKeys.%Get(pI))
+}
+
 ClassMethod KeysJSON(ByRef pQ, pStored As %String) As %String [ Private ]
 {
 	Quit:$Extract(pStored)'=$Char(1) pStored
@@ -1561,7 +1654,7 @@ ClassMethod OrderKey(ByRef pQ, pGName As %String, ByRef pB, pJ As %Integer) As %
 {
 	Set tItem = $List(pQ("ord"), pJ)
 	Set tVal = ##class(Graph.KG.Cypher.Props).Get(pGName, pB($List(tItem, 1)), $List(tItem, 2), .tFound)
-	Quit ##class(User.funcCYSORTKEY).CYSORTKEY($Select(tFound: tVal, 1: ""), "x")
+	Quit ##class(Graph.KG.Cypher.SortKey).Key($Select(tFound: tVal, 1: ""), "x")
 }
 
 /// Cut the sort tree back to its first pQ("limit") rows in the order EmitSorted writes them. A later match only files