22763596638

Committed 06 Mar 2026 12:31PM UTC coverage: 51.142% (-0.08%) from 51.223%

Build Type

push

github

Committed by Ziroli

Commit Message

feat: support SPARQL CONSTRUCT query responses (issue #61)

- Broaden Accept header in QueryCall to include text/turtle and application/ld+json
- Add rdfContent field to ApiResponse for holding RDF model results
- Update QueryAccess.call() to detect Content-Type and dispatch to CSV or RDF parsing
- Add processRdfContent() hook to QueryAccess (default no-op, backward compatible)
- Update RunQuery to print Turtle when response is RDF

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Run Details

1020 of 2986 branches covered (34.16%)

Branch coverage included in aggregate %.

5228 of 9231 relevant lines covered (56.64%)

7.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.21

src/main/java/org/nanopub/extra/services/QueryAccess.java

package org.nanopub.extra.services;

import com.opencsv.CSVReader;
import com.opencsv.CSVWriterBuilder;
import com.opencsv.ICSVWriter;
import com.opencsv.exceptions.CsvValidationException;
import org.apache.http.HttpResponse;
import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.Rio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Writer;

/**
 * Second-generation query API access
 */
public abstract class QueryAccess {

    /**
     * Process the header.
     *
     * @param line the header line from the CSV response
     */
    protected abstract void processHeader(String[] line);

    /**
     * Process a line of data from the CSV response.
     *
     * @param line the line of data from the CSV response
     */
    protected abstract void processLine(String[] line);

    /**
     * Process the RDF content from a SPARQL CONSTRUCT query response.
     * Override this method to handle RDF responses. Default implementation is a no-op.
     *
     * @param model the parsed RDF model
     */
    protected void processRdfContent(Model model) {
    }

    /**
     * Call a query with the given queryId and parameters.
     *
     * @param queryRef the query reference
     * @throws FailedApiCallException         if the API call fails
     * @throws APINotReachableException       if the API is not reachable
     * @throws NotEnoughAPIInstancesException if there are not enough API instances available
     */
    public void call(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
        HttpResponse resp = QueryCall.run(queryRef);
        String contentType = resp.getFirstHeader("Content-Type") != null
                ? resp.getFirstHeader("Content-Type").getValue() : "";
        String mimeType = contentType.contains(";") ? contentType.split(";")[0].trim() : contentType.trim();
        if (mimeType.equals("text/csv") || mimeType.isEmpty()) {
            try (CSVReader csvReader = new CSVReader(new BufferedReader(new InputStreamReader(resp.getEntity().getContent())))) {
                String[] line = null;
                int n = 0;
                while ((line = csvReader.readNext()) != null) {
                    n++;
                    if (n == 1) {
                        processHeader(line);
                    } else {
                        processLine(line);
                    }
                }
            } catch (IOException | CsvValidationException ex) {
                throw new FailedApiCallException(ex);
            }
        } else {
            RDFFormat format = Rio.getParserFormatForMIMEType(mimeType).orElse(RDFFormat.TURTLE);
            try {
                Model model = Rio.parse(resp.getEntity().getContent(), format);
                processRdfContent(model);
            } catch (IOException ex) {
                throw new FailedApiCallException(ex);
            }
        }
    }

    /**
     * Print the response of a query in CSV format to the given writer.
     *
     * @param queryRef the query reference
     * @param writer   the writer to print the CSV response to
     * @throws FailedApiCallException         if the API call fails
     * @throws APINotReachableException       if the API is not reachable
     * @throws NotEnoughAPIInstancesException if there are not enough API instances available
     */
    public static void printCvsResponse(QueryRef queryRef, Writer writer) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
        ICSVWriter icsvWriter = new CSVWriterBuilder(writer).withSeparator(',').build();
        QueryAccess a = new QueryAccess() {

            @Override
            protected void processHeader(String[] line) {
                icsvWriter.writeNext(line);
            }

            @Override
            protected void processLine(String[] line) {
                icsvWriter.writeNext(line);
            }

        };
        a.call(queryRef);
        icsvWriter.flushQuietly();
    }

    /**
     * Get the response of a query as an ApiResponse object.
     *
     * @param queryRef the query reference
     * @return an ApiResponse object containing the response data
     * @throws FailedApiCallException         if the API call fails
     * @throws APINotReachableException       if the API is not reachable
     * @throws NotEnoughAPIInstancesException if there are not enough API instances available
     */
    public static ApiResponse get(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
        final ApiResponse response = new ApiResponse();
        QueryAccess a = new QueryAccess() {

            @Override
            protected void processHeader(String[] line) {
                response.setHeader(line);
            }

            @Override
            protected void processLine(String[] line) {
                response.add(line);
            }

            @Override
            protected void processRdfContent(Model model) {
                response.setRdfContent(model);
            }

        };
        a.call(queryRef);
        return response;
    }

}

1	package org.nanopub.extra.services;
2
3	import com.opencsv.CSVReader;
4	import com.opencsv.CSVWriterBuilder;
5	import com.opencsv.ICSVWriter;
6	import com.opencsv.exceptions.CsvValidationException;
7	import org.apache.http.HttpResponse;
8	import org.eclipse.rdf4j.model.Model;
9	import org.eclipse.rdf4j.rio.RDFFormat;
10	import org.eclipse.rdf4j.rio.Rio;
11
12	import java.io.BufferedReader;
13	import java.io.IOException;
14	import java.io.InputStreamReader;
15	import java.io.Writer;
16
17	/**
18	* Second-generation query API access
19	*/
20	public abstract class QueryAccess {	9✔
21
22	/**
23	* Process the header.
24	*
25	* @param line the header line from the CSV response
26	*/
27	protected abstract void processHeader(String[] line);
28
29	/**
30	* Process a line of data from the CSV response.
31	*
32	* @param line the line of data from the CSV response
33	*/
34	protected abstract void processLine(String[] line);
35
36	/**
37	* Process the RDF content from a SPARQL CONSTRUCT query response.
38	* Override this method to handle RDF responses. Default implementation is a no-op.
39	*
40	* @param model the parsed RDF model
41	*/
42	protected void processRdfContent(Model model) {
43	}	×
44
45	/**
46	* Call a query with the given queryId and parameters.
47	*
48	* @param queryRef the query reference
49	* @throws FailedApiCallException if the API call fails
50	* @throws APINotReachableException if the API is not reachable
51	* @throws NotEnoughAPIInstancesException if there are not enough API instances available
52	*/
53	public void call(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
54	HttpResponse resp = QueryCall.run(queryRef);	9✔
55	String contentType = resp.getFirstHeader("Content-Type") != null	12!
56	? resp.getFirstHeader("Content-Type").getValue() : "";	18✔
57	String mimeType = contentType.contains(";") ? contentType.split(";")[0].trim() : contentType.trim();	36!
58	if (mimeType.equals("text/csv") \|\| mimeType.isEmpty()) {	12!
59	try (CSVReader csvReader = new CSVReader(new BufferedReader(new InputStreamReader(resp.getEntity().getContent())))) {	39✔
60	String[] line = null;	6✔
61	int n = 0;	6✔
62	while ((line = csvReader.readNext()) != null) {	15✔
63	n++;	3✔
64	if (n == 1) {	9!
65	processHeader(line);	12✔
66	} else {
67	processLine(line);	×
68	}
69	}
70	} catch (IOException \| CsvValidationException ex) {	×
71	throw new FailedApiCallException(ex);	×
72	}	3✔
73	} else {
74	RDFFormat format = Rio.getParserFormatForMIMEType(mimeType).orElse(RDFFormat.TURTLE);	×
75	try {
76	Model model = Rio.parse(resp.getEntity().getContent(), format);	×
77	processRdfContent(model);	×
78	} catch (IOException ex) {	×
79	throw new FailedApiCallException(ex);	×
80	}	×
81	}
82	}	3✔
83
84	/**
85	* Print the response of a query in CSV format to the given writer.
86	*
87	* @param queryRef the query reference
88	* @param writer the writer to print the CSV response to
89	* @throws FailedApiCallException if the API call fails
90	* @throws APINotReachableException if the API is not reachable
91	* @throws NotEnoughAPIInstancesException if there are not enough API instances available
92	*/
93	public static void printCvsResponse(QueryRef queryRef, Writer writer) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
94	ICSVWriter icsvWriter = new CSVWriterBuilder(writer).withSeparator(',').build();	×
95	QueryAccess a = new QueryAccess() {	×
96
97	@Override
98	protected void processHeader(String[] line) {
99	icsvWriter.writeNext(line);	×
100	}	×
101
102	@Override
103	protected void processLine(String[] line) {
104	icsvWriter.writeNext(line);	×
105	}	×
106
107	};
108	a.call(queryRef);	×
109	icsvWriter.flushQuietly();	×
110	}	×
111
112	/**
113	* Get the response of a query as an ApiResponse object.
114	*
115	* @param queryRef the query reference
116	* @return an ApiResponse object containing the response data
117	* @throws FailedApiCallException if the API call fails
118	* @throws APINotReachableException if the API is not reachable
119	* @throws NotEnoughAPIInstancesException if there are not enough API instances available
120	*/
121	public static ApiResponse get(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
122	final ApiResponse response = new ApiResponse();	12✔
123	QueryAccess a = new QueryAccess() {	33✔
124
125	@Override
126	protected void processHeader(String[] line) {
127	response.setHeader(line);	12✔
128	}	3✔
129
130	@Override
131	protected void processLine(String[] line) {
132	response.add(line);	×
133	}	×
134
135	@Override
136	protected void processRdfContent(Model model) {
137	response.setRdfContent(model);	×
138	}	×
139
140	};
141	a.call(queryRef);	9✔
142	return response;	6✔
143	}
144
145	}

Nanopublication / nanopub-java / 22763596638

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous