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

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

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

@@ -1643,9 +1643,13 @@ def translate_match_clause(match_clause, context, metadata):
     for pattern in match_clause.patterns:
         if not pattern.nodes:
             continue
-        translate_node_pattern(
-            pattern.nodes[0], context, metadata, optional=match_clause.optional
-        )
+        first_node = pattern.nodes[0]
+        if first_node.variable or first_node.labels or first_node.properties:
+            translate_node_pattern(
+                first_node, context, metadata, optional=match_clause.optional
+            )
+        else:
+            _ = context.next_alias("n")
         for i, rel in enumerate(pattern.relationships):
             translate_relationship_pattern(
                 rel,
@@ -1655,9 +1659,11 @@ def translate_match_clause(match_clause, context, metadata):
                 metadata,
                 optional=match_clause.optional,
             )
-            translate_node_pattern(
-                pattern.nodes[i + 1], context, metadata, optional=match_clause.optional
-            )
+            last_node = pattern.nodes[i + 1]
+            if last_node.variable or last_node.labels or last_node.properties:
+                translate_node_pattern(
+                    last_node, context, metadata, optional=match_clause.optional
+                )
 
     for np in match_clause.named_paths:
         context.named_paths[np.variable] = np
@@ -1680,13 +1686,8 @@ def translate_subquery_call(
     is_correlated = len(subquery.import_variables) > 0
 
     if is_correlated:
-        if not inner.return_clause or len(inner.return_clause.items) != 1:
-            raise ValueError(
-                "Correlated subquery Phase 1 requires exactly one RETURN column (scalar)"
-            )
-
-        ret_item = inner.return_clause.items[0]
-        alias = ret_item.alias or "sub_result"
+        if not inner.return_clause:
+            raise ValueError("Correlated subquery requires a RETURN clause")
 
         child_ctx = TranslationContext()
         child_ctx.input_params = context.input_params
@@ -1706,49 +1707,132 @@ def translate_subquery_call(
                 elif isinstance(clause, ast.WhereClause):
                     translate_where_clause(clause, child_ctx)
 
-        inner_expr = translate_expression(
-            ret_item.expression, child_ctx, segment="select"
+        num_return_cols = len(inner.return_clause.items)
+        is_single_scalar = (
+            num_return_cols == 1
+            and isinstance(
+                inner.return_clause.items[0].expression,
+                (ast.AggregationFunction,),
+            )
         )
 
-        inner_sql_parts = [f"SELECT {inner_expr}"]
-        if child_ctx.from_clauses:
-            inner_sql_parts.append(f"FROM {', '.join(child_ctx.from_clauses)}")
-            if child_ctx.join_clauses:
-                inner_sql_parts.extend(child_ctx.join_clauses)
-        elif child_ctx.join_clauses:
-            first_join = (
-                child_ctx.join_clauses[0]
-                .replace("JOIN ", "", 1)
-                .replace("CROSS JOIN ", "", 1)
+        if is_single_scalar:
+            ret_item = inner.return_clause.items[0]
+            alias = ret_item.alias or "sub_result"
+            inner_expr = translate_expression(
+                ret_item.expression, child_ctx, segment="select"
             )
-            on_idx = first_join.find(" ON ")
-            if on_idx > 0:
-                from_part = first_join[:on_idx]
-                on_part = first_join[on_idx + 4 :]
-                inner_sql_parts.append(f"FROM {from_part}")
-                if child_ctx.join_clauses[1:]:
-                    inner_sql_parts.extend(child_ctx.join_clauses[1:])
-                if child_ctx.where_conditions:
-                    child_ctx.where_conditions.insert(0, on_part)
+            inner_sql_parts = [f"SELECT {inner_expr}"]
+            if child_ctx.from_clauses:
+                inner_sql_parts.append(f"FROM {', '.join(child_ctx.from_clauses)}")
+                if child_ctx.join_clauses:
+                    inner_sql_parts.extend(child_ctx.join_clauses)
+            elif child_ctx.join_clauses:
+                first_join = (
+                    child_ctx.join_clauses[0]
+                    .replace("JOIN ", "", 1)
+                    .replace("CROSS JOIN ", "", 1)
+                )
+                on_idx = first_join.find(" ON ")
+                if on_idx > 0:
+                    from_part = first_join[:on_idx]
+                    on_part = first_join[on_idx + 4 :]
+                    inner_sql_parts.append(f"FROM {from_part}")
+                    if child_ctx.join_clauses[1:]:
+                        inner_sql_parts.extend(child_ctx.join_clauses[1:])
+                    if child_ctx.where_conditions:
+                        child_ctx.where_conditions.insert(0, on_part)
+                    else:
+                        child_ctx.where_conditions.append(on_part)
                 else:
-                    child_ctx.where_conditions.append(on_part)
-            else:
-                inner_sql_parts.append(f"FROM {first_join}")
-                if child_ctx.join_clauses[1:]:
-                    inner_sql_parts.extend(child_ctx.join_clauses[1:])
-        if child_ctx.where_conditions:
-            inner_sql_parts.append(f"WHERE {' AND '.join(child_ctx.where_conditions)}")
-
-        scalar_sql = "\n".join(inner_sql_parts)
-        all_params = (
-            child_ctx.select_params + child_ctx.join_params + child_ctx.where_params
-        )
-        for p in all_params:
-            context.select_params.append(p)
-
-        context.select_items.append(f"COALESCE(({scalar_sql}), 0) AS {alias}")
-        context.scalar_variables.add(alias)
-        context.variable_aliases[alias] = "scalar"
+                    inner_sql_parts.append(f"FROM {first_join}")
+                    if child_ctx.join_clauses[1:]:
+                        inner_sql_parts.extend(child_ctx.join_clauses[1:])
+            if child_ctx.where_conditions:
+                inner_sql_parts.append(f"WHERE {' AND '.join(child_ctx.where_conditions)}")
+            scalar_sql = "\n".join(inner_sql_parts)
+            all_params = (
+                child_ctx.select_params + child_ctx.join_params + child_ctx.where_params
+            )
+            for p in all_params:
+                context.select_params.append(p)
+            context.select_items.append(f"COALESCE(({scalar_sql}), 0) AS {alias}")
+            context.scalar_variables.add(alias)
+            context.variable_aliases[alias] = "scalar"
+        else:
+            child_ctx_lateral = TranslationContext()
+            child_ctx_lateral.input_params = context.input_params
+            child_ctx_lateral._alias_counter = context._alias_counter
+            for var in subquery.import_variables:
+                child_ctx_lateral.variable_aliases[var] = context.variable_aliases[var]
+
+            def _inline_val(v):
+                if isinstance(v, str): return f"'{v.replace(chr(39), chr(39)+chr(39))}'"
+                if isinstance(v, bool): return "1" if v else "0"
+                if v is None: return "NULL"
+                return str(v)
+
+            def _inline_join_param(val):
+                return _inline_val(val)
+            def _inline_where_param(val):
+                return _inline_val(val)
+            def _inline_select_param(val):
+                return _inline_val(val)
+
+            child_ctx_lateral.add_join_param = _inline_join_param
+            child_ctx_lateral.add_where_param = _inline_where_param
+            child_ctx_lateral.add_select_param = _inline_select_param
+
+            for part in inner.query_parts:
+                for clause in part.clauses:
+                    if isinstance(clause, ast.MatchClause):
+                        translate_match_clause(clause, child_ctx_lateral, metadata)
+                    elif isinstance(clause, ast.WhereClause):
+                        translate_where_clause(clause, child_ctx_lateral)
+            translate_return_clause(inner.return_clause, child_ctx_lateral)
+            if not child_ctx_lateral.from_clauses and child_ctx_lateral.join_clauses:
+                first_jc = child_ctx_lateral.join_clauses[0]
+                for prefix in ("CROSS JOIN ", "LEFT OUTER JOIN ", "JOIN "):
+                    if first_jc.startswith(prefix):
+                        rest = first_jc[len(prefix):]
+                        on_idx = rest.find(" ON ")
+                        if on_idx > 0:
+                            table_part = rest[:on_idx]
+                            cond_part = rest[on_idx + 4:]
+                            child_ctx_lateral.from_clauses.append(table_part)
+                            if cond_part.strip() and cond_part.strip() != "1=1":
+                                child_ctx_lateral.where_conditions.insert(0, cond_part)
+                            child_ctx_lateral.join_clauses = child_ctx_lateral.join_clauses[1:]
+                        else:
+                            child_ctx_lateral.from_clauses.append(rest)
+                            child_ctx_lateral.join_clauses = child_ctx_lateral.join_clauses[1:]
+                        break
+            inner_sql_parts_lat = [
+                f"SELECT {'DISTINCT ' if inner.return_clause.distinct else ''}{', '.join(child_ctx_lateral.select_items)}"
+            ]
+            if child_ctx_lateral.from_clauses:
+                inner_sql_parts_lat.append(f"FROM {', '.join(child_ctx_lateral.from_clauses)}")
+            if child_ctx_lateral.join_clauses:
+                inner_sql_parts_lat.extend(child_ctx_lateral.join_clauses)
+            if child_ctx_lateral.where_conditions:
+                inner_sql_parts_lat.append(f"WHERE {' AND '.join(child_ctx_lateral.where_conditions)}")
+            inner_sql = "\n".join(inner_sql_parts_lat)
+            lat_alias = context.next_alias("lat")
+            context.join_clauses.append(
+                f"CROSS JOIN LATERAL (\n{inner_sql}\n) {lat_alias}"
+            )
+            for item in inner.return_clause.items:
+                col_alias = item.alias
+                if col_alias is None:
+                    if isinstance(item.expression, ast.Variable):
+                        col_alias = item.expression.name
+                    elif isinstance(item.expression, ast.PropertyReference):
+                        col_alias = f"{item.expression.variable}_{item.expression.property_name}"
+                    else:
+                        col_alias = f"col_{len(context.scalar_variables)}"
+                if col_alias:
+                    context.variable_aliases[col_alias] = lat_alias
+                    context.scalar_variables.add(col_alias)
     else:
         child_ctx = TranslationContext()
         child_ctx.input_params = context.input_params
@@ -1908,7 +1992,14 @@ def translate_relationship_pattern(
         else:
             context.join_clauses.append(f"JOIN {_table('nodes')} {target_alias} ON 1=1")
         return
-    if source_node.variable is None:
+    is_anon_source = (
+        source_node.variable is None
+        and not source_node.labels
+        and not source_node.properties
+    )
+    if is_anon_source:
+        source_alias = context.next_alias("n")
+    elif source_node.variable is None:
         source_alias = context.next_alias("n")
         joined = any(
             source_alias in fc for fc in context.from_clauses + context.join_clauses
@@ -2060,10 +2151,16 @@ def translate_relationship_pattern(
     jt = "LEFT OUTER JOIN" if optional else "JOIN"
 
     if rel.direction == ast.Direction.OUTGOING:
-        edge_cond, target_on = (
-            f"{edge_alias}.s = {source_alias}.{s_col}",
-            f"{target_alias}.{t_col} = {edge_alias}.o_id",
-        )
+        if is_anon_source:
+            edge_cond, target_on = (
+                f"1=1",
+                f"{target_alias}.{t_col} = {edge_alias}.o_id",
+            )
+        else:
+            edge_cond, target_on = (
+                f"{edge_alias}.s = {source_alias}.{s_col}",
+                f"{target_alias}.{t_col} = {edge_alias}.o_id",
+            )
     elif rel.direction == ast.Direction.INCOMING:
         edge_cond, target_on = (
             f"{edge_alias}.o_id = {source_alias}.{s_col}",
@@ -2140,7 +2237,7 @@ def translate_relationship_pattern(
         and not source_alias.startswith("VecSearch")
     )
 
-    if use_edgescan:
+    if use_edgescan and not is_anon_source:
         pred_sql = f"'{rel.types[0]}'" if len(rel.types) == 1 else "NULL"
         src_id_val = source_node.properties.get("id") if source_node else None
         if src_id_val is not None:
@@ -2179,9 +2276,21 @@ def translate_relationship_pattern(
                 f"{jt} {_table('rdf_edges')} {edge_alias} ON {edge_cond}"
             )
     else:
-        context.join_clauses.append(
-            f"{jt} {_table('rdf_edges')} {edge_alias} ON {edge_cond}"
-        )
+        if is_anon_source:
+            actual_cond = edge_cond.lstrip("1=1").lstrip(" AND ").strip() if edge_cond.startswith("1=1") else edge_cond
+            if not context.from_clauses:
+                context.from_clauses.append(f"{_table('rdf_edges')} {edge_alias}")
+                if actual_cond:
+                    context.where_conditions.append(actual_cond)
+            else:
+                full_cond = actual_cond if actual_cond else "1=1"
+                context.join_clauses.append(
+                    f"{jt} {_table('rdf_edges')} {edge_alias} ON {full_cond}"
+                )
+        else:
+            context.join_clauses.append(
+                f"{jt} {_table('rdf_edges')} {edge_alias} ON {edge_cond}"
+            )
 
     if is_new_target and not target_alias.startswith("Stage"):
         context.join_clauses.append(

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

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