Skip to main content

graphd_engine/
rewriter.rs

1use std::time::{SystemTime, UNIX_EPOCH};
2use uuid::Uuid;
3
4/// Result of rewriting a Cypher query for deterministic replay.
5pub struct RewriteResult {
6    /// The rewritten query text (unchanged if no non-deterministic functions found).
7    pub query: String,
8    /// Generated parameters to merge with user-supplied params.
9    /// Keys are param names without `$` prefix (e.g., `_uuid_0`).
10    pub generated_params: Vec<(String, serde_json::Value)>,
11}
12
13/// Rewrite non-deterministic function calls in a Cypher query.
14///
15/// Replaces:
16///   gen_random_uuid()   -> $__graphd_uuid_N   (UUID v4 string value)
17///   current_timestamp() -> $__graphd_now_N    (ISO 8601 timestamp string)
18///   current_date()      -> $__graphd_date_N   (ISO 8601 date string)
19///
20/// Does NOT rewrite inside string literals ('...' or "...").
21/// Case-insensitive. Handles optional whitespace between name and `()`.
22pub fn rewrite_query(query: &str) -> RewriteResult {
23    let bytes = query.as_bytes();
24    let len = bytes.len();
25    let mut output = Vec::with_capacity(len);
26    let mut generated_params = Vec::new();
27    let mut counters = [0u32; 3]; // [uuid, now, date]
28    let mut i = 0;
29    let mut in_single_quote = false;
30    let mut in_double_quote = false;
31
32    while i < len {
33        if in_single_quote {
34            output.push(bytes[i]);
35            if bytes[i] == b'\'' {
36                // Handle escaped single quote ''
37                if i + 1 < len && bytes[i + 1] == b'\'' {
38                    output.push(bytes[i + 1]);
39                    i += 2;
40                } else {
41                    in_single_quote = false;
42                    i += 1;
43                }
44            } else {
45                i += 1;
46            }
47        } else if in_double_quote {
48            output.push(bytes[i]);
49            if bytes[i] == b'"' {
50                in_double_quote = false;
51            }
52            i += 1;
53        } else if bytes[i] == b'\'' {
54            in_single_quote = true;
55            output.push(bytes[i]);
56            i += 1;
57        } else if bytes[i] == b'"' {
58            in_double_quote = true;
59            output.push(bytes[i]);
60            i += 1;
61        } else if let Some((func_idx, consumed)) = try_match_func(bytes, i) {
62            let (param_ref, param_name, param_value) = match func_idx {
63                0 => {
64                    let n = counters[0];
65                    counters[0] += 1;
66                    (format!("$__graphd_uuid_{n}"), format!("__graphd_uuid_{n}"), Uuid::new_v4().to_string())
67                }
68                1 => {
69                    let n = counters[1];
70                    counters[1] += 1;
71                    (format!("$__graphd_now_{n}"), format!("__graphd_now_{n}"), generate_timestamp())
72                }
73                _ => {
74                    let n = counters[2];
75                    counters[2] += 1;
76                    (format!("$__graphd_date_{n}"), format!("__graphd_date_{n}"), generate_date())
77                }
78            };
79            output.extend_from_slice(param_ref.as_bytes());
80            generated_params.push((param_name, serde_json::Value::String(param_value)));
81            i += consumed;
82        } else {
83            output.push(bytes[i]);
84            i += 1;
85        }
86    }
87
88    let query_str = unsafe { String::from_utf8_unchecked(output) };
89    let query_str = rewrite_remove(&query_str);
90
91    RewriteResult {
92        query: query_str,
93        generated_params,
94    }
95}
96
97/// Merge generated params into user-supplied params.
98/// Returns `None` if both are empty/absent. Otherwise returns a merged JSON object.
99pub fn merge_params(
100    user_params: Option<&serde_json::Value>,
101    generated: &[(String, serde_json::Value)],
102) -> Option<serde_json::Value> {
103    if generated.is_empty() {
104        return user_params.cloned();
105    }
106    let mut obj = match user_params.and_then(|p| p.as_object()) {
107        Some(o) => o.clone(),
108        None => serde_json::Map::new(),
109    };
110    for (key, val) in generated {
111        obj.insert(key.clone(), val.clone());
112    }
113    Some(serde_json::Value::Object(obj))
114}
115
116// ─── REMOVE rewrite ───
117
118const REMOVE_KW: &[u8] = b"REMOVE";
119
120/// Rewrite `REMOVE <expr>.<prop>` to `SET <expr>.<prop> = NULL`.
121///
122/// Handles single property removal only (not label removal or multi-item).
123/// Respects string literals — does not rewrite inside '...' or "...".
124/// Case-insensitive keyword matching with word boundary checks.
125fn rewrite_remove(query: &str) -> String {
126    let bytes = query.as_bytes();
127    let len = bytes.len();
128    let mut output = Vec::with_capacity(len);
129    let mut i = 0;
130    let mut in_single_quote = false;
131    let mut in_double_quote = false;
132    let mut changed = false;
133
134    while i < len {
135        // String literal tracking (same logic as rewrite_query)
136        if in_single_quote {
137            output.push(bytes[i]);
138            if bytes[i] == b'\'' {
139                if i + 1 < len && bytes[i + 1] == b'\'' {
140                    output.push(bytes[i + 1]);
141                    i += 2;
142                } else {
143                    in_single_quote = false;
144                    i += 1;
145                }
146            } else {
147                i += 1;
148            }
149            continue;
150        }
151        if in_double_quote {
152            output.push(bytes[i]);
153            if bytes[i] == b'"' {
154                in_double_quote = false;
155            }
156            i += 1;
157            continue;
158        }
159        if bytes[i] == b'\'' {
160            in_single_quote = true;
161            output.push(bytes[i]);
162            i += 1;
163            continue;
164        }
165        if bytes[i] == b'"' {
166            in_double_quote = true;
167            output.push(bytes[i]);
168            i += 1;
169            continue;
170        }
171
172        // Try to match REMOVE keyword
173        if i + REMOVE_KW.len() <= len
174            && bytes[i..i + REMOVE_KW.len()].eq_ignore_ascii_case(REMOVE_KW)
175        {
176            // Word boundary: not preceded by alphanumeric
177            let before_ok = i == 0 || !bytes[i - 1].is_ascii_alphanumeric();
178            // Word boundary: not followed by alphanumeric (after keyword)
179            let after_pos = i + REMOVE_KW.len();
180            let after_ok =
181                after_pos >= len || !bytes[after_pos].is_ascii_alphanumeric();
182
183            if before_ok && after_ok {
184                // Scan ahead: skip whitespace, then look for <expr>.<prop> pattern.
185                // A property expression is: identifier chars, then '.', then identifier chars.
186                let mut j = after_pos;
187                while j < len && bytes[j].is_ascii_whitespace() {
188                    j += 1;
189                }
190
191                if let Some((prop_end, has_dot)) = scan_property_expr(bytes, j) {
192                    if has_dot {
193                        // It's a property removal: REMOVE n.prop → SET n.prop = NULL
194                        output.extend_from_slice(b"SET ");
195                        // Copy the property expression preserving original case
196                        output.extend_from_slice(&bytes[j..prop_end]);
197                        output.extend_from_slice(b" = NULL");
198                        i = prop_end;
199                        changed = true;
200                        continue;
201                    }
202                }
203            }
204        }
205
206        output.push(bytes[i]);
207        i += 1;
208    }
209
210    if changed {
211        unsafe { String::from_utf8_unchecked(output) }
212    } else {
213        query.to_string()
214    }
215}
216
217/// Scan a property expression starting at `pos`.
218/// Returns `(end_pos, has_dot)` where `has_dot` indicates it's a property access (n.prop)
219/// vs a label expression (n:Label) which we don't rewrite.
220///
221/// Accepts identifiers with backtick quoting: `weird name`.prop
222fn scan_property_expr(bytes: &[u8], pos: usize) -> Option<(usize, bool)> {
223    let len = bytes.len();
224    if pos >= len {
225        return None;
226    }
227
228    // Scan first identifier (variable name): alphanumeric, underscore, or backtick-quoted
229    let mut i = scan_identifier(bytes, pos)?;
230
231    // Check what follows: '.' means property access, ':' means label, anything else = not a match
232    if i >= len || bytes[i] != b'.' {
233        return Some((i, false));
234    }
235    i += 1; // skip '.'
236
237    // Scan property name
238    let end = scan_identifier(bytes, i)?;
239    Some((end, true))
240}
241
242/// Scan a single Cypher identifier at `pos`. Returns end position.
243/// Handles plain identifiers (alphanumeric + underscore) and backtick-quoted identifiers.
244fn scan_identifier(bytes: &[u8], pos: usize) -> Option<usize> {
245    let len = bytes.len();
246    if pos >= len {
247        return None;
248    }
249    if bytes[pos] == b'`' {
250        // Backtick-quoted identifier
251        let mut i = pos + 1;
252        while i < len && bytes[i] != b'`' {
253            i += 1;
254        }
255        if i >= len {
256            return None; // unclosed backtick
257        }
258        Some(i + 1) // past closing backtick
259    } else if bytes[pos].is_ascii_alphabetic() || bytes[pos] == b'_' {
260        let mut i = pos + 1;
261        while i < len && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
262            i += 1;
263        }
264        Some(i)
265    } else {
266        None
267    }
268}
269
270// ─── Internals ───
271
272/// Function name patterns to match (case-insensitive). Order matters:
273/// check `current_timestamp` before `current_date` since it's longer.
274const FUNC_NAMES: &[&[u8]] = &[
275    b"gen_random_uuid",    // index 0
276    b"current_timestamp",  // index 1
277    b"current_date",       // index 2
278];
279
280/// Try to match a non-deterministic function call at byte position `pos`.
281/// Returns `(func_index, bytes_consumed)` on match.
282fn try_match_func(bytes: &[u8], pos: usize) -> Option<(usize, usize)> {
283    for (idx, func_name) in FUNC_NAMES.iter().enumerate() {
284        let name_len = func_name.len();
285        if pos + name_len > bytes.len() {
286            continue;
287        }
288        if !bytes[pos..pos + name_len].eq_ignore_ascii_case(func_name) {
289            continue;
290        }
291        // Skip optional whitespace after function name
292        let mut j = pos + name_len;
293        while j < bytes.len() && bytes[j].is_ascii_whitespace() {
294            j += 1;
295        }
296        // Expect '('
297        if j >= bytes.len() || bytes[j] != b'(' {
298            continue;
299        }
300        j += 1;
301        // Skip whitespace inside parens
302        while j < bytes.len() && bytes[j].is_ascii_whitespace() {
303            j += 1;
304        }
305        // Expect ')'
306        if j < bytes.len() && bytes[j] == b')' {
307            return Some((idx, j + 1 - pos));
308        }
309    }
310    None
311}
312
313/// Generate an ISO 8601 timestamp string from the current system time (UTC).
314/// Format: `YYYY-MM-DDThh:mm:ss.uuuuuu`
315fn generate_timestamp() -> String {
316    let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
317    let total_secs = dur.as_secs();
318    let micros = dur.subsec_micros();
319    let days = (total_secs / 86400) as i64;
320    let day_secs = total_secs % 86400;
321    let h = day_secs / 3600;
322    let m = (day_secs % 3600) / 60;
323    let s = day_secs % 60;
324    let (y, mo, d) = days_to_ymd(days);
325    format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}.{micros:06}")
326}
327
328/// Generate an ISO 8601 date string from the current system time (UTC).
329/// Format: `YYYY-MM-DD`
330fn generate_date() -> String {
331    let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
332    let days = (dur.as_secs() / 86400) as i64;
333    let (y, m, d) = days_to_ymd(days);
334    format!("{y:04}-{m:02}-{d:02}")
335}
336
337/// Convert days since Unix epoch (1970-01-01) to (year, month, day).
338/// Howard Hinnant's civil_from_days algorithm.
339fn days_to_ymd(days: i64) -> (i32, u32, u32) {
340    let z = days + 719468;
341    let era = (if z >= 0 { z } else { z - 146096 }) / 146097;
342    let doe = (z - era * 146097) as u32;
343    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
344    let y = yoe as i64 + era * 400;
345    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
346    let mp = (5 * doy + 2) / 153;
347    let d = doy - (153 * mp + 2) / 5 + 1;
348    let m = if mp < 10 { mp + 3 } else { mp - 9 };
349    let y = if m <= 2 { y + 1 } else { y };
350    (y as i32, m, d)
351}
352
353#[cfg(test)]
354mod tests {
355    use super::*;
356
357    #[test]
358    fn test_no_rewrite_plain_query() {
359        let r = rewrite_query("MATCH (n:Person) RETURN n.name");
360        assert_eq!(r.query, "MATCH (n:Person) RETURN n.name");
361        assert!(r.generated_params.is_empty());
362    }
363
364    #[test]
365    fn test_no_rewrite_return_literal() {
366        let r = rewrite_query("RETURN 42 AS x");
367        assert_eq!(r.query, "RETURN 42 AS x");
368        assert!(r.generated_params.is_empty());
369    }
370
371    #[test]
372    fn test_rewrite_gen_random_uuid() {
373        let r = rewrite_query("CREATE (:T {id: gen_random_uuid()})");
374        assert_eq!(r.query, "CREATE (:T {id: $__graphd_uuid_0})");
375        assert_eq!(r.generated_params.len(), 1);
376        assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
377        // Value should be a valid UUID
378        let val = r.generated_params[0].1.as_str().unwrap();
379        assert!(uuid::Uuid::parse_str(val).is_ok(), "Not a valid UUID: {val}");
380    }
381
382    #[test]
383    fn test_rewrite_current_timestamp() {
384        let r = rewrite_query("RETURN current_timestamp() AS ts");
385        assert_eq!(r.query, "RETURN $__graphd_now_0 AS ts");
386        assert_eq!(r.generated_params.len(), 1);
387        assert_eq!(r.generated_params[0].0, "__graphd_now_0");
388        let val = r.generated_params[0].1.as_str().unwrap();
389        // Should match ISO 8601: YYYY-MM-DDThh:mm:ss.uuuuuu
390        assert!(val.len() >= 26, "Timestamp too short: {val}");
391        assert_eq!(&val[4..5], "-");
392        assert_eq!(&val[7..8], "-");
393        assert_eq!(&val[10..11], "T");
394        assert_eq!(&val[13..14], ":");
395        assert_eq!(&val[16..17], ":");
396        assert_eq!(&val[19..20], ".");
397    }
398
399    #[test]
400    fn test_rewrite_current_date() {
401        let r = rewrite_query("RETURN current_date() AS d");
402        assert_eq!(r.query, "RETURN $__graphd_date_0 AS d");
403        assert_eq!(r.generated_params.len(), 1);
404        assert_eq!(r.generated_params[0].0, "__graphd_date_0");
405        let val = r.generated_params[0].1.as_str().unwrap();
406        // Should match YYYY-MM-DD
407        assert_eq!(val.len(), 10, "Date wrong length: {val}");
408        assert_eq!(&val[4..5], "-");
409        assert_eq!(&val[7..8], "-");
410    }
411
412    #[test]
413    fn test_rewrite_multiple_same_function() {
414        let r = rewrite_query("CREATE (:T {a: gen_random_uuid(), b: gen_random_uuid()})");
415        assert_eq!(r.query, "CREATE (:T {a: $__graphd_uuid_0, b: $__graphd_uuid_1})");
416        assert_eq!(r.generated_params.len(), 2);
417        assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
418        assert_eq!(r.generated_params[1].0, "__graphd_uuid_1");
419        // Values should be distinct
420        assert_ne!(r.generated_params[0].1, r.generated_params[1].1);
421    }
422
423    #[test]
424    fn test_rewrite_mixed_functions() {
425        let r = rewrite_query(
426            "CREATE (:T {id: gen_random_uuid(), ts: current_timestamp(), d: current_date()})",
427        );
428        assert_eq!(
429            r.query,
430            "CREATE (:T {id: $__graphd_uuid_0, ts: $__graphd_now_0, d: $__graphd_date_0})"
431        );
432        assert_eq!(r.generated_params.len(), 3);
433        assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
434        assert_eq!(r.generated_params[1].0, "__graphd_now_0");
435        assert_eq!(r.generated_params[2].0, "__graphd_date_0");
436    }
437
438    #[test]
439    fn test_no_rewrite_in_single_quotes() {
440        let r = rewrite_query("RETURN 'gen_random_uuid()' AS s");
441        assert_eq!(r.query, "RETURN 'gen_random_uuid()' AS s");
442        assert!(r.generated_params.is_empty());
443    }
444
445    #[test]
446    fn test_no_rewrite_in_double_quotes() {
447        let r = rewrite_query("RETURN \"gen_random_uuid()\" AS s");
448        assert_eq!(r.query, "RETURN \"gen_random_uuid()\" AS s");
449        assert!(r.generated_params.is_empty());
450    }
451
452    #[test]
453    fn test_escaped_single_quotes() {
454        // Cypher uses '' to escape a single quote inside a string
455        let r = rewrite_query("RETURN 'it''s gen_random_uuid()' AS s");
456        assert_eq!(r.query, "RETURN 'it''s gen_random_uuid()' AS s");
457        assert!(r.generated_params.is_empty());
458    }
459
460    #[test]
461    fn test_case_insensitive() {
462        let r1 = rewrite_query("RETURN GEN_RANDOM_UUID()");
463        assert_eq!(r1.query, "RETURN $__graphd_uuid_0");
464        assert_eq!(r1.generated_params.len(), 1);
465
466        let r2 = rewrite_query("RETURN Gen_Random_Uuid()");
467        assert_eq!(r2.query, "RETURN $__graphd_uuid_0");
468        assert_eq!(r2.generated_params.len(), 1);
469
470        let r3 = rewrite_query("RETURN CURRENT_TIMESTAMP()");
471        assert_eq!(r3.query, "RETURN $__graphd_now_0");
472
473        let r4 = rewrite_query("RETURN CURRENT_DATE()");
474        assert_eq!(r4.query, "RETURN $__graphd_date_0");
475    }
476
477    #[test]
478    fn test_whitespace_between_name_and_parens() {
479        let r = rewrite_query("RETURN gen_random_uuid ()");
480        assert_eq!(r.query, "RETURN $__graphd_uuid_0");
481        assert_eq!(r.generated_params.len(), 1);
482
483        let r2 = rewrite_query("RETURN gen_random_uuid\t( )");
484        assert_eq!(r2.query, "RETURN $__graphd_uuid_0");
485        assert_eq!(r2.generated_params.len(), 1);
486    }
487
488    #[test]
489    fn test_no_match_without_parens() {
490        let r = rewrite_query("RETURN gen_random_uuid AS alias");
491        assert_eq!(r.query, "RETURN gen_random_uuid AS alias");
492        assert!(r.generated_params.is_empty());
493    }
494
495    #[test]
496    fn test_no_match_with_args() {
497        let r = rewrite_query("RETURN gen_random_uuid(42)");
498        assert_eq!(r.query, "RETURN gen_random_uuid(42)");
499        assert!(r.generated_params.is_empty());
500    }
501
502    #[test]
503    fn test_preserves_surrounding_text() {
504        let r = rewrite_query("SELECT 1; gen_random_uuid(); SELECT 2");
505        assert_eq!(r.query, "SELECT 1; $__graphd_uuid_0; SELECT 2");
506    }
507
508    #[test]
509    fn test_merge_params_empty() {
510        let merged = merge_params(None, &[]);
511        assert!(merged.is_none());
512    }
513
514    #[test]
515    fn test_merge_params_only_user() {
516        let user = serde_json::json!({"name": "Alice"});
517        let merged = merge_params(Some(&user), &[]);
518        assert_eq!(merged, Some(user));
519    }
520
521    #[test]
522    fn test_merge_params_only_generated() {
523        let gen = vec![("__graphd_uuid_0".to_string(), serde_json::json!("abc-123"))];
524        let merged = merge_params(None, &gen).unwrap();
525        assert_eq!(merged["__graphd_uuid_0"], "abc-123");
526    }
527
528    #[test]
529    fn test_merge_params_both() {
530        let user = serde_json::json!({"name": "Alice"});
531        let gen = vec![("__graphd_uuid_0".to_string(), serde_json::json!("abc-123"))];
532        let merged = merge_params(Some(&user), &gen).unwrap();
533        assert_eq!(merged["name"], "Alice");
534        assert_eq!(merged["__graphd_uuid_0"], "abc-123");
535    }
536
537    #[test]
538    fn test_days_to_ymd_epoch() {
539        assert_eq!(days_to_ymd(0), (1970, 1, 1));
540    }
541
542    #[test]
543    fn test_days_to_ymd_known_date() {
544        // 2024-01-15 is 19737 days after epoch
545        assert_eq!(days_to_ymd(19737), (2024, 1, 15));
546    }
547
548    #[test]
549    fn test_days_to_ymd_leap_year() {
550        // 2024-02-29 is 19782 days after epoch
551        assert_eq!(days_to_ymd(19782), (2024, 2, 29));
552    }
553
554    #[test]
555    fn test_generated_uuid_is_valid_v4() {
556        let r = rewrite_query("RETURN gen_random_uuid()");
557        let val = r.generated_params[0].1.as_str().unwrap();
558        let parsed = uuid::Uuid::parse_str(val).unwrap();
559        assert_eq!(parsed.get_version_num(), 4);
560    }
561
562    // ─── REMOVE rewrite tests ───
563
564    #[test]
565    fn test_remove_property() {
566        let r = rewrite_query("MATCH (n:Person) REMOVE n.age");
567        assert_eq!(r.query, "MATCH (n:Person) SET n.age = NULL");
568    }
569
570    #[test]
571    fn test_remove_property_case_insensitive() {
572        let r = rewrite_query("MATCH (n) remove n.prop");
573        assert_eq!(r.query, "MATCH (n) SET n.prop = NULL");
574
575        let r2 = rewrite_query("MATCH (n) Remove n.prop");
576        assert_eq!(r2.query, "MATCH (n) SET n.prop = NULL");
577    }
578
579    #[test]
580    fn test_remove_property_extra_whitespace() {
581        let r = rewrite_query("MATCH (n) REMOVE   n.prop");
582        assert_eq!(r.query, "MATCH (n) SET n.prop = NULL");
583    }
584
585    #[test]
586    fn test_remove_preserves_surrounding_query() {
587        let r = rewrite_query("MATCH (n:Person) REMOVE n.age RETURN n");
588        assert_eq!(r.query, "MATCH (n:Person) SET n.age = NULL RETURN n");
589    }
590
591    #[test]
592    fn test_remove_underscore_identifiers() {
593        let r = rewrite_query("MATCH (my_node) REMOVE my_node.some_prop");
594        assert_eq!(r.query, "MATCH (my_node) SET my_node.some_prop = NULL");
595    }
596
597    #[test]
598    fn test_remove_backtick_variable() {
599        let r = rewrite_query("MATCH (`my node`) REMOVE `my node`.prop");
600        assert_eq!(r.query, "MATCH (`my node`) SET `my node`.prop = NULL");
601    }
602
603    #[test]
604    fn test_remove_backtick_property() {
605        let r = rewrite_query("MATCH (n) REMOVE n.`weird prop`");
606        assert_eq!(r.query, "MATCH (n) SET n.`weird prop` = NULL");
607    }
608
609    #[test]
610    fn test_remove_not_in_string_literal() {
611        let r = rewrite_query("RETURN 'REMOVE n.prop' AS s");
612        assert_eq!(r.query, "RETURN 'REMOVE n.prop' AS s");
613    }
614
615    #[test]
616    fn test_remove_not_in_double_quote_string() {
617        let r = rewrite_query("RETURN \"REMOVE n.prop\" AS s");
618        assert_eq!(r.query, "RETURN \"REMOVE n.prop\" AS s");
619    }
620
621    #[test]
622    fn test_remove_label_not_rewritten() {
623        // REMOVE n:Label is label removal — not rewritable to SET
624        let r = rewrite_query("MATCH (n) REMOVE n:SomeLabel");
625        // Should pass through unchanged (no dot = not a property removal)
626        assert_eq!(r.query, "MATCH (n) REMOVE n:SomeLabel");
627    }
628
629    #[test]
630    fn test_remove_word_boundary() {
631        // "REMOVED" should not match (alphanumeric after keyword)
632        let r = rewrite_query("RETURN REMOVED AS alias");
633        assert_eq!(r.query, "RETURN REMOVED AS alias");
634    }
635
636    #[test]
637    fn test_remove_combined_with_function_rewrite() {
638        // Both rewrites should apply in the same query
639        let r = rewrite_query("MATCH (n) REMOVE n.ts SET n.id = gen_random_uuid()");
640        assert_eq!(
641            r.query,
642            "MATCH (n) SET n.ts = NULL SET n.id = $__graphd_uuid_0"
643        );
644        assert_eq!(r.generated_params.len(), 1);
645    }
646}