.

inference/src/service.rs

@@ -110,60 +110,82 @@ impl Ontology for OntologyService {
             ONTOLOGY_GRAPH.into_owned()
         };
 
-        let mut evaluator = SparqlEvaluator::new();
-        for (name, iri) in &request.prefixes {
-            evaluator = evaluator.with_prefix(name, iri)
-                .map_err(|err| Status::internal(err.to_string()))?;
-        }
-
-        if let Some(base) = &request.base {
-            evaluator = evaluator.with_base_iri(base)
-                .map_err(|err| Status::internal(err.to_string()))?;
-        }
-
-        let mut query = evaluator.parse_query(&request.sparql_query)
-            .map_err(|err| Status::internal(err.to_string()))?;
-
-        query.dataset_mut().set_default_graph(vec![graph_name.clone()]);
-
-        let results = query.on_store(&self.ontology)
-            .execute()
-            .map_err(|err| Status::internal(err.to_string()))?;
-
         let mut output_buffer = Vec::new();
-        match results {
-            QueryResults::Boolean(result) => {
-                let serializer = QueryResultsSerializer::from_format(QueryResultsFormat::Json);
-                output_buffer = serializer.serialize_boolean_to_writer(output_buffer, result)
+        if let Some(sparql_query) = &request.sparql_query {
+            let mut evaluator = SparqlEvaluator::new();
+            for (name, iri) in &request.prefixes {
+                evaluator = evaluator.with_prefix(name, iri)
                     .map_err(|err| Status::internal(err.to_string()))?;
             }
-            QueryResults::Solutions(solutions) => {
-                let serializer = QueryResultsSerializer::from_format(QueryResultsFormat::Json);
-                let variables = Vec::from_iter(solutions.variables().iter().cloned());
-                let mut writer = serializer.serialize_solutions_to_writer(output_buffer, variables)?;
-                for solution in solutions.filter_map(Result::ok) {
-                    writer.serialize(&solution)?;
-                }
-                output_buffer = writer.finish()?;
-            }
-            QueryResults::Graph(graph) => {
-                let mut serializer = RdfSerializer::from_format(RdfFormat::Turtle);
-                for (name, iri) in &request.prefixes {
-                    serializer = serializer.with_prefix(name, iri)
-                        .map_err(|err| Status::internal(err.to_string()))?;
-                }
-                if let Some(base) = &request.base {
-                    serializer = serializer.with_base_iri(base)
-                        .map_err(|err| Status::internal(err.to_string()))?;
-                }
 
-                let mut serializer = serializer.for_writer(output_buffer);
-                for triple in graph.filter_map(Result::ok) {
-                    serializer.serialize_triple(triple.as_ref())?;
-                }
-                output_buffer = serializer.finish()?;
+            if let Some(base) = &request.base {
+                evaluator = evaluator.with_base_iri(base)
+                    .map_err(|err| Status::internal(err.to_string()))?;
             }
+
+            let mut query = evaluator.parse_query(sparql_query)
+                .map_err(|err| Status::internal(err.to_string()))?;
+
+            query.dataset_mut().set_default_graph(vec![graph_name.clone()]);
+
+            let results = query.on_store(&self.ontology)
+                .execute()
+                .map_err(|err| Status::internal(err.to_string()))?;
+
+            match results {
+                QueryResults::Boolean(result) => {
+                    let serializer = QueryResultsSerializer::from_format(QueryResultsFormat::Json);
+                    output_buffer = serializer.serialize_boolean_to_writer(output_buffer, result)
+                        .map_err(|err| Status::internal(err.to_string()))?;
+                }
+                QueryResults::Solutions(solutions) => {
+                    let serializer = QueryResultsSerializer::from_format(QueryResultsFormat::Json);
+                    let variables = Vec::from_iter(solutions.variables().iter().cloned());
+                    let mut writer = serializer.serialize_solutions_to_writer(output_buffer, variables)?;
+                    for solution in solutions.filter_map(Result::ok) {
+                        writer.serialize(&solution)?;
+                    }
+                    output_buffer = writer.finish()?;
+                }
+                QueryResults::Graph(graph) => {
+                    let mut serializer = RdfSerializer::from_format(RdfFormat::Turtle);
+                    for (name, iri) in &request.prefixes {
+                        serializer = serializer.with_prefix(name, iri)
+                            .map_err(|err| Status::internal(err.to_string()))?;
+                    }
+                    if let Some(base) = &request.base {
+                        serializer = serializer.with_base_iri(base)
+                            .map_err(|err| Status::internal(err.to_string()))?;
+                    }
+
+                    let mut serializer = serializer.for_writer(output_buffer);
+                    for triple in graph.filter_map(Result::ok) {
+                        serializer.serialize_triple(triple.as_ref())?;
+                    }
+                    output_buffer = serializer.finish()?;
+                }
+            }
+        } else {
+            let mut serializer = RdfSerializer::from_format(RdfFormat::Turtle);
+            for (name, iri) in &request.prefixes {
+                serializer = serializer.with_prefix(name, iri)
+                    .map_err(|err| Status::internal(err.to_string()))?;
+            }
+            if let Some(base) = &request.base {
+                serializer = serializer.with_base_iri(base)
+                    .map_err(|err| Status::internal(err.to_string()))?;
+            }
+
+            let mut serializer = serializer.for_writer(output_buffer);
+            let graph = self.ontology
+                .quads_for_pattern(None, None, None, Some(graph_name.as_ref()))
+                .filter_map(Result::ok);
+            for triple in graph {
+                serializer.serialize_triple(triple.as_ref())?;
+            }
+            output_buffer = serializer.finish()?;
         }
+
         response.results = String::from_utf8_lossy(&output_buffer).to_string();
 
         if request.turtle.is_some() {