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
7pub struct RawExecution<'db> {
9 pub query_result: lbug::QueryResult<'db>,
10 pub columns: Vec<String>,
11 pub rewritten_query: String,
13 pub merged_params: Option<serde_json::Value>,
15}
16
17#[derive(Debug)]
19pub struct ExecutedQuery {
20 pub columns: Vec<String>,
21 pub rows: Vec<Vec<GraphValue>>,
22 pub rewritten_query: String,
24 pub merged_params: Option<serde_json::Value>,
26}
27
28pub 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 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#[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 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 let merged_json = if params.is_empty() {
104 None
105 } else {
106 let mut map = serde_json::Map::new();
107 for (k, v) in ¶ms {
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
141pub(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 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
168pub 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
184pub 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}