iris-vector-graph 1.64.0__tar.gz → 1.64.2__tar.gz

{iris_vector_graph-1.64.0 → iris_vector_graph-1.64.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.64.0
+Version: 1.64.2
 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.64.0 → iris_vector_graph-1.64.2}/iris_vector_graph/cypher/translator.py

@@ -151,6 +151,7 @@ class TranslationContext:
         self.where_conditions: List[str] = []
         self.having_conditions: List[str] = []
         self.group_by_items: List[str] = []
+        self._undirected_aliases: set = set()
 
         self.select_params: List[Any] = []
         self.join_params: List[Any] = []
@@ -1949,8 +1950,52 @@ def translate_relationship_pattern(
             f"{target_alias}.{t_col} = {edge_alias}.s",
         )
     else:
-        edge_cond = f"({edge_alias}.s = {source_alias}.{s_col} OR {edge_alias}.o_id = {source_alias}.{s_col})"
-        target_on = f"({target_alias}.{t_col} = {edge_alias}.o_id OR {target_alias}.{t_col} = {edge_alias}.s)"
+        # UNION ALL of two indexed scans replaces OR-join:
+        # OR-join forces full table scan; UNION ALL uses two index seeks (10-50× faster on IRIS).
+        pred_filter = ""
+        if rel.types:
+            if len(rel.types) == 1:
+                pt = context.add_join_param(rel.types[0])
+                pred_filter = f" AND p = {pt}"
+            else:
+                pts = ", ".join(context.add_join_param(t) for t in rel.types)
+                pred_filter = f" AND p IN ({pts})"
+        edges_tbl = _table("rdf_edges")
+        union_derived = (
+            f"(\n"
+            f"  SELECT s AS _src, p AS _p, o_id AS _dst\n"
+            f"  FROM {edges_tbl}\n"
+            f"  WHERE s = {source_alias}.{s_col}{pred_filter}\n"
+            f"  UNION ALL\n"
+            f"  SELECT o_id AS _src, p AS _p, s AS _dst\n"
+            f"  FROM {edges_tbl}\n"
+            f"  WHERE o_id = {source_alias}.{s_col}{pred_filter}\n"
+            f") {edge_alias}"
+        )
+        edge_cond = f"1=1"
+        target_on = f"{target_alias}.{t_col} = {edge_alias}._dst"
+        context.join_clauses.append(f"{jt} {union_derived} ON {edge_cond}")
+        context._undirected_aliases.add(edge_alias)
+        if is_new_target and not target_alias.startswith("Stage"):
+            context.join_clauses.append(
+                f"{jt} {_table('nodes')} {target_alias} ON {target_on}"
+            )
+        else:
+            context.where_conditions.append(target_on)
+        context.variable_aliases[rel.variable or edge_alias] = edge_alias
+        for prop_node, prop_alias in (
+            (source_node, source_alias),
+            (target_node, target_alias),
+        ):
+            if prop_node:
+                for k, v in (prop_node.properties or {}).items():
+                    if k in ("id", "node_id"):
+                        continue
+                    col = f"{prop_alias}.{k}" if prop_alias else k
+                    context.where_conditions.append(
+                        f"{col} = {context.add_where_param(v.value if isinstance(v, ast.Literal) else str(v))}"
+                    )
+        return
 
     if rel.types:
         if len(rel.types) == 1:
@@ -2583,7 +2628,8 @@ def translate_expression(expr, context, segment="select") -> str:
                 var_name = args_exprs[0].name
                 alias = context.variable_aliases.get(var_name, "")
                 if alias:
-                    return f"{alias}.p"
+                    p_col = "_p" if getattr(context, "_undirected_aliases", set()) and alias in context._undirected_aliases else "p"
+                    return f"{alias}.{p_col}"
             return args[0] if args else "NULL"
 
         if fn in ("startnode",):
@@ -2723,7 +2769,16 @@ def translate_expression(expr, context, segment="select") -> str:
 
 
 def translate_return_clause(ret, context):
+    _IRIS_RESERVED = frozenset({
+        "count","sum","avg","min","max","key","value","type","name","label",
+        "order","group","index","select","from","where","join","having",
+        "union","insert","update","delete","create","drop","alter","set",
+        "table","schema","column","row","data","id","user","date","time",
+    })
     has_agg = any(isinstance(i.expression, ast.AggregationFunction) for i in ret.items)
+    def _safe_alias(a):
+        return f'"{a}"' if a and a.lower() in _IRIS_RESERVED else a
+
     for item in ret.items:
         if isinstance(item.expression, ast.Variable):
             var_name = item.expression.name
@@ -2734,7 +2789,7 @@ def translate_return_clause(ret, context):
                 nodes_arr = ", ".join(f"{a}.node_id" for a in node_aliases)
                 rels_arr = ", ".join(f"{a}.p" for a in edge_aliases)
                 json_expr = f"'{{\"nodes\":' || JSON_ARRAY({nodes_arr}) || ',\"rels\":' || JSON_ARRAY({rels_arr}) || '}}'"
-                context.select_items.append(f"{json_expr} AS {alias}")
+                context.select_items.append(f"{json_expr} AS {_safe_alias(alias)}")
                 continue
             alias_name = context.variable_aliases.get(var_name)
             is_scalar = var_name in context.scalar_variables
@@ -2768,7 +2823,7 @@ def translate_return_clause(ret, context):
             ):
                 alias = f"{item.expression.function_name}_res"
         if alias:
-            context.select_items.append(f"{sql} AS {alias.replace('.', '_')}")
+            context.select_items.append(f"{sql} AS {_safe_alias(alias).replace('.', '_')}")
         else:
             context.select_items.append(sql)
         if has_agg and not isinstance(item.expression, ast.AggregationFunction):
@@ -2803,7 +2858,7 @@ def translate_with_clause(with_clause, context):
                 alias = f"{item.expression.function_name}"
         if alias is None:
             alias = context.next_alias("v")
-        context.select_items.append(f"{sql} AS {alias.replace('.', '_')}")
+        context.select_items.append(f"{sql} AS {_safe_alias(alias).replace('.', '_')}")
         if has_agg and not isinstance(item.expression, ast.AggregationFunction):
             context.group_by_items.append(sql)
         if isinstance(item.expression, ast.AggregationFunction):

{iris_vector_graph-1.64.0 → iris_vector_graph-1.64.2}/pyproject.toml

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

{iris_vector_graph-1.64.0 → iris_vector_graph-1.64.2}/tests/unit/test_cypher_translator.py

@@ -181,3 +181,40 @@ def test_in_param_empty_list_handled():
     q = "MATCH (a) WHERE a.id IN $ids RETURN a.id"
     result = translate_to_sql(parse_query(q), {"ids": []})
     assert result.sql is not None
+
+
+def test_undirected_1hop_uses_union_all_not_or_join():
+    q = "MATCH (a)-[r]-(b) WHERE a.id = $x RETURN b.id, type(r)"
+    r = translate_to_sql(parse_query(q), {"x": "hla-b27"})
+    assert "UNION ALL" in r.sql, "undirected pattern must use UNION ALL not OR-join"
+    assert " OR " not in r.sql or "o_id" not in r.sql.split("OR")[0], \
+        "OR-join pattern must be eliminated for undirected 1-hop"
+
+
+def test_undirected_with_node_props_uses_union_all():
+    q = "MATCH (a)-[r]-(b) WHERE a.id = $x RETURN a.id, b.id, b.name, type(r)"
+    r = translate_to_sql(parse_query(q), {"x": "hla-b27"})
+    assert "UNION ALL" in r.sql
+    assert "e2._p AS type_res" in r.sql, "type(r) must use _p column alias in UNION subquery"
+
+
+def test_undirected_typed_rel_uses_union_all():
+    q = "MATCH (a)-[r:KNOWS]-(b) WHERE a.id = $x RETURN b.id"
+    r = translate_to_sql(parse_query(q), {"x": "hla-b27"})
+    assert "UNION ALL" in r.sql
+    assert "AND p = ?" in r.sql, "predicate filter applied inside both arms of UNION"
+
+
+def test_directed_outgoing_still_uses_single_join():
+    q = "MATCH (a)-[r]->(b) WHERE a.id = $x RETURN b.id, type(r)"
+    r = translate_to_sql(parse_query(q), {"x": "hla-b27"})
+    assert "UNION ALL" not in r.sql
+    assert "JOIN rdf_edges" in r.sql
+    assert "e2.p AS type_res" in r.sql
+
+
+def test_directed_incoming_still_uses_single_join():
+    q = "MATCH (a)<-[r]-(b) WHERE a.id = $x RETURN b.id"
+    r = translate_to_sql(parse_query(q), {"x": "hla-b27"})
+    assert "UNION ALL" not in r.sql
+    assert "JOIN rdf_edges" in r.sql