Function expand_pattern_rels

src/cypher/cypher.c:3291–3359

}

static void expand_pattern_rels(cbm_store_t *store, cbm_pattern_t *pat, binding_t **bindings,
                                int *bind_count, int *bind_cap, const char **var_name,
                                bool is_optional) {
    for (int ri = 0; ri < pat->rel_count; ri++) {
        /* #601: stop expanding further hops once the wall-clock budget is spent
         * (an unbounded expansion is exactly what blows up here). */
        if (cypher_deadline_exceeded()) {
            return;
        }
        cbm_rel_pattern_t *rel = &pat->rels[ri];
        cbm_node_pattern_t *target_node = &pat->nodes[ri + SKIP_ONE];
        const char *to_var = target_node->variable ? target_node->variable : "_n_t";

        bool is_variable_length = (rel->min_hops != SKIP_ONE || rel->max_hops != SKIP_ONE);

        /* #1196: the hop's output buffer GROWS to hold every matched row —
         * the old bind_cap*10 ceiling silently dropped edges before WHERE and
         * aggregation, falsifying counts. binding_out_append handles growth
         * and the OPTIONAL fallback shares it, so no writer can run off the
         * end and no row class is dropped (the old fixed sizing had exactly
         * those two failure modes, CWE-787 and the OPTIONAL data loss). */
        int new_cap = *bind_count > 0 ? *bind_count : CYP_GROWTH_10;
        binding_t *new_bindings = malloc((size_t)new_cap * sizeof(binding_t));
        if (!new_bindings) {
            return; /* OOM: leave existing bindings untouched rather than corrupt */
        }
        int new_count = 0;

        for (int bi = 0; bi < *bind_count; bi++) {
            if ((bi & CYPHER_DEADLINE_CHECK_MASK) == 0 && cypher_deadline_exceeded()) {
                break;
            }
            binding_t *b = &(*bindings)[bi];
            cbm_node_t *src = binding_get(b, *var_name);
            if (!src) {
                continue;
            }

            int match_count = 0;

            if (is_variable_length) {
                expand_var_length(store, rel, target_node, b, src, to_var, &new_bindings,
                                  &new_count, &new_cap, &match_count);
            } else {
                expand_fixed_length(store, rel, target_node, b, src, to_var, &new_bindings,
                                    &new_count, &new_cap, &match_count);
            }

            /* OPTIONAL MATCH: no expansion for this source, so keep the binding
             * with the target unbound (projection renders it ""). The shared
             * growable append gives every fallback row a slot. */
            if (is_optional && match_count == 0) {
                binding_t nb = {0};
                binding_copy(&nb, b);
                /* Don't set to_var — it remains unbound; projection returns "" */
                (void)binding_out_append(&new_bindings, &new_count, &new_cap, &nb);
            }
        }