iris-vector-graph 1.78.0__tar.gz → 1.80.0__tar.gz

{iris_vector_graph-1.78.0 → iris_vector_graph-1.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.78.0
+Version: 1.80.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

{iris_vector_graph-1.78.0 → iris_vector_graph-1.80.0}/iris_vector_graph/cypher/ast.py

@@ -56,11 +56,13 @@ class NodePattern:
     """
     Node pattern in MATCH clause.
     Example: (p:Protein {id: 'PROTEIN:TP53'})
+    labels_or: when True, labels use OR semantics (:A|B), else AND (:A:B)
     """
 
     variable: Optional[str] = None
     labels: List[str] = field(default_factory=list)
     properties: Dict[str, Any] = field(default_factory=dict)
+    labels_or: bool = False
 
 
 @dataclass(slots=True)
@@ -451,6 +453,7 @@ class ReduceExpression:
 class ExistsExpression:
     pattern: "GraphPattern"
     negated: bool = False
+    where_condition: Optional[Any] = None
 
 
 @dataclass(slots=True)

{iris_vector_graph-1.78.0 → iris_vector_graph-1.80.0}/iris_vector_graph/cypher/parser.py

@@ -116,12 +116,14 @@ class Parser:
             self.peek().kind == TokenType.IDENTIFIER
             and self.peek().value
             and self.peek().value.upper() == "USE"
-            and self.lexer.peek_ahead(1).kind == TokenType.IDENTIFIER
-            and self.lexer.peek_ahead(1).value
-            and self.lexer.peek_ahead(1).value.upper() == "GRAPH"
         ):
             self.eat()
-            self.eat()
+            if (
+                self.peek().kind == TokenType.IDENTIFIER
+                and self.peek().value
+                and self.peek().value.upper() == "GRAPH"
+            ):
+                self.eat()
             graph_name_tok = self.peek()
             if graph_name_tok.kind == TokenType.STRING_LITERAL:
                 graph_context = self.eat().value
@@ -213,7 +215,7 @@ class Parser:
         while self.peek().kind in _QUERY_STARTERS or (
             self.peek().kind == TokenType.IDENTIFIER
             and self.peek().value
-            and self.peek().value.upper() in ("OPTIONAL", "USE")
+            and self.peek().value.upper() == "OPTIONAL"
         ) or self.peek().kind == TokenType.WHERE or self.peek().kind == TokenType.RETURN:
             if self.peek().kind == TokenType.WHERE:
                 self.eat()
@@ -300,10 +302,25 @@ class Parser:
                 and tok.value
                 and tok.value.upper() == "OPTIONAL"
             ):
-                # Check for OPTIONAL MATCH
-                self.eat()  # OPTIONAL
-                self.expect(TokenType.MATCH)
-                clauses.append(self.parse_match_clause(optional=True))
+                self.eat()
+                if self.peek().kind == TokenType.MATCH:
+                    self.expect(TokenType.MATCH)
+                    clauses.append(self.parse_match_clause(optional=True))
+                elif (
+                    self.peek().kind == TokenType.CALL
+                    and self.lexer.peek_ahead(1).kind == TokenType.LBRACE
+                ):
+                    subq = self.parse_subquery_call()
+                    subq_optional = ast.SubqueryCall(
+                        inner_query=subq.inner_query,
+                        import_variables=subq.import_variables,
+                        in_transactions=subq.in_transactions,
+                        transactions_batch_size=subq.transactions_batch_size,
+                    )
+                    clauses.append(subq_optional)
+                else:
+                    self.expect(TokenType.MATCH)
+                    clauses.append(self.parse_match_clause(optional=True))
             elif kind == TokenType.UNWIND:
                 clauses.append(self.parse_unwind_clause())
             elif kind in (
@@ -426,7 +443,13 @@ class Parser:
         if self.peek().kind == TokenType.RETURN:
             inner_return = self.parse_return_clause()
 
-        if inner_return is None:
+        has_updating = any(
+            isinstance(c, ast.UpdatingClause)
+            for part in inner_parts
+            for c in part.clauses
+        )
+
+        if inner_return is None and not has_updating:
             tok = self.peek()
             raise CypherParseError(
                 "Subquery must contain a RETURN clause",
@@ -705,10 +728,20 @@ class Parser:
             var = self.eat().value
 
         labels = []
+        labels_or = False
         while self.matches(TokenType.COLON):
             label_tok = self.expect(TokenType.IDENTIFIER)
             if label_tok.value:
                 labels.append(label_tok.value)
+            while self.peek().kind == TokenType.PIPE or (
+                self.peek().kind == TokenType.IDENTIFIER
+                and self.peek().value == "|"
+            ):
+                self.eat()
+                labels_or = True
+                alt_tok = self.expect(TokenType.IDENTIFIER)
+                if alt_tok.value:
+                    labels.append(alt_tok.value)
 
         props = {}
         if self.matches(TokenType.LBRACE):
@@ -716,7 +749,7 @@ class Parser:
             self.expect(TokenType.RBRACE)
 
         self.expect(TokenType.RPAREN)
-        return ast.NodePattern(variable=var, labels=labels, properties=props)
+        return ast.NodePattern(variable=var, labels=labels, properties=props, labels_or=labels_or)
 
     def parse_relationship_pattern(self) -> ast.RelationshipPattern:
         """Parse -[r:TYPE]-> or <-[r:TYPE]- or -[r:TYPE]-"""
@@ -868,8 +901,12 @@ class Parser:
                 if self.peek().kind == TokenType.MATCH:
                     self.eat()
                 pattern = self.parse_graph_pattern()
+                where_cond = None
+                if self.peek().kind == TokenType.WHERE:
+                    self.eat()
+                    where_cond = self.parse_expression()
                 self.expect(TokenType.RBRACE)
-                return ast.ExistsExpression(pattern=pattern, negated=True)
+                return ast.ExistsExpression(pattern=pattern, negated=True, where_condition=where_cond)
             operand = self.parse_not_expression()
             return ast.BooleanExpression(ast.BooleanOperator.NOT, [operand])
         return self.parse_comparison_expression()
@@ -1027,8 +1064,16 @@ class Parser:
                 if self.peek().kind == TokenType.MATCH:
                     self.eat()
                 pattern = self.parse_graph_pattern()
+                where_cond = None
+                if self.peek().kind == TokenType.WHERE:
+                    self.eat()
+                    where_cond = self.parse_expression()
+                if self.peek().kind == TokenType.RETURN:
+                    self.eat()
+                    while self.peek().kind not in (TokenType.RBRACE, TokenType.EOF):
+                        self.eat()
                 self.expect(TokenType.RBRACE)
-                return ast.ExistsExpression(pattern=pattern, negated=False)
+                return ast.ExistsExpression(pattern=pattern, negated=False, where_condition=where_cond)
 
             if name.lower() in ("shortestpath", "allshortestpaths") and self.peek().kind == TokenType.LPAREN:
                 self.eat()

{iris_vector_graph-1.78.0 → iris_vector_graph-1.80.0}/iris_vector_graph/cypher/translator.py

@@ -1027,7 +1027,9 @@ def translate_to_sql(
                         context.foreach_literals = getattr(
                             context, "foreach_literals", {}
                         )
-                        context.foreach_literals[clause.variable] = item
+                        context.foreach_literals[clause.variable] = (
+                            item.value if isinstance(item, ast.Literal) else item
+                        )
                         for uc in clause.update_clauses:
                             if isinstance(uc, ast.UpdatingClause):
                                 translate_updating_clause(uc, context, metadata)
@@ -1391,6 +1393,9 @@ def translate_create_clause(create, context, metadata):
                         val = v.value
                     elif isinstance(v, ast.Variable) and v.name in context.input_params:
                         val = context.input_params[v.name]
+                    elif isinstance(v, ast.Variable) and getattr(context, "foreach_literals", {}).get(v.name) is not None:
+                        raw = context.foreach_literals[v.name]
+                        val = raw.value if isinstance(raw, ast.Literal) else raw
                     else:
                         val = v
                     context.add_dml(
@@ -1526,25 +1531,43 @@ def translate_delete_clause(delete, context, metadata):
 
 def translate_merge_clause(merge, context, metadata):
     translate_create_clause(ast.CreateClause(patterns=[merge.pattern]), context, metadata)
+    var = merge.pattern.nodes[0].variable if merge.pattern.nodes else None
     for action, is_create in [(merge.on_create, True), (merge.on_match, False)]:
         if action:
             for item in action.items:
                 if isinstance(item, ast.SetItem) and isinstance(
                     item.expression, ast.PropertyReference
                 ):
-                    node_id = context.variable_aliases.get(item.expression.variable)
+                    var_name = item.expression.variable
+                    sql_alias = context.variable_aliases.get(var_name, "")
+                    actual_id = (
+                        context.input_params.get(f"__create_id_{var_name}")
+                        or context.input_params.get(var_name)
+                    )
                     k, v = item.expression.property_name, item.value
                     val = v.value if isinstance(v, ast.Literal) else v
                     if is_create:
-                        context.add_dml(
-                            f'INSERT INTO {_table("rdf_props")} (s, "key", val) SELECT node_id, ?, ? FROM {_table("nodes")} WHERE node_id = ? AND NOT EXISTS (SELECT 1 FROM {_table("rdf_props")} WHERE s = ? AND "key" = ?)',
-                            [k, val, node_id, node_id, k],
-                        )
+                        if actual_id:
+                            context.add_dml(
+                                f'INSERT INTO {_table("rdf_props")} (s, "key", val) SELECT ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM {_table("rdf_props")} WHERE s = ? AND "key" = ?)',
+                                [actual_id, k, val, actual_id, k],
+                            )
+                        else:
+                            context.add_dml(
+                                f'INSERT INTO {_table("rdf_props")} (s, "key", val) SELECT node_id, ?, ? FROM {_table("nodes")} WHERE node_id = ? AND NOT EXISTS (SELECT 1 FROM {_table("rdf_props")} WHERE s = ? AND "key" = ?)',
+                                [k, val, sql_alias, sql_alias, k],
+                            )
                     else:
-                        context.add_dml(
-                            f'UPDATE {_table("rdf_props")} SET val = ? WHERE s = ? AND "key" = ?',
-                            [val, node_id, k],
-                        )
+                        if actual_id:
+                            context.add_dml(
+                                f'UPDATE {_table("rdf_props")} SET val = ? WHERE s = ? AND "key" = ?',
+                                [val, actual_id, k],
+                            )
+                        else:
+                            context.add_dml(
+                                f'UPDATE {_table("rdf_props")} SET val = ? WHERE s IN (SELECT node_id FROM {_table("nodes")} WHERE node_id = ?) AND "key" = ?',
+                                [val, sql_alias, k],
+                            )
 
 
 def translate_set_clause(set_cl, context, metadata):
@@ -1914,13 +1937,23 @@ def translate_node_pattern(node, context, metadata, optional=False):
         alias in j for j in context.join_clauses
     ):
         context.join_clauses.append(f"CROSS JOIN {nodes_tbl} {alias}")
-    for label in node.labels:
-        l_alias = context.next_alias("l")
-        context.join_clauses.append(
-            f"{jt} {_table('rdf_labels')} {l_alias} ON {l_alias}.s = {alias}.node_id AND {l_alias}.label = {context.add_join_param(label)}"
-        )
-        if not optional:
-            context.where_conditions.append(f"{l_alias}.s IS NOT NULL")
+    if node.labels:
+        if getattr(node, 'labels_or', False) and len(node.labels) > 1:
+            l_alias = context.next_alias("l")
+            labels_inlined = ", ".join(f"'{lab}'" for lab in node.labels)
+            context.join_clauses.append(
+                f"{jt} {_table('rdf_labels')} {l_alias} ON {l_alias}.s = {alias}.node_id AND {l_alias}.label IN ({labels_inlined})"
+            )
+            if not optional:
+                context.where_conditions.append(f"{l_alias}.s IS NOT NULL")
+        else:
+            for label in node.labels:
+                l_alias = context.next_alias("l")
+                context.join_clauses.append(
+                    f"{jt} {_table('rdf_labels')} {l_alias} ON {l_alias}.s = {alias}.node_id AND {l_alias}.label = {context.add_join_param(label)}"
+                )
+                if not optional:
+                    context.where_conditions.append(f"{l_alias}.s IS NOT NULL")
     for k, v in node.properties.items():
         val_sql = translate_expression(v, context, segment="where")
         if k in ("node_id", "id"):
@@ -2359,6 +2392,13 @@ def translate_boolean_expression(expr, context) -> str:
                 and tgt_node.variable in context.variable_aliases
             )
             edge_alias = f"_ex{len(context.variable_aliases) + 1}"
+            child_ctx = TranslationContext()
+            child_ctx.input_params = context.input_params
+            child_ctx._alias_counter = context._alias_counter
+            child_ctx.variable_aliases = dict(context.variable_aliases)
+            if tgt_node and tgt_node.variable and not tgt_bound:
+                tgt_alias = child_ctx.next_alias("n")
+                child_ctx.variable_aliases[tgt_node.variable] = tgt_alias
             if tgt_bound:
                 tgt_ref = context.variable_aliases[tgt_node.variable]
                 cond = f"{edge_alias}.o_id = {tgt_ref}.node_id"
@@ -2369,7 +2409,23 @@ def translate_boolean_expression(expr, context) -> str:
                 cond = "1=1"
             if rel.types:
                 cond += f" AND {edge_alias}.p = '{rel.types[0]}'"
-            sub = f"SELECT 1 FROM {_table('rdf_edges')} {edge_alias} WHERE {cond}"
+            sub_froms = [f"{_table('rdf_edges')} {edge_alias}"]
+            sub_wheres = [cond]
+            if tgt_node and tgt_node.variable and not tgt_bound:
+                tgt_alias = child_ctx.variable_aliases.get(tgt_node.variable, "_tn")
+                sub_froms.append(f"{_table('nodes')} {tgt_alias}")
+                sub_wheres.append(f"{tgt_alias}.node_id = {edge_alias}.o_id")
+                if tgt_node.labels:
+                    for lbl in tgt_node.labels:
+                        lbl_alias = child_ctx.next_alias("l")
+                        sub_froms.append(f"{_table('rdf_labels')} {lbl_alias}")
+                        sub_wheres.append(f"{lbl_alias}.s = {tgt_alias}.node_id AND {lbl_alias}.label = '{lbl}'")
+            if expr.where_condition:
+                where_sql = translate_boolean_expression(expr.where_condition, child_ctx)
+                for p in child_ctx.where_params:
+                    context.where_params.append(p)
+                sub_wheres.append(where_sql)
+            sub = f"SELECT 1 FROM {', '.join(sub_froms)} WHERE {' AND '.join(sub_wheres)}"
             prefix = "NOT " if expr.negated else ""
             return f"{prefix}EXISTS ({sub})"
         return "1=1"
@@ -2798,14 +2854,25 @@ def translate_expression(expr, context, segment="select") -> str:
         inner = " || ',' || ".join(parts)
         return f"('{{'||{inner}||'}}')"
     if isinstance(expr, ast.SubscriptExpression):
-        base_sql = translate_expression(expr.expression, context, segment=segment)
-        if isinstance(expr.index, ast.Literal) and isinstance(expr.index.value, int):
-            idx = expr.index.value
+        base = expr.expression
+        idx = expr.index
+        if isinstance(base, ast.Variable) and isinstance(idx, ast.Variable):
+            node_alias = context.variable_aliases.get(base.name, "")
+            key_val = context.input_params.get(idx.name, idx.name)
+            p_alias = context.next_alias("dp")
+            node_ref = f"{node_alias}.node_id" if node_alias else "NULL"
+            context.join_clauses.append(
+                f"LEFT JOIN {_table('rdf_props')} {p_alias} ON {p_alias}.s = {node_ref} AND {p_alias}.\"key\" = {context.add_join_param(key_val)}"
+            )
+            return f"{p_alias}.val"
+        base_sql = translate_expression(base, context, segment=segment)
+        if isinstance(idx, ast.Literal) and isinstance(idx.value, int):
+            i = idx.value
             return (
                 f"(SELECT elem FROM JSON_TABLE({base_sql}, "
-                f"'$[{idx}]' COLUMNS (elem VARCHAR(1000) PATH '$')) __jt)"
+                f"'$[{i}]' COLUMNS (elem VARCHAR(1000) PATH '$')) __jt)"
             )
-        idx_sql = translate_expression(expr.index, context, segment=segment)
+        idx_sql = translate_expression(idx, context, segment=segment)
         return (
             f"JSON_TABLE({base_sql}, '$[*]' COLUMNS "
             f"(idx FOR ORDINALITY, elem VARCHAR(1000) PATH '$'))[{idx_sql}].elem"
@@ -2825,6 +2892,15 @@ def translate_expression(expr, context, segment="select") -> str:
         return f"SQLUser.JSON_VALUE({base_sql}, '$.{prop}')"
     if isinstance(expr, ast.Variable):
         alias = context.variable_aliases.get(expr.name)
+        if alias == "__foreach_literal__":
+            val = getattr(context, "foreach_literals", {}).get(expr.name)
+            if val is not None:
+                if isinstance(val, str):
+                    safe = val.replace("'", "''")
+                    return f"'{safe}'"
+                if isinstance(val, bool):
+                    return "1" if val else "0"
+                return str(val)
         if not alias:
             if expr.name in context.input_params:
                 v = context.input_params[expr.name]

{iris_vector_graph-1.78.0 → iris_vector_graph-1.80.0}/pyproject.toml

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