iris-vector-graph 1.59.2__tar.gz → 1.60.0__tar.gz

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.59.2
+Version: 1.60.0
 Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
 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
@@ -655,6 +655,17 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.60.0 (2026-04-24)
+
+Four openCypher gaps closed, all from structured gap analysis against the openCypher grammar spec:
+
+- feat: `WHERE n:Label` predicate — `MATCH (n) WHERE n:Gene AND n.id = 'x'` now works; translates to `EXISTS (SELECT 1 FROM rdf_labels WHERE label = ?)` (spec 068)
+- feat: Map literal expressions — `RETURN {id: n.id, score: 0.9} AS obj` translates to `JSON_OBJECT(...)` (spec 069)
+- feat: `WITH agg-alias HAVING filter` — `WITH n, count(r) AS cnt WHERE cnt > 2` now emits SQL `HAVING cnt > 2` correctly; was `ValueError: Undefined: cnt` (spec 070)
+- feat: Subscript/slice/property-access postfix — `list[n]`, `list[start..end]`, `expr.key` on any expression; translates to `JSON_ARRAYGET`, `JSON_ARRAY_SLICE`, `JSON_VALUE` (spec 071)
+- fix: `DELETE r` by relationship variable now emits `WHERE (s,p,o_id) IN (SELECT ...)` instead of broken correlated subquery (spec 071)
+
+
 ### v1.59.2 (2026-04-24)
 - fix: Cypher `WHERE x IN $param` and `WHERE x IN [list]` now correctly emit `IN (?,?,?)` — previously emitted `IN ?` which IRIS DBAPI can't expand. Enables batch multi-node queries like `MATCH (a)-[r]-(b) WHERE a.id IN $node_ids RETURN ...` (20× speedup for 2-hop expansion vs N sequential queries).
 

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/README.md

@@ -583,6 +583,17 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.60.0 (2026-04-24)
+
+Four openCypher gaps closed, all from structured gap analysis against the openCypher grammar spec:
+
+- feat: `WHERE n:Label` predicate — `MATCH (n) WHERE n:Gene AND n.id = 'x'` now works; translates to `EXISTS (SELECT 1 FROM rdf_labels WHERE label = ?)` (spec 068)
+- feat: Map literal expressions — `RETURN {id: n.id, score: 0.9} AS obj` translates to `JSON_OBJECT(...)` (spec 069)
+- feat: `WITH agg-alias HAVING filter` — `WITH n, count(r) AS cnt WHERE cnt > 2` now emits SQL `HAVING cnt > 2` correctly; was `ValueError: Undefined: cnt` (spec 070)
+- feat: Subscript/slice/property-access postfix — `list[n]`, `list[start..end]`, `expr.key` on any expression; translates to `JSON_ARRAYGET`, `JSON_ARRAY_SLICE`, `JSON_VALUE` (spec 071)
+- fix: `DELETE r` by relationship variable now emits `WHERE (s,p,o_id) IN (SELECT ...)` instead of broken correlated subquery (spec 071)
+
+
 ### v1.59.2 (2026-04-24)
 - fix: Cypher `WHERE x IN $param` and `WHERE x IN [list]` now correctly emit `IN (?,?,?)` — previously emitted `IN ?` which IRIS DBAPI can't expand. Enables batch multi-node queries like `MATCH (a)-[r]-(b) WHERE a.id IN $node_ids RETURN ...` (20× speedup for 2-hop expansion vs N sequential queries).
 

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/iris_vector_graph/cypher/ast.py

@@ -198,6 +198,36 @@ class WhereClause:
     expression: BooleanExpression
 
 
+@dataclass(slots=True)
+class LabelPredicate:
+    variable: str
+    label: str
+
+
+@dataclass(slots=True)
+class MapLiteral:
+    entries: dict
+
+
+@dataclass(slots=True)
+class SubscriptExpression:
+    expression: Any
+    index: Any
+
+
+@dataclass(slots=True)
+class SliceExpression:
+    expression: Any
+    start: Any
+    end: Any
+
+
+@dataclass(slots=True)
+class PropertyAccessExpression:
+    expression: Any
+    property_name: str
+
+
 @dataclass(slots=True)
 class MatchClause:
     """MATCH clause with one or more patterns"""

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/iris_vector_graph/cypher/parser.py

@@ -802,11 +802,42 @@ class Parser:
             self.eat()
             exp = self.parse_power_expression()
             return ast.FunctionCall(function_name="__arith_^", arguments=[base, exp])
+        while self.peek().kind in (TokenType.LBRACKET, TokenType.DOT):
+            if self.peek().kind == TokenType.LBRACKET:
+                self.eat()
+                if self.peek().kind == TokenType.DOT and self.lexer.peek_ahead(1).kind == TokenType.DOT:
+                    self.eat()
+                    self.eat()
+                    end = self.parse_primary_expression()
+                    self.expect(TokenType.RBRACKET)
+                    base = ast.SliceExpression(expression=base, start=ast.Literal(0), end=end)
+                else:
+                    first = self.parse_primary_expression()
+                    if self.peek().kind == TokenType.DOT and self.lexer.peek_ahead(1).kind == TokenType.DOT:
+                        self.eat()
+                        self.eat()
+                        second = self.parse_primary_expression()
+                        self.expect(TokenType.RBRACKET)
+                        base = ast.SliceExpression(expression=base, start=first, end=second)
+                    else:
+                        self.expect(TokenType.RBRACKET)
+                        base = ast.SubscriptExpression(expression=base, index=first)
+            elif self.peek().kind == TokenType.DOT:
+                self.eat()
+                prop_tok = self.expect(TokenType.IDENTIFIER)
+                base = ast.PropertyAccessExpression(
+                    expression=base, property_name=prop_tok.value or ""
+                )
         return base
 
     def parse_comparison_expression(self) -> Any:
         left = self.parse_additive_expression()
 
+        if isinstance(left, ast.Variable) and self.peek().kind == TokenType.COLON:
+            self.eat()
+            label_tok = self.expect(TokenType.IDENTIFIER)
+            return ast.LabelPredicate(variable=left.name, label=label_tok.value or "")
+
         # Binary comparisons
         tok = self.peek()
         op = None
@@ -873,6 +904,12 @@ class Parser:
             self.expect(TokenType.RPAREN)
             return expr
 
+        if tok.kind == TokenType.LBRACE:
+            self.eat()
+            entries = self.parse_map_literal()
+            self.expect(TokenType.RBRACE)
+            return ast.MapLiteral(entries=entries)
+
         if tok.kind == TokenType.IDENTIFIER:
             name = self.eat().value
             if name is None:

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/iris_vector_graph/cypher/translator.py

@@ -149,6 +149,7 @@ class TranslationContext:
         self.from_clauses: List[str] = []
         self.join_clauses: List[str] = []
         self.where_conditions: List[str] = []
+        self.having_conditions: List[str] = []
         self.group_by_items: List[str] = []
 
         self.select_params: List[Any] = []
@@ -228,6 +229,8 @@ class TranslationContext:
             parts.append(f"WHERE {' AND '.join(self.where_conditions)}")
         if self.group_by_items:
             parts.append(f"GROUP BY {', '.join(self.group_by_items)}")
+        if self.having_conditions:
+            parts.append(f"HAVING {' AND '.join(self.having_conditions)}")
         sql = "\n".join(parts)
         params = (
             (self.select_params if not select_override else [])
@@ -1354,9 +1357,12 @@ def translate_delete_clause(delete, context, metadata):
                 subparams,
             )
         else:
+            subquery_spo, subparams_spo = context.build_stage_sql(
+                select_override=f"SELECT {alias}.s, {alias}.p, {alias}.o_id"
+            )
             context.add_dml(
-                f"DELETE FROM {_table('rdf_edges')} WHERE s = (SELECT s FROM {_table('rdf_edges')} {alias}) AND p = (SELECT p FROM {_table('rdf_edges')} {alias}) AND o_id = (SELECT o_id FROM {_table('rdf_edges')} {alias})",
-                [],
+                f"DELETE FROM {_table('rdf_edges')} WHERE (s, p, o_id) IN ({subquery_spo})",
+                subparams_spo,
             )
 
 
@@ -1999,6 +2005,15 @@ def translate_boolean_expression(expr, context) -> str:
             prefix = "NOT " if expr.negated else ""
             return f"{prefix}EXISTS ({sub})"
         return "1=1"
+    if isinstance(expr, ast.LabelPredicate):
+        alias = context.variable_aliases.get(expr.variable)
+        node_col = f"{alias}.node_id" if alias else "node_id"
+        labels_tbl = _table("rdf_labels")
+        safe_label = context.add_where_param(expr.label)
+        return (
+            f"EXISTS (SELECT 1 FROM {labels_tbl} _lp WHERE _lp.s = {node_col}"
+            f" AND _lp.label = {safe_label})"
+        )
     if not isinstance(expr, ast.BooleanExpression):
         return translate_expression(expr, context, segment="where")
     op = expr.operator
@@ -2343,6 +2358,28 @@ def translate_expression(expr, context, segment="select") -> str:
             f'LEFT JOIN {_table("rdf_props")} {p_alias} ON {p_alias}.s = {alias}.node_id AND {p_alias}."key" = {context.add_join_param(expr.property_name)}'
         )
         return f"{p_alias}.val"
+    if isinstance(expr, ast.MapLiteral):
+        if not expr.entries:
+            return "JSON_OBJECT()"
+        parts = []
+        for k, v in expr.entries.items():
+            key_sql = f"'{k}'"
+            val_sql = translate_expression(v, context, segment=segment)
+            parts.append(f"{key_sql}, {val_sql}")
+        return f"JSON_OBJECT({', '.join(parts)})"
+    if isinstance(expr, ast.SubscriptExpression):
+        base_sql = translate_expression(expr.expression, context, segment=segment)
+        idx_sql = translate_expression(expr.index, context, segment=segment)
+        return f"JSON_ARRAYGET({base_sql}, {idx_sql})"
+    if isinstance(expr, ast.SliceExpression):
+        base_sql = translate_expression(expr.expression, context, segment=segment)
+        start_sql = translate_expression(expr.start, context, segment=segment)
+        end_sql = translate_expression(expr.end, context, segment=segment)
+        return f"JSON_ARRAY_SLICE({base_sql}, {start_sql}, {end_sql})"
+    if isinstance(expr, ast.PropertyAccessExpression):
+        base_sql = translate_expression(expr.expression, context, segment=segment)
+        prop = expr.property_name.replace("'", "''")
+        return f"JSON_VALUE({base_sql}, '$.{prop}')"
     if isinstance(expr, ast.Variable):
         alias = context.variable_aliases.get(expr.name)
         if not alias:
@@ -2615,6 +2652,7 @@ def translate_with_clause(with_clause, context):
     has_agg = any(
         isinstance(i.expression, ast.AggregationFunction) for i in with_clause.items
     )
+    agg_aliases: set = set()
     for item in with_clause.items:
         sql = translate_expression(item.expression, context, segment="select")
         alias = item.alias
@@ -2630,7 +2668,54 @@ def translate_with_clause(with_clause, context):
         context.select_items.append(f"{sql} AS {alias.replace('.', '_')}")
         if has_agg and not isinstance(item.expression, ast.AggregationFunction):
             context.group_by_items.append(sql)
+        if isinstance(item.expression, ast.AggregationFunction):
+            agg_aliases.add(alias)
     if with_clause.where_clause:
-        context.where_conditions.append(
-            translate_boolean_expression(with_clause.where_clause.expression, context)
-        )
+        expr = with_clause.where_clause.expression
+        if has_agg and agg_aliases and _references_agg_alias(expr, agg_aliases):
+            context.having_conditions.append(
+                _translate_having_expr(expr, agg_aliases, context)
+            )
+        else:
+            context.where_conditions.append(
+                translate_boolean_expression(expr, context)
+            )
+
+
+def _references_agg_alias(expr, agg_aliases: set) -> bool:
+    if isinstance(expr, ast.Variable) and expr.name in agg_aliases:
+        return True
+    if isinstance(expr, ast.BooleanExpression):
+        return any(_references_agg_alias(o, agg_aliases) for o in expr.operands)
+    return False
+
+
+def _translate_having_expr(expr, agg_aliases: set, context) -> str:
+    if isinstance(expr, ast.Variable) and expr.name in agg_aliases:
+        return expr.name
+    if isinstance(expr, ast.BooleanExpression):
+        op = expr.operator
+        if op == ast.BooleanOperator.AND:
+            return "(" + " AND ".join(
+                _translate_having_expr(o, agg_aliases, context) for o in expr.operands
+            ) + ")"
+        if op == ast.BooleanOperator.OR:
+            return "(" + " OR ".join(
+                _translate_having_expr(o, agg_aliases, context) for o in expr.operands
+            ) + ")"
+        if op == ast.BooleanOperator.NOT:
+            return f"NOT ({_translate_having_expr(expr.operands[0], agg_aliases, context)})"
+        left = _translate_having_expr(expr.operands[0], agg_aliases, context)
+        right_expr = expr.operands[1] if len(expr.operands) > 1 else None
+        right = translate_expression(right_expr, context, segment="where") if right_expr is not None else ""
+        op_map = {
+            ast.BooleanOperator.EQUALS: "=",
+            ast.BooleanOperator.NOT_EQUALS: "<>",
+            ast.BooleanOperator.LESS_THAN: "<",
+            ast.BooleanOperator.LESS_THAN_OR_EQUAL: "<=",
+            ast.BooleanOperator.GREATER_THAN: ">",
+            ast.BooleanOperator.GREATER_THAN_OR_EQUAL: ">=",
+        }
+        if op in op_map:
+            return f"{left} {op_map[op]} {right}"
+    return translate_boolean_expression(expr, context)

{iris_vector_graph-1.59.2 → iris_vector_graph-1.60.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.59.2"
+version = "1.60.0"
 description = "Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs"
 readme = "README.md"
 license = "MIT"