graphistry
diff --git a/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎graphistry/compute/gfql/cypher/lowering.py‎
Lines changed: 22 additions & 4 deletions b/‎graphistry/compute/gfql/cypher/lowering.py‎
Lines changed: 22 additions & 4 deletions
diff --git a/‎graphistry/compute/gfql/cypher/result_postprocess.py‎
Lines changed: 14 additions & 66 deletions b/‎graphistry/compute/gfql/cypher/result_postprocess.py‎
Lines changed: 14 additions & 66 deletions
@@ -52,6 +52,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - **GFQL / IR refactor**: Consolidated the `("input", "left", "right", "subquery")` child-slot tuple that was duplicated across 5 sites (IR verifier, physical planner, two rewrite passes, one test helper) into a single `CHILD_SLOTS` constant and `iter_children` helper in `graphistry/compute/gfql/ir/logical_plan.py`. Adds 8 regression tests including: identity-preservation for `UnnestApply` and `PredicatePushdownPass` when no descendant is rewritten (the `rewritten_child is not child` guard is load-bearing for tier-2 fixed-point convergence), asymmetric identity preservation across `Join` when only one branch is rewritten, and a reflective `typing.get_type_hints` check that any future `LogicalPlan` subclass adding a new child slot must update `CHILD_SLOTS` (#1196, #1199).
 
 ### Fixed
+- **GFQL / row pipeline — relationship alias in row expressions (#1072)**: Bare edge-alias tokens in row expressions (`select([("rel", "workAt")])`, `WHERE rel IS NOT NULL`, `RETURN rel`) no longer raise `unsupported token in row expression: '<alias>'`. `_gfql_resolve_token` in `graphistry/compute/gfql/row/pipeline.py` extends the bare-alias branch with edge-alias resolution: prefer `{alias}.{_edge}` when present, otherwise render `[:TYPE {prop: value, ...}]` via a new shared vectorized renderer in `graphistry/compute/gfql/row/entity_props.py` reused by `cypher/result_postprocess.py::_format_edge_entities` and the row-pipeline path. Edge-alias classification is gated on `_gfql_rows_edge_aliases` metadata propagated through row-table adapters so node-alias frames missing a node-id column are not misrendered as edges. Renderer normalizes string escaping (`\\`, `'`), float formatting (strips trailing `.0+`), and treats blank/whitespace `type` as absent (`[{...}]` instead of `[: {...}]`). Re-entry `WHERE` secondary-alias property predicates (`MATCH ... WITH a, b ... MATCH ... WHERE b.x = ...`) are now rewritten when the predicate has no `expr_tree` by synthesizing WHERE expression text from structured predicates and clearing consumed predicates in `cypher/lowering.py` to avoid stale dual representation. Carries upstream prerequisites #1071 (multi-alias carry through `WITH` before MATCH re-entry) and #1236 (OR/XOR-around-pattern WHERE lowering) needed for current TCK contract behavior. Adds regressions in `test_row_pipeline_ops.py` covering string escaping, float normalization, null-only properties, missing/empty `type`, multi-edge rows, `select`/`return` parity, node-alias misclassification guard, and bare-alias `id` parity; adds `test_lowering.py` regressions for re-entry WHERE rewrites on secondary aliases and OR/XOR-around carried+trailing alias property paths (#1072).
 - **GFQL / comparison predicates**: Mixed-type scalar comparisons in Cypher `WHERE` execution (`>`, `<`, `>=`, `<=`) now preserve null-safe filter semantics across pandas and cuDF backends instead of failing whole-series evaluation on incomparable rows. Comparable rows keep backend-native ordering; incomparable/null rows evaluate non-matching (`False`) (#1219, #1223).
 - **GFQL / predicate pushdown**: Fixed a silent `\b` regex bug in `_refs_for_segment` (`graphistry/compute/gfql/passes/predicate_pushdown.py`). The rf-string `rf"\\b..."` produced a literal backslash-b sequence, not a word-boundary assertion, so per-conjunct alias detection never matched and always fell back to the full original reference set — widening reference sets for every split conjunct and preventing some safe-pushable conjuncts from being recognized. Tests passed because the fallback is a superset. Also consolidated two duplicate "split WHERE body on top-level AND" implementations (one in `parser.py`, one in `predicate_pushdown.py`) into a shared helper `graphistry/compute/gfql/expr_split.py::split_top_level_and` with strictly quote/bracket/paren/backtick-aware splitting. Adds 20 direct unit tests for the shared helper and one regression test locking the `\b` fix (#1195, #1198).
 - **GFQL / Cypher binder**: Replaced fragile regex-based WHERE label narrowing fallback in `_apply_where_label_narrowing` with AST-derived narrowing. `generic_where_clause` now lifts AND-joined bare label predicates (`WHERE n:Admin AND n:Active`) to structured `WhereClause.predicates` using the existing quote/bracket/paren/backtick-aware `_split_top_level_and_terms` helper; string-literal false-matches (e.g. `WHERE n.name = 'n:Admin'` incorrectly narrowing alias `n`) are closed by `fullmatch` anchoring. Removes `_WHERE_LABEL_RE` and `_WHERE_NON_CONJUNCTIVE_RE` from `binder.py`. Adds 10 targeted tests covering single/double/triple AND, multi-alias, multi-label-per-alias, lowercase `and`, XOR/OR/NOT conservative non-narrowing, mixed label+property all-or-nothing, and string-literal false-positive guards (#1125, #1193).
 
@@ -5874,9 +5874,24 @@ def _where_clause_expr_text(where: WhereClause) -> Optional[ExpressionText]:
     derived from the same ``_span_from_meta(meta)`` of the
     ``generic_where_clause`` rule) to preserve error-position semantics.
     """
-    if where.expr_tree is None:
-        return None
-    return ExpressionText(text=boolean_expr_to_text(where.expr_tree), span=where.span)
+    if where.expr_tree is not None:
+        return ExpressionText(text=boolean_expr_to_text(where.expr_tree), span=where.span)
+
+    # Structured-predicate WHERE clauses can still require downstream rewrite
+    # (for example, multi-alias re-entry secondary carry demotion).  Synthesize
+    # equivalent row-expression text when all predicates are row-renderable.
+    if where.predicates:
+        predicate_texts: List[str] = []
+        for predicate in where.predicates:
+            if not isinstance(predicate, WherePredicate):
+                return None
+            row_text = _row_where_predicate_text(predicate)
+            if row_text is None:
+                return None
+            predicate_texts.append(row_text)
+        if predicate_texts:
+            return ExpressionText(text=" and ".join(predicate_texts), span=where.span)
+    return None
 
 
 def _rewrite_where_clause_and_resync(
@@ -5907,7 +5922,10 @@ def _rewrite_where_clause_and_resync(
         atom_text=rewritten.text,
         atom_span=rewritten.span,
     )
-    return replace(where, expr_tree=new_tree)
+    rewritten_where = replace(where, expr_tree=new_tree)
+    if where.expr_tree is None and where.predicates:
+        rewritten_where = replace(rewritten_where, predicates=())
+    return rewritten_where
 
 
 def _extract_relationship_type_where(
 
@@ -16,7 +16,13 @@
     LOCALTIME_CALL_TEXT_RE,
     TIME_CALL_TEXT_RE,
 )
-from graphistry.compute.gfql.row.entity_props import edge_property_columns, node_property_columns
+from graphistry.compute.gfql.row.entity_props import (
+    append_property_segments as shared_append_property_segments,
+    edge_property_columns,
+    format_edge_entity_text as shared_format_edge_entity_text,
+    node_property_columns,
+    render_scalar_value_text as shared_render_scalar_value_text,
+)
 from graphistry.compute.gfql.row.pipeline import _RowPipelineAdapter
 
 
@@ -270,61 +276,15 @@ def _format(series: SeriesT) -> SeriesT:
 
 
 def _render_scalar_value_text(df: DataFrameT, alias_col: str, series: SeriesT) -> SeriesT:
-    text = _object_text(cast(SeriesT, series.astype(str)))
-    dtype_txt = str(getattr(series, "dtype", "")).lower()
-    if "bool" in dtype_txt and hasattr(text, "str"):
-        return cast(SeriesT, text.str.lower())
-    if "float" in dtype_txt and hasattr(text, "str"):
-        return _normalize_scientific_numeric_text(text)
-    if any(token in dtype_txt for token in ("int", "double", "decimal")):
-        return text
-    if hasattr(text, "str"):
-        stripped = cast(SeriesT, text.str.strip())
-        non_null = cast(SeriesT, ~_is_null_mask(series))
-        list_like = cast(SeriesT, series_str_match(stripped, r"^\[.*\]$", na=False))
-        if _all_non_null_match(list_like, non_null):
-            return stripped
-        map_like = cast(SeriesT, series_str_match(stripped, r"^\{.*\}$", na=False))
-        if _all_non_null_match(map_like, non_null):
-            return stripped
-        temporal = _normalize_temporal_constructor_series(df, alias_col, series, text, quoted=True)
-        if temporal is not None:
-            return temporal
-        non_null = cast(SeriesT, ~_is_null_mask(series))
-        bool_like = cast(SeriesT, series_str_match(text, r"^(True|False)$", na=False))
-        num_like = cast(SeriesT, series_str_match(text, r"^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$", na=False))
-        if hasattr(bool_like, "where") and bool(bool_like.where(non_null, True).all()):
-            return cast(SeriesT, text.str.lower())
-        if hasattr(num_like, "where") and bool(num_like.where(non_null, True).all()):
-            return _normalize_scientific_numeric_text(text)
-        out = _quote_text_series(df, alias_col, text)
-        out = cast(SeriesT, out.where(~bool_like, text.str.lower()))
-        out = cast(SeriesT, out.where(~num_like, text.str.replace(r"\.0+$", "", regex=True)))
-        out = cast(SeriesT, out.where(~list_like, stripped))
-        out = cast(SeriesT, out.where(~map_like, stripped))
-        return out
-    if hasattr(text, "str"):
-        return _quote_text_series(df, alias_col, text)
-    return cast(SeriesT, _const_text(df, alias_col, "'") + text + "'")
+    return shared_render_scalar_value_text(df, alias_col, series)
 
 
 def _append_property_segments(
     df: DataFrameT,
     alias_col: str,
     property_columns: Sequence[str],
 ) -> tuple[SeriesT, SeriesT]:
-    text = _empty_text(df, alias_col)
-    has_props = _false_mask(df, alias_col)
-    for col in property_columns:
-        series = cast(SeriesT, df[col])
-        include = cast(SeriesT, ~_is_null_mask(series))
-        value_text = _render_scalar_value_text(df, alias_col, series)
-        segment = _const_text(df, alias_col, f"{col}: ") + value_text
-        prefix = cast(SeriesT, _const_text(df, alias_col, ", ").where(has_props & include, ""))
-        append = cast(SeriesT, (prefix + segment).where(include, ""))
-        text = cast(SeriesT, text + append)
-        has_props = cast(SeriesT, has_props | include)
-    return text, has_props
+    return shared_append_property_segments(df, alias_col, property_columns)
 
 
 def _node_label_text(df: DataFrameT, alias_col: str) -> SeriesT:
@@ -377,25 +337,13 @@ def _format_node_entities(df: DataFrameT, projection: ResultProjectionPlan) -> S
 
 def _format_edge_entities(df: DataFrameT, projection: ResultProjectionPlan) -> SeriesT:
     alias_col = projection.alias
-    if "type" in df.columns:
-        type_series = cast(SeriesT, df["type"])
-        type_text = _object_text(cast(SeriesT, type_series.astype(str)))
-        type_part = cast(SeriesT, (_const_text(df, alias_col, ":") + type_text).where(~_is_null_mask(type_series), ""))
-    else:
-        type_part = _empty_text(df, alias_col)
-    prop_text, has_props = _append_property_segments(
+    return shared_format_edge_entity_text(
         df,
-        alias_col,
-        _edge_property_columns(df, alias_col, projection.exclude_columns),
-    )
-    type_present = cast(SeriesT, type_part != "")
-    prop_block = cast(SeriesT, _const_text(df, alias_col, "{") + prop_text + "}")
-    prop_suffix = cast(
-        SeriesT,
-        (_const_text(df, alias_col, " ").where(has_props & type_present, "") + prop_block).where(has_props, ""),
+        alias_col=alias_col,
+        property_columns=_edge_property_columns(df, alias_col, projection.exclude_columns),
+        type_col="type",
+        nullify_missing_alias_rows=True,
     )
-    rendered = cast(SeriesT, _const_text(df, alias_col, "[") + type_part + prop_suffix + "]")
-    return _nullify_missing_alias_rows(df, alias_col, rendered)
 
 
 def _project_property_column(