1use crate::sparql_ast::*;
6use crate::sparql_executor::QueryExecutor;
7use crate::sparql_parser;
8use crate::sparql_planner::QueryPlanner;
9use crate::NQuin;
10
11use std::collections::HashMap;
12
13#[repr(C)]
15#[derive(Debug, Clone, Copy)]
16pub struct ServiceEndpoint {
17 pub did: u64, pub endpoint_url: u64, pub auth_method: u8, pub timeout_ms: u32,
21}
22
23#[repr(C)]
25#[derive(Debug, Clone, Copy)]
26pub struct FederatedResult {
27 pub endpoint_did: u64,
28 pub row_count: u16,
29 pub success: bool,
30}
31
32pub struct FederatedQueryHandler<'a> {
36 pub local_quins: &'a [NQuin],
37 pub endpoints: [Option<ServiceEndpoint>; 16],
38 pub endpoint_count: u8,
39 pub cache_enabled: bool,
40 endpoint_urls: HashMap<u64, String>,
43}
44
45impl<'a> FederatedQueryHandler<'a> {
46 pub fn new(quins: &'a [NQuin]) -> Self {
48 Self {
49 local_quins: quins,
50 endpoints: [None; 16],
51 endpoint_count: 0,
52 cache_enabled: true,
53 endpoint_urls: HashMap::new(),
54 }
55 }
56
57 pub fn set_endpoint_url(&mut self, did: u64, url: &str) {
60 self.endpoint_urls.insert(did, url.to_string());
61 }
62
63 pub fn register_endpoint(&mut self, endpoint: ServiceEndpoint) -> Result<u8, String> {
65 if self.endpoint_count >= 16 {
66 return Err("Endpoint overflow".to_string());
67 }
68 let idx = self.endpoint_count;
69 self.endpoints[idx as usize] = Some(endpoint);
70 self.endpoint_count += 1;
71 Ok(idx)
72 }
73
74 pub fn resolve_did(&self, did: u64) -> Result<u64, String> {
76 for i in 0..self.endpoint_count as usize {
83 if let Some(endpoint) = self.endpoints[i] {
84 if endpoint.did == did {
85 return Ok(endpoint.endpoint_url);
86 }
87 }
88 }
89
90 Err("DID not found in endpoint registry".to_string())
91 }
92
93 pub fn execute_service(
102 &self,
103 did: u64,
104 query: &str,
105 _format: &str,
106 ) -> Result<FederatedResult, String> {
107 let endpoint = (0..self.endpoint_count as usize)
108 .filter_map(|i| self.endpoints[i])
109 .find(|e| e.did == did)
110 .ok_or("DID not found in endpoint registry")?;
111 if endpoint.auth_method != 0 {
112 return Err(
113 "authenticated (DID-LD/JWT) federation must be signed by the \
114 identity layer; only no-auth remote endpoints are dispatched here"
115 .to_string(),
116 );
117 }
118 let url = self.endpoint_urls.get(&did).ok_or(
119 "no resolvable endpoint URL registered for this DID (call set_endpoint_url); \
120 the endpoint_url hash is not reversible",
121 )?;
122 let body = fetch_remote_sparql(url, query, endpoint.timeout_ms, None)?;
123 let (_vars, rows, _lexicon) = parse_sparql_results_json(&body)?;
124 Ok(FederatedResult {
125 endpoint_did: did,
126 row_count: rows.len() as u16,
127 success: true,
128 })
129 }
130
131 pub fn execute_federated(
133 &self,
134 _service_did: u64,
135 _service_query: &str,
136 _local_pattern: PatternId,
137 _ctx: &SparqlQueryContext,
138 ) -> Result<Vec<BindingRow>, String> {
139 Ok(vec![])
157 }
158
159 pub fn check_cors_allowed(&self, did: u64, origin_did: u64) -> Result<bool, String> {
161 Ok(did == origin_did)
168 }
169
170 pub fn generate_cors_headers(&self, did: u64) -> Result<Vec<(u64, u64)>, String> {
172 let access_control_origin: u64 = 0x41432D4F72696769; let access_control_methods: u64 = 0x41432D4D65746F64; let access_control_headers: u64 = 0x41432D4865616465; Ok(vec![
180 (access_control_origin, did), (access_control_methods, 0x4745540000000000_u64), (access_control_headers, 0x436F6E74656E742D_u64), ])
184 }
185}
186
187impl<'a> Default for FederatedQueryHandler<'a> {
188 fn default() -> Self {
189 Self::new(&[])
190 }
191}
192
193#[derive(Debug, Clone)]
207pub struct FederatedService {
208 pub endpoint: String,
210 pub auth_method: u8,
212 pub timeout_ms: u32,
214}
215
216impl FederatedService {
217 pub fn new(endpoint: &str) -> Self {
219 Self {
220 endpoint: endpoint.to_string(),
221 auth_method: 0,
222 timeout_ms: 30_000,
223 }
224 }
225
226 pub fn is_local(&self) -> bool {
229 self.endpoint.starts_with("local:") || self.endpoint.starts_with("qualia:")
230 }
231
232 pub fn local_graph(&self) -> Option<&str> {
235 if let Some(rest) = self.endpoint.strip_prefix("local:") {
236 return Some(rest);
237 }
238 if let Some(rest) = self.endpoint.strip_prefix("qualia:") {
239 return Some(rest);
240 }
241 None
242 }
243}
244
245#[derive(Debug, Clone)]
247pub struct FederatedQueryResult {
248 pub service_endpoint: String,
250 pub query: String,
252 pub results: Vec<BindingRow>,
256 pub variables: Vec<String>,
259 pub lexicon: LiteralTable,
263 pub success: bool,
265 pub error: Option<String>,
267 pub remote_query_url: Option<String>,
270}
271
272impl FederatedQueryResult {
273 pub fn row_count(&self) -> usize {
275 self.results.len()
276 }
277}
278
279#[derive(Debug, Clone)]
281pub struct FederatedQuery {
282 pub services: Vec<FederatedService>,
284 pub query: String,
286}
287
288impl FederatedQuery {
289 pub fn new(query: &str) -> Self {
291 Self {
292 services: Vec::new(),
293 query: query.to_string(),
294 }
295 }
296
297 pub fn with_service(mut self, service: FederatedService) -> Self {
299 self.services.push(service);
300 self
301 }
302}
303
304pub struct FederatedQueryEngine<'a> {
314 pub local_quins: &'a [NQuin],
316 pub services: HashMap<String, FederatedService>,
318 pub initialized: bool,
320}
321
322impl<'a> FederatedQueryEngine<'a> {
323 pub fn new(quins: &'a [NQuin]) -> Self {
325 Self {
326 local_quins: quins,
327 services: HashMap::new(),
328 initialized: false,
329 }
330 }
331
332 pub fn initialize(&mut self) -> Result<(), String> {
336 self.initialized = true;
340 Ok(())
341 }
342
343 pub fn register_service(&mut self, service: FederatedService) {
346 self.services.insert(service.endpoint.clone(), service);
347 }
348
349 pub fn list_services(&self) -> Vec<String> {
351 let mut endpoints: Vec<String> = self.services.keys().cloned().collect();
352 endpoints.sort();
353 endpoints
354 }
355
356 pub fn execute_service(
366 &self,
367 service: &FederatedService,
368 query: &str,
369 ) -> Result<FederatedQueryResult, String> {
370 if service.is_local() {
371 let (sparql_query, ctx) = match sparql_parser::parse_sparql(query) {
373 Ok(parsed) => parsed,
374 Err(e) => {
375 return Ok(Self::failed(
376 service,
377 query,
378 format!("Parse error: {e}"),
379 None,
380 ))
381 }
382 };
383 let plan = match QueryPlanner::plan(&sparql_query, &ctx) {
384 Ok(plan) => plan,
385 Err(e) => {
386 return Ok(Self::failed(
387 service,
388 query,
389 format!("Planning error: {e}"),
390 None,
391 ))
392 }
393 };
394 let executor = QueryExecutor::new(self.local_quins);
395 match executor.execute(&plan, &ctx) {
396 Ok(results) => Ok(FederatedQueryResult {
397 service_endpoint: service.endpoint.clone(),
398 query: query.to_string(),
399 results,
400 variables: Vec::new(),
401 lexicon: LiteralTable::new(),
402 success: true,
403 error: None,
404 remote_query_url: None,
405 }),
406 Err(e) => Ok(Self::failed(
407 service,
408 query,
409 format!("Execution error: {e}"),
410 None,
411 )),
412 }
413 } else {
414 let query_url = build_remote_query_url(&service.endpoint, query);
422 match fetch_remote_sparql(&service.endpoint, query, service.timeout_ms, None) {
423 Ok(body) => match parse_sparql_results_json(&body) {
424 Ok((variables, results, lexicon)) => Ok(FederatedQueryResult {
425 service_endpoint: service.endpoint.clone(),
426 query: query.to_string(),
427 results,
428 variables,
429 lexicon,
430 success: true,
431 error: None,
432 remote_query_url: Some(query_url),
433 }),
434 Err(e) => Ok(Self::failed(
435 service,
436 query,
437 format!("Remote result parse error: {e}"),
438 Some(query_url),
439 )),
440 },
441 Err(e) => Ok(Self::failed(service, query, e, Some(query_url))),
442 }
443 }
444 }
445
446 fn failed(
448 service: &FederatedService,
449 query: &str,
450 error: String,
451 remote_query_url: Option<String>,
452 ) -> FederatedQueryResult {
453 FederatedQueryResult {
454 service_endpoint: service.endpoint.clone(),
455 query: query.to_string(),
456 results: Vec::new(),
457 variables: Vec::new(),
458 lexicon: LiteralTable::new(),
459 success: false,
460 error: Some(error),
461 remote_query_url,
462 }
463 }
464
465 pub fn execute_federated(
472 &self,
473 query: &FederatedQuery,
474 ) -> Result<Vec<FederatedQueryResult>, String> {
475 if !self.initialized {
476 return Err("FederatedQueryEngine not initialized".to_string());
477 }
478 if query.services.is_empty() {
479 return Err("Federated query has no services".to_string());
480 }
481
482 let mut results = Vec::with_capacity(query.services.len());
483 for service in &query.services {
484 let result = self.execute_service(service, &query.query)?;
487 results.push(result);
488 }
489 Ok(results)
490 }
491}
492
493impl<'a> Default for FederatedQueryEngine<'a> {
494 fn default() -> Self {
495 Self::new(&[])
496 }
497}
498
499fn build_remote_query_url(endpoint: &str, query: &str) -> String {
503 let encoded = percent_encode_query(query);
504 let separator = if endpoint.contains('?') { '&' } else { '?' };
505 format!("{}{}query={}", endpoint, separator, encoded)
506}
507
508fn percent_encode_query(input: &str) -> String {
511 let mut out = String::with_capacity(input.len());
512 for &b in input.as_bytes() {
513 let unreserved = b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~');
515 if unreserved {
516 out.push(b as char);
517 } else {
518 out.push('%');
519 out.push_str(&format!("{:02X}", b));
520 }
521 }
522 out
523}
524
525#[cfg(not(target_arch = "wasm32"))]
535fn fetch_remote_sparql(
536 endpoint: &str,
537 query: &str,
538 timeout_ms: u32,
539 auth: Option<&str>,
540) -> Result<String, String> {
541 let endpoint = endpoint.to_string();
542 let query = query.to_string();
543 let auth = auth.map(|s| s.to_string());
544 std::thread::spawn(move || -> Result<String, String> {
545 let client = reqwest::blocking::Client::builder()
546 .timeout(std::time::Duration::from_millis(timeout_ms.max(1) as u64))
547 .build()
548 .map_err(|e| format!("http client build failed: {e}"))?;
549 let mut req = client
550 .post(&endpoint)
551 .header(reqwest::header::CONTENT_TYPE, "application/sparql-query")
552 .header(reqwest::header::ACCEPT, "application/sparql-results+json")
553 .body(query);
554 if let Some(a) = auth {
555 req = req.header(reqwest::header::AUTHORIZATION, a);
556 }
557 let resp = req
558 .send()
559 .map_err(|e| format!("remote request failed: {e}"))?;
560 let status = resp.status();
561 let text = resp
562 .text()
563 .map_err(|e| format!("reading remote response failed: {e}"))?;
564 if !status.is_success() {
565 let snippet: String = text.chars().take(200).collect();
566 return Err(format!("remote endpoint returned HTTP {status}: {snippet}"));
567 }
568 Ok(text)
569 })
570 .join()
571 .map_err(|_| "remote fetch thread panicked".to_string())?
572}
573
574#[cfg(target_arch = "wasm32")]
576fn fetch_remote_sparql(
577 _endpoint: &str,
578 _query: &str,
579 _timeout_ms: u32,
580 _auth: Option<&str>,
581) -> Result<String, String> {
582 Err("remote SPARQL federation is not available on the wasm target".to_string())
583}
584
585fn parse_sparql_results_json(
591 body: &str,
592) -> Result<(Vec<String>, Vec<BindingRow>, LiteralTable), String> {
593 let v: serde_json::Value =
594 serde_json::from_str(body).map_err(|e| format!("invalid SPARQL results JSON: {e}"))?;
595 let mut lexicon = LiteralTable::new();
596
597 if let Some(b) = v.get("boolean").and_then(|b| b.as_bool()) {
599 let mut row = BindingRow::new();
600 row.slots[0] = Some(if b { 1 } else { 0 });
601 return Ok((Vec::new(), vec![row], lexicon));
602 }
603
604 let vars: Vec<String> = v
605 .get("head")
606 .and_then(|h| h.get("vars"))
607 .and_then(|a| a.as_array())
608 .map(|a| {
609 a.iter()
610 .filter_map(|x| x.as_str().map(String::from))
611 .collect()
612 })
613 .unwrap_or_default();
614
615 let bindings = v
616 .get("results")
617 .and_then(|r| r.get("bindings"))
618 .and_then(|b| b.as_array())
619 .cloned()
620 .unwrap_or_default();
621
622 let mut rows = Vec::with_capacity(bindings.len());
623 for binding in &bindings {
624 let mut row = BindingRow::new();
625 for (i, var) in vars.iter().enumerate() {
626 if i >= MAX_BINDINGS {
627 break; }
629 if let Some(term) = binding.get(var) {
630 let value = term.get("value").and_then(|x| x.as_str()).unwrap_or("");
631 let lang = term.get("xml:lang").and_then(|x| x.as_str());
632 let datatype = term.get("datatype").and_then(|x| x.as_str());
633 let hash = crate::sparql_ast::literal_term_hash(value, lang, datatype);
636 lexicon.intern_tagged(hash, value, lang, datatype);
637 row.slots[i] = Some(hash);
638 }
639 }
640 rows.push(row);
641 }
642 Ok((vars, rows, lexicon))
643}
644
645pub struct DidCorsHelper;
647
648impl DidCorsHelper {
649 pub fn verify_did_signature(
658 _did: u64,
659 _signature: u64,
660 _challenge: u64,
661 ) -> Result<bool, String> {
662 Err(
663 "DID signature verification must be performed by the identity/key-vault layer \
664 (the SPARQL federation layer holds no keys); refusing to fabricate a result"
665 .to_string(),
666 )
667 }
668
669 pub fn generate_challenge(did: u64) -> u64 {
671 did ^ 0xDEADBEEFCAFEBABE
673 }
674}
675
676#[cfg(test)]
677mod tests {
678 use super::*;
679
680 #[test]
681 fn test_federated_handler_creation() {
682 let quins = vec![];
683 let handler = FederatedQueryHandler::new(&quins);
684 assert_eq!(handler.endpoint_count, 0);
685 }
686
687 #[test]
688 fn test_register_endpoint() {
689 let quins = vec![];
690 let mut handler = FederatedQueryHandler::new(&quins);
691
692 let endpoint = ServiceEndpoint {
693 did: 1,
694 endpoint_url: 2,
695 auth_method: 0,
696 timeout_ms: 5000,
697 };
698
699 let result = handler.register_endpoint(endpoint);
700 assert!(result.is_ok());
701 assert_eq!(handler.endpoint_count, 1);
702 }
703
704 #[test]
705 fn test_resolve_did() {
706 let quins = vec![];
707 let mut handler = FederatedQueryHandler::new(&quins);
708
709 let endpoint = ServiceEndpoint {
710 did: 123,
711 endpoint_url: 456,
712 auth_method: 0,
713 timeout_ms: 5000,
714 };
715
716 handler.register_endpoint(endpoint).unwrap();
717 let url_hash = handler.resolve_did(123).unwrap();
718 assert_eq!(url_hash, 456);
719 }
720
721 #[test]
722 fn test_cors_check() {
723 let quins = vec![];
724 let handler = FederatedQueryHandler::new(&quins);
725
726 let allowed = handler.check_cors_allowed(123, 123).unwrap();
727 assert!(allowed);
728
729 let not_allowed = handler.check_cors_allowed(123, 456).unwrap();
730 assert!(!not_allowed);
731 }
732
733 #[test]
734 fn test_did_signature_verification_fails_closed() {
735 assert!(DidCorsHelper::verify_did_signature(123, 456, 789).is_err());
738 }
739
740 #[test]
743 fn test_engine_creation() {
744 let quins = vec![];
745 let engine = FederatedQueryEngine::new(&quins);
746 assert!(!engine.initialized);
747 assert!(engine.services.is_empty());
748 }
749
750 #[test]
751 fn test_engine_initialize() {
752 let quins = vec![];
753 let mut engine = FederatedQueryEngine::new(&quins);
754 assert!(!engine.initialized);
755 engine.initialize().unwrap();
756 assert!(engine.initialized);
757 }
758
759 #[test]
760 fn test_register_and_list_services() {
761 let quins = vec![];
762 let mut engine = FederatedQueryEngine::new(&quins);
763 engine.register_service(FederatedService::new("local:default"));
764 engine.register_service(FederatedService::new("https://remote.example.org/sparql"));
765
766 let services = engine.list_services();
767 assert_eq!(services.len(), 2);
768 assert!(services.contains(&"local:default".to_string()));
769 assert!(services.contains(&"https://remote.example.org/sparql".to_string()));
770 }
771
772 #[test]
773 fn test_register_service_overwrites() {
774 let quins = vec![];
775 let mut engine = FederatedQueryEngine::new(&quins);
776 let mut svc = FederatedService::new("local:default");
777 svc.auth_method = 0;
778 engine.register_service(svc);
779 let mut svc2 = FederatedService::new("local:default");
780 svc2.auth_method = 2;
781 engine.register_service(svc2);
782
783 assert_eq!(engine.list_services().len(), 1);
785 assert_eq!(engine.services.get("local:default").unwrap().auth_method, 2);
786 }
787
788 #[test]
789 fn test_service_is_local() {
790 assert!(FederatedService::new("local:default").is_local());
791 assert!(FederatedService::new("qualia:graph1").is_local());
792 assert!(!FederatedService::new("https://remote.example.org/sparql").is_local());
793 assert!(!FederatedService::new("http://remote.example.org/sparql").is_local());
794 }
795
796 #[test]
797 fn test_service_local_graph() {
798 assert_eq!(
799 FederatedService::new("local:default").local_graph(),
800 Some("default")
801 );
802 assert_eq!(
803 FederatedService::new("qualia:graph1").local_graph(),
804 Some("graph1")
805 );
806 assert_eq!(
807 FederatedService::new("https://remote.example.org/sparql").local_graph(),
808 None
809 );
810 }
811
812 #[test]
813 fn test_execute_service_local() {
814 let quins = vec![];
815 let engine = FederatedQueryEngine::new(&quins);
816 let service = FederatedService::new("local:default");
817 let result = engine
818 .execute_service(&service, "SELECT ?s WHERE { ?s ?p ?o }")
819 .unwrap();
820 assert_eq!(result.service_endpoint, "local:default");
821 assert!(
822 result.success,
823 "local execution should succeed: {:?}",
824 result.error
825 );
826 assert!(result.remote_query_url.is_none());
827 assert_eq!(result.row_count(), 0);
829 }
830
831 #[test]
832 fn test_execute_service_local_parse_error() {
833 let quins = vec![];
834 let engine = FederatedQueryEngine::new(&quins);
835 let service = FederatedService::new("local:default");
836 let result = engine
837 .execute_service(&service, "this is not sparql")
838 .unwrap();
839 assert!(!result.success);
840 assert!(result.error.is_some());
841 assert_eq!(result.row_count(), 0);
842 }
843
844 #[test]
845 #[ignore = "makes a real (localhost) network connection — integration test"]
846 fn test_execute_service_remote_unreachable_fails_gracefully() {
847 let quins = vec![];
848 let engine = FederatedQueryEngine::new(&quins);
849 let mut service = FederatedService::new("http://127.0.0.1:1/sparql");
850 service.timeout_ms = 300;
851 let result = engine
852 .execute_service(&service, "SELECT ?s WHERE { ?s ?p ?o }")
853 .unwrap();
854 assert!(!result.success);
857 assert!(result.error.is_some());
858 assert!(result.remote_query_url.is_some());
859 assert_eq!(result.row_count(), 0);
860 }
861
862 #[test]
863 fn test_execute_federated_across_local_services() {
864 let quins = vec![];
866 let mut engine = FederatedQueryEngine::new(&quins);
867 engine.initialize().unwrap();
868
869 let query = FederatedQuery::new("SELECT ?s WHERE { ?s ?p ?o }")
870 .with_service(FederatedService::new("local:default"))
871 .with_service(FederatedService::new("qualia:graph1"));
872
873 let results = engine.execute_federated(&query).unwrap();
874 assert_eq!(results.len(), 2);
875 assert_eq!(results[0].service_endpoint, "local:default");
876 assert!(results[0].success);
877 assert!(results[0].remote_query_url.is_none());
878 assert_eq!(results[1].service_endpoint, "qualia:graph1");
879 assert!(results[1].success);
880 }
881
882 #[test]
883 fn test_parse_sparql_results_json_select() {
884 let body = r#"{
887 "head": { "vars": ["s", "name", "age"] },
888 "results": { "bindings": [
889 { "s": {"type":"uri","value":"http://ex/a"},
890 "name": {"type":"literal","xml:lang":"en","value":"Alice"},
891 "age": {"type":"literal","datatype":"http://www.w3.org/2001/XMLSchema#integer","value":"30"} }
892 ] }
893 }"#;
894 let (vars, rows, lexicon) = parse_sparql_results_json(body).unwrap();
895 assert_eq!(vars, vec!["s", "name", "age"]);
896 assert_eq!(rows.len(), 1);
897 let name_hash = rows[0].slots[1].unwrap();
898 assert_eq!(lexicon.resolve(name_hash), Some("Alice"));
899 assert_eq!(lexicon.lang(name_hash), Some("en"));
900 let age_hash = rows[0].slots[2].unwrap();
901 assert_eq!(
902 lexicon.datatype(age_hash),
903 Some("http://www.w3.org/2001/XMLSchema#integer")
904 );
905 }
906
907 #[test]
908 fn test_parse_sparql_results_json_ask() {
909 let (vars, rows, _lex) =
910 parse_sparql_results_json(r#"{ "head": {}, "boolean": true }"#).unwrap();
911 assert!(vars.is_empty());
912 assert_eq!(rows.len(), 1);
913 assert_eq!(rows[0].slots[0], Some(1));
914 }
915
916 #[test]
917 fn test_execute_federated_not_initialized() {
918 let quins = vec![];
919 let engine = FederatedQueryEngine::new(&quins);
920 let query = FederatedQuery::new("SELECT ?s WHERE { ?s ?p ?o }")
921 .with_service(FederatedService::new("local:default"));
922 let err = engine.execute_federated(&query).unwrap_err();
923 assert!(err.contains("not initialized"));
924 }
925
926 #[test]
927 fn test_execute_federated_no_services() {
928 let quins = vec![];
929 let mut engine = FederatedQueryEngine::new(&quins);
930 engine.initialize().unwrap();
931 let query = FederatedQuery::new("SELECT ?s WHERE { ?s ?p ?o }");
932 let err = engine.execute_federated(&query).unwrap_err();
933 assert!(err.contains("no services"));
934 }
935
936 #[test]
937 fn test_percent_encode_query() {
938 let encoded = percent_encode_query("SELECT ?s WHERE { ?s ?p ?o }");
939 assert!(!encoded.contains(' '));
940 assert!(encoded.contains("SELECT"));
941 assert!(encoded.contains("%3F"));
943 }
944
945 #[test]
946 fn test_build_remote_query_url_joins_with_ampersand_when_query_present() {
947 let url = build_remote_query_url("https://example.org/sparql?dataset=foo", "SELECT ?s");
949 assert!(url.contains("&query="));
950 assert!(!url.contains(' '));
951 }
952
953 #[test]
954 fn test_build_remote_query_url() {
955 let url = build_remote_query_url("https://example.org/sparql", "SELECT ?s");
956 assert!(url.starts_with("https://example.org/sparql?query="));
957 assert!(!url.contains(' '));
958 }
959}