Skip to main content

graphd_engine/
query.rs

1use tracing::warn;
2
3use crate::error::GraphdError;
4use crate::journal_types::{self, JournalCommand, JournalSender, PendingEntry};
5use crate::values::{self, json_params_to_lbug, GraphValue};
6
7/// Result of executing a query via `run_query_raw`, including journal-relevant info.
8pub struct RawExecution<'db> {
9    pub query_result: lbug::QueryResult<'db>,
10    pub columns: Vec<String>,
11    /// The rewritten query (with non-deterministic functions replaced).
12    pub rewritten_query: String,
13    /// Merged params (user + generated). None if no params.
14    pub merged_params: Option<serde_json::Value>,
15}
16
17/// Result of executing a query via `run_query`, with all rows materialized.
18#[derive(Debug)]
19pub struct ExecutedQuery {
20    pub columns: Vec<String>,
21    pub rows: Vec<Vec<GraphValue>>,
22    /// The rewritten query (with non-deterministic functions replaced).
23    pub rewritten_query: String,
24    /// Merged params (user + generated). None if no params.
25    pub merged_params: Option<serde_json::Value>,
26}
27
28/// Execute a query and return the raw QueryResult, column names, timing,
29/// and the rewritten query + merged params for journaling.
30pub fn run_query_raw<'db>(
31    conn: &lbug::Connection<'db>,
32    query: &str,
33    params: Option<&serde_json::Value>,
34) -> Result<RawExecution<'db>, GraphdError> {
35    // Rewrite non-deterministic functions (gen_random_uuid, current_timestamp, current_date)
36    // to parameter references with concrete generated values.
37    let rewrite = crate::rewriter::rewrite_query(query);
38    let query_str = rewrite.query.clone();
39    let query = &rewrite.query;
40    let merged = crate::rewriter::merge_params(params, &rewrite.generated_params);
41    let params = merged.as_ref();
42
43    let has_params = params
44        .and_then(|p| p.as_object())
45        .map_or(false, |o| !o.is_empty());
46
47    let result = if has_params {
48        match json_params_to_lbug(params.unwrap()) {
49            Ok(owned) => {
50                let refs: Vec<(&str, lbug::Value)> =
51                    owned.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
52                match conn.prepare(query) {
53                    Ok(mut prepared) => conn
54                        .execute(&mut prepared, refs)
55                        .map_err(|e| GraphdError::SyntaxError(format!("{e}"))),
56                    Err(e) => Err(GraphdError::SyntaxError(format!("{e}"))),
57                }
58            }
59            Err(e) => Err(e),
60        }
61    } else {
62        conn.query(query)
63            .map_err(|e| GraphdError::SyntaxError(format!("{e}")))
64    };
65
66    let merged_params = merged.clone();
67
68    match result {
69        Ok(qr) => {
70            let columns = qr.get_column_names();
71            Ok(RawExecution {
72                query_result: qr,
73                columns,
74                rewritten_query: query_str,
75                merged_params,
76            })
77        }
78        Err(e) => Err(e),
79    }
80}
81
82/// Execute a query with pre-converted lbug params (used by Bolt path to avoid JSON intermediary).
83///
84/// The rewriter still generates JSON params for non-deterministic functions; these are
85/// converted to lbug values and merged with the caller-supplied params.
86#[cfg(feature = "bolt")]
87pub fn run_query_raw_bolt<'db>(
88    conn: &lbug::Connection<'db>,
89    query: &str,
90    bolt_params: Option<Vec<(String, lbug::Value)>>,
91) -> Result<RawExecution<'db>, GraphdError> {
92    let rewrite = crate::rewriter::rewrite_query(query);
93    let query_str = rewrite.query.clone();
94    let query = &rewrite.query;
95
96    // Merge bolt params with rewriter-generated params
97    let mut params = bolt_params.unwrap_or_default();
98    for (key, json_val) in &rewrite.generated_params {
99        params.push((key.clone(), values::to_lbug_value(json_val)?));
100    }
101
102    // For journaling, serialize params back to JSON
103    let merged_json = if params.is_empty() {
104        None
105    } else {
106        let mut map = serde_json::Map::new();
107        for (k, v) in &params {
108            map.insert(k.clone(), serde_json::Value::String(format!("{v:?}")));
109        }
110        Some(serde_json::Value::Object(map))
111    };
112
113    let result = if params.is_empty() {
114        conn.query(query)
115            .map_err(|e| GraphdError::SyntaxError(format!("{e}")))
116    } else {
117        let refs: Vec<(&str, lbug::Value)> =
118            params.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
119        match conn.prepare(query) {
120            Ok(mut prepared) => conn
121                .execute(&mut prepared, refs)
122                .map_err(|e| GraphdError::SyntaxError(format!("{e}"))),
123            Err(e) => Err(GraphdError::SyntaxError(format!("{e}"))),
124        }
125    };
126
127    match result {
128        Ok(qr) => {
129            let columns = qr.get_column_names();
130            Ok(RawExecution {
131                query_result: qr,
132                columns,
133                rewritten_query: query_str,
134                merged_params: merged_json,
135            })
136        }
137        Err(e) => Err(e),
138    }
139}
140
141/// Take up to `limit` rows from a QueryResult. Returns (rows, has_more).
142/// Uses `buf` to buffer a peeked row across calls — pass `&mut None` for one-shot reads.
143pub(crate) fn take_rows(
144    result: &mut lbug::QueryResult<'_>,
145    limit: usize,
146    buf: &mut Option<Vec<GraphValue>>,
147) -> (Vec<Vec<GraphValue>>, bool) {
148    let mut rows = Vec::new();
149    if let Some(row) = buf.take() {
150        rows.push(row);
151    }
152    while rows.len() < limit {
153        match result.next() {
154            Some(row) => rows.push(row.iter().map(|v| values::from_lbug_value(v)).collect()),
155            None => return (rows, false),
156        }
157    }
158    // Peek one more to determine has_more without losing the row.
159    match result.next() {
160        Some(row) => {
161            *buf = Some(row.iter().map(|v| values::from_lbug_value(v)).collect());
162            (rows, true)
163        }
164        None => (rows, false),
165    }
166}
167
168/// Execute a single query, collecting all rows.
169pub fn run_query(
170    conn: &lbug::Connection<'_>,
171    query: &str,
172    params: Option<&serde_json::Value>,
173) -> Result<ExecutedQuery, GraphdError> {
174    let mut raw = run_query_raw(conn, query, params)?;
175    let (rows, _) = take_rows(&mut raw.query_result, usize::MAX, &mut None);
176    Ok(ExecutedQuery {
177        columns: raw.columns,
178        rows,
179        rewritten_query: raw.rewritten_query,
180        merged_params: raw.merged_params,
181    })
182}
183
184/// Send a journal entry for a successful mutation (no-op if journal is disabled or query is read-only).
185pub fn journal_entry(
186    journal: &Option<JournalSender>,
187    query: &str,
188    params: &Option<serde_json::Value>,
189) {
190    if let Some(ref tx) = journal {
191        if journal_types::is_mutation(query) {
192            if tx
193                .send(JournalCommand::Write(PendingEntry {
194                    query: query.to_string(),
195                    params: params.clone(),
196                }))
197                .is_err()
198            {
199                warn!("Journal write failed: channel disconnected (mutation not journaled)");
200            }
201        }
202    }
203}