1use crate::sparql_ast::*;
6use std::io::Write;
7
8pub struct ResultFormatter;
10
11impl ResultFormatter {
12 fn format_value_xml<W: Write>(
13 writer: &mut W,
14 value: u64,
15 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
16 ) -> std::io::Result<()> {
17 if (value & crate::resolver::MSB_FLAG) == 0
20 && (value & crate::resolver::INLINE_TAG_MASK) == crate::resolver::TAG_EMBEDDED
21 {
22 if let Some(lex) = lexicon {
23 if let Some([s, p, o]) = lex.lookup_embedded_triple(value) {
24 writeln!(writer, r#" <triple>"#)?;
25 writeln!(writer, r#" <subject>"#)?;
26 Self::format_value_xml(writer, s, lexicon)?;
27 writeln!(writer, r#" </subject>"#)?;
28 writeln!(writer, r#" <predicate>"#)?;
29 Self::format_value_xml(writer, p, lexicon)?;
30 writeln!(writer, r#" </predicate>"#)?;
31 writeln!(writer, r#" <object>"#)?;
32 Self::format_value_xml(writer, o, lexicon)?;
33 writeln!(writer, r#" </object>"#)?;
34 return writeln!(writer, r#" </triple>"#);
35 }
36 }
37 }
38
39 if let Some(lit) = crate::resolver::classify_inline_literal(value) {
42 return writeln!(
43 writer,
44 r#" <literal datatype="{}">{}</literal>"#,
45 lit.datatype_iri(),
46 lit
47 );
48 }
49
50 let uri = if let Some(bytes) = crate::resolver::resolve_hash(value) {
52 String::from_utf8_lossy(bytes).into_owned()
53 } else if (value & crate::resolver::MSB_FLAG) != 0 {
54 format!("did:q42:ptr/{:016x}", value & !crate::resolver::MSB_FLAG)
55 } else {
56 format!("urn:hash:{:016x}", value)
57 };
58 writeln!(writer, r#" <uri>{}</uri>"#, uri)
59 }
60
61 fn format_value_json<W: Write>(
62 writer: &mut W,
63 value: u64,
64 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
65 ) -> std::io::Result<()> {
66 if (value & crate::resolver::MSB_FLAG) == 0
70 && (value & crate::resolver::INLINE_TAG_MASK) == crate::resolver::TAG_EMBEDDED
71 {
72 if let Some(lex) = lexicon {
73 if let Some([s, p, o]) = lex.lookup_embedded_triple(value) {
74 writeln!(writer, r#" {{"#)?;
75 writeln!(writer, r#" "type": "triple","#)?;
76 writeln!(writer, r#" "value": {{"#)?;
77 write!(writer, r#" "subject": "#)?;
78 Self::format_value_json(writer, s, lexicon)?;
79 writeln!(writer, r#","#)?;
80 write!(writer, r#" "predicate": "#)?;
81 Self::format_value_json(writer, p, lexicon)?;
82 writeln!(writer, r#","#)?;
83 write!(writer, r#" "object": "#)?;
84 Self::format_value_json(writer, o, lexicon)?;
85 writeln!(writer, r#""#)?;
86 writeln!(writer, r#" }}"#)?;
87 return write!(writer, r#" }}"#);
88 }
89 }
90 }
91
92 if let Some(lit) = crate::resolver::classify_inline_literal(value) {
96 writeln!(writer, r#" {{"#)?;
97 writeln!(writer, r#" "type": "literal","#)?;
98 writeln!(writer, r#" "value": "{}","#, lit)?;
99 writeln!(writer, r#" "datatype": "{}""#, lit.datatype_iri())?;
100 return write!(writer, r#" }}"#);
101 }
102
103 let uri = if let Some(bytes) = crate::resolver::resolve_hash(value) {
107 String::from_utf8_lossy(bytes).into_owned()
108 } else if (value & crate::resolver::MSB_FLAG) != 0 {
109 format!("did:q42:ptr/{:016x}", value & !crate::resolver::MSB_FLAG)
110 } else {
111 format!("urn:hash:{:016x}", value)
112 };
113 writeln!(writer, r#" {{"#)?;
114 writeln!(writer, r#" "type": "uri","#)?;
115 writeln!(writer, r#" "value": "{}""#, uri)?;
116 write!(writer, r#" }}"#)
117 }
118
119 fn format_value_tsv<W: Write>(
120 writer: &mut W,
121 value: u64,
122 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
123 ) -> std::io::Result<()> {
124 if (value & crate::resolver::MSB_FLAG) == 0
128 && (value & crate::resolver::INLINE_TAG_MASK) == crate::resolver::TAG_EMBEDDED
129 {
130 if let Some(lex) = lexicon {
131 if let Some([s, p, o]) = lex.lookup_embedded_triple(value) {
132 write!(writer, "<<")?;
133 Self::format_value_tsv(writer, s, lexicon)?;
134 write!(writer, " ")?;
135 Self::format_value_tsv(writer, p, lexicon)?;
136 write!(writer, " ")?;
137 Self::format_value_tsv(writer, o, lexicon)?;
138 return write!(writer, ">>");
139 }
140 }
141 }
142
143 if let Some(lit) = crate::resolver::classify_inline_literal(value) {
146 return write!(writer, "\"{}\"^^<{}>", lit, lit.datatype_iri());
147 }
148
149 let uri = if let Some(bytes) = crate::resolver::resolve_hash(value) {
151 String::from_utf8_lossy(bytes).into_owned()
152 } else if (value & crate::resolver::MSB_FLAG) != 0 {
153 format!("did:q42:ptr/{:016x}", value & !crate::resolver::MSB_FLAG)
154 } else {
155 format!("urn:hash:{:016x}", value)
156 };
157 write!(writer, "<{}>", uri)
158 }
159
160 pub fn format_xml<W: Write>(
162 writer: &mut W,
163 variables: &[VariableId],
164 results: &[BindingRow],
165 ctx: &SparqlQueryContext,
166 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
167 ) -> std::io::Result<()> {
168 writeln!(writer, r#"<?xml version="1.0"?>"#)?;
169 writeln!(
170 writer,
171 r#"<sparql xmlns="http://www.w3.org/2005/sparql-results#">"#
172 )?;
173 writeln!(writer, r#" <head>"#)?;
174 writeln!(writer, r#" <variables>"#)?;
175
176 for var in variables {
177 let var_name = ctx.variable_hashes[*var as usize];
178 writeln!(writer, r#" <variable name="{}"/>"#, var_name)?;
179 }
180
181 writeln!(writer, r#" </variables>"#)?;
182 writeln!(writer, r#" </head>"#)?;
183 writeln!(writer, r#" <results>"#)?;
184
185 for row in results {
186 writeln!(writer, r#" <result>"#)?;
187 for var in variables {
188 let var_id = *var;
189 if let Some(value) = row.get(var_id) {
190 let var_name = ctx.variable_hashes[var_id as usize];
191 writeln!(writer, r#" <binding name="{}">"#, var_name)?;
192 Self::format_value_xml(writer, value, lexicon)?;
193 writeln!(writer, r#" </binding>"#)?;
194 }
195 }
196 writeln!(writer, r#" </result>"#)?;
197 }
198
199 writeln!(writer, r#" </results>"#)?;
200 writeln!(writer, r#"</sparql>"#)?;
201
202 Ok(())
203 }
204
205 pub fn format_json<W: Write>(
207 writer: &mut W,
208 variables: &[VariableId],
209 results: &[BindingRow],
210 ctx: &SparqlQueryContext,
211 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
212 ) -> std::io::Result<()> {
213 writeln!(writer, r#"{{"#)?;
214 writeln!(writer, r#" "head": {{"vars": ["#)?;
215
216 for (i, var) in variables.iter().enumerate() {
217 let var_name = ctx.variable_hashes[*var as usize];
218 if i > 0 {
219 write!(writer, r#", "#)?;
220 }
221 write!(writer, r#""{}""#, var_name)?;
222 }
223
224 writeln!(writer, r#"]}},"#)?;
225 writeln!(writer, r#" "results": {{"#)?;
226 writeln!(writer, r#" "bindings": ["#)?;
227
228 for (i, row) in results.iter().enumerate() {
229 if i > 0 {
230 writeln!(writer, r#","#)?;
231 }
232 writeln!(writer, r#" {{"#)?;
233
234 let mut first = true;
235 for var in variables {
236 let var_id = *var;
237 if let Some(value) = row.get(var_id) {
238 if !first {
239 writeln!(writer, r#","#)?;
240 }
241 first = false;
242 let var_name = ctx.variable_hashes[var_id as usize];
243 writeln!(writer, r#" "{}": "#, var_name)?;
244 Self::format_value_json(writer, value, lexicon)?;
245 }
246 }
247
248 if !first {
249 writeln!(writer)?
250 };
251 write!(writer, r#" }}"#)?;
252 }
253 writeln!(writer)?;
254
255 writeln!(writer, r#" ]"#)?;
256 writeln!(writer, r#" }}"#)?;
257 writeln!(writer, r#"}}"#)?;
258
259 Ok(())
260 }
261
262 pub fn format_tsv<W: Write>(
264 writer: &mut W,
265 variables: &[VariableId],
266 results: &[BindingRow],
267 ctx: &SparqlQueryContext,
268 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
269 ) -> std::io::Result<()> {
270 for (i, var) in variables.iter().enumerate() {
271 if i > 0 {
272 write!(writer, "\t")?;
273 }
274 write!(writer, "?{}", ctx.variable_hashes[*var as usize])?;
275 }
276 writeln!(writer)?;
277
278 for row in results {
279 for (i, var) in variables.iter().enumerate() {
280 if i > 0 {
281 write!(writer, "\t")?;
282 }
283 if let Some(value) = row.get(*var) {
284 Self::format_value_tsv(writer, value, lexicon)?;
285 }
286 }
287 writeln!(writer)?;
288 }
289 Ok(())
290 }
291
292 pub fn format_csv<W: Write>(
294 writer: &mut W,
295 variables: &[VariableId],
296 results: &[BindingRow],
297 ctx: &SparqlQueryContext,
298 lexicon: Option<&crate::q42_lex::Q42LexMmap>,
299 ) -> std::io::Result<()> {
300 for (i, var) in variables.iter().enumerate() {
301 if i > 0 {
302 write!(writer, ",")?;
303 }
304 write!(writer, "{}", ctx.variable_hashes[*var as usize])?;
305 }
306 writeln!(writer)?;
307
308 for row in results {
309 for (i, var) in variables.iter().enumerate() {
310 if i > 0 {
311 write!(writer, ",")?;
312 }
313 if let Some(value) = row.get(*var) {
314 let mut temp = Vec::new();
315 Self::format_value_tsv(&mut temp, value, lexicon)?;
316 let s = String::from_utf8_lossy(&temp);
317 if s.contains(',') || s.contains('"') || s.contains('\n') {
318 write!(writer, "\"{}\"", s.replace('"', "\"\""))?;
319 } else {
320 write!(writer, "{}", s)?;
321 }
322 }
323 }
324 writeln!(writer)?;
325 }
326 Ok(())
327 }
328
329 pub fn format_ntriples<W: Write>(
331 writer: &mut W,
332 results: &[BindingRow],
333 ) -> std::io::Result<()> {
334 for row in results {
335 let s = row.get(0).unwrap_or(0);
336 let p = row.get(1).unwrap_or(0);
337 let o = row.get(2).unwrap_or(0);
338 let quin = crate::NQuin {
339 subject: s,
340 predicate: p,
341 object: o,
342 context: 0,
343 metadata: 0,
344 parity: 0,
345 };
346 crate::resolver::format_ntriples_to(&[quin], writer)?;
347 }
348 Ok(())
349 }
350
351 pub fn format_ask_xml<W: Write>(writer: &mut W, result: bool) -> std::io::Result<()> {
353 writeln!(writer, r#"<?xml version="1.0"?>"#)?;
354 writeln!(
355 writer,
356 r#"<sparql xmlns="http://www.w3.org/2005/sparql-results#">"#
357 )?;
358 writeln!(writer, r#" <head></head>"#)?;
359 writeln!(writer, r#" <boolean>{}</boolean>"#, result)?;
360 writeln!(writer, r#"</sparql>"#)?;
361 Ok(())
362 }
363
364 #[cfg(test)]
365 fn value_json_string(value: u64) -> String {
366 let mut buf = Vec::new();
367 Self::format_value_json(&mut buf, value, None).unwrap();
368 String::from_utf8(buf).unwrap()
369 }
370
371 #[cfg(test)]
372 fn value_xml_string(value: u64) -> String {
373 let mut buf = Vec::new();
374 Self::format_value_xml(&mut buf, value, None).unwrap();
375 String::from_utf8(buf).unwrap()
376 }
377
378 #[cfg(test)]
379 fn value_tsv_string(value: u64) -> String {
380 let mut buf = Vec::new();
381 Self::format_value_tsv(&mut buf, value, None).unwrap();
382 String::from_utf8(buf).unwrap()
383 }
384
385 pub fn format_ask_json<W: Write>(writer: &mut W, result: bool) -> std::io::Result<()> {
387 writeln!(writer, r#"{{"#)?;
388 writeln!(writer, r#" "head": {{}},"#)?;
389 writeln!(writer, r#" "boolean": {}"#, result)?;
390 writeln!(writer, r#"}}"#)?;
391 Ok(())
392 }
393}
394
395#[cfg(test)]
396mod tests {
397 use super::ResultFormatter;
398 use crate::resolver::{
399 INLINE_TAG_BOOLEAN, INLINE_TAG_DECIMAL, INLINE_TAG_FLOAT, INLINE_TAG_INTEGER,
400 };
401
402 #[test]
406 fn inline_integer_serialises_as_typed_literal_json() {
407 let json = ResultFormatter::value_json_string(INLINE_TAG_INTEGER | 42);
408 assert!(json.contains(r#""type": "literal""#), "got: {json}");
409 assert!(json.contains(r#""value": "42""#), "got: {json}");
410 assert!(
411 json.contains("XMLSchema#integer"),
412 "expected xsd:integer datatype, got: {json}"
413 );
414 assert!(
415 !json.contains(r#""type": "uri""#),
416 "must not be a uri: {json}"
417 );
418 }
419
420 #[test]
421 fn inline_boolean_serialises_as_typed_literal_json() {
422 let json = ResultFormatter::value_json_string(INLINE_TAG_BOOLEAN | 1);
423 assert!(json.contains(r#""type": "literal""#), "got: {json}");
424 assert!(json.contains(r#""value": "true""#), "got: {json}");
425 assert!(json.contains("XMLSchema#boolean"), "got: {json}");
426 }
427
428 #[test]
429 fn inline_decimal_serialises_as_typed_literal_json() {
430 let json = ResultFormatter::value_json_string(INLINE_TAG_DECIMAL | 3_500_000);
432 assert!(json.contains("XMLSchema#decimal"), "got: {json}");
433 assert!(json.contains(r#""value": "3.500000""#), "got: {json}");
434 }
435
436 #[test]
437 fn inline_float_serialises_as_typed_literal_json() {
438 let val = INLINE_TAG_FLOAT | (0.5f32.to_bits() as u64);
439 let json = ResultFormatter::value_json_string(val);
440 assert!(json.contains("XMLSchema#float"), "got: {json}");
441 assert!(json.contains(r#""value": "0.5""#), "got: {json}");
442 }
443
444 #[test]
445 fn inline_integer_serialises_as_typed_literal_xml() {
446 let xml = ResultFormatter::value_xml_string(INLINE_TAG_INTEGER | 7);
447 assert!(xml.contains("<literal"), "expected <literal>, got: {xml}");
448 assert!(xml.contains("XMLSchema#integer"), "got: {xml}");
449 assert!(xml.contains(">7</literal>"), "got: {xml}");
450 assert!(!xml.contains("<uri>"), "must not be a <uri>: {xml}");
451 }
452
453 #[test]
454 fn unresolved_hash_still_serialises_as_uri_json() {
455 let json = ResultFormatter::value_json_string(0x0123_4567_89ab_cdef);
457 assert!(json.contains(r#""type": "uri""#), "got: {json}");
458 }
459
460 #[test]
464 fn inline_integer_serialises_as_typed_literal_tsv() {
465 let tsv = ResultFormatter::value_tsv_string(INLINE_TAG_INTEGER | 42);
466 assert!(tsv.contains(r#""42"^^<"#), "got: {tsv}");
467 assert!(tsv.contains("XMLSchema#integer"), "got: {tsv}");
468 assert!(!tsv.contains("<<"), "must not be an embedded triple: {tsv}");
469 }
470}