• SPARQL debugger for DBpedia queries • SPARQL query rewriting for expected and unexpected answers • Sound and complete rule and constraint based solving procedure • Web tool support DBpedia serves as the principal resource for Linked Open Data available on the Web and is currently the largest Knowledge Graph. Queries to DBpedia resources typically utilize the SPARQL query language through its SPARQL endpoint. Errors can occur within SPARQL queries. A recent study examining SPARQL endpoint executions found that 66.9% experience runtime errors, while 20.0% may not have errors but produce empty results. Ensuring a query is both error-free and aligned with user expectations presents a challenge. This paper introduces a debugging technique for DBpedia queries aimed at aligning a specific query with expected and unexpected answers. By converting SPARQL into rules, the debugger identifies query rewrites that meet these criteria. It employs constraint solving to determine filter conditions aligning with expected and unexpected results. A semantic characterization of query rewriting is defined, for which the proposed method has been proved to be sound and complete. The paper showcases the practical use of rule systems and constraint solving within databases, more specifically in SPARQL and DBpedia, facilitating real-time query adjustment to actual datasets.

During the last years, the study of fuzzy database query languages has attracted the attention of many researchers. In this line of research, our group has proposed and developed FSA-SPARQL ( Fuzzy Sets and Aggregators based SPARQL ), which is a fuzzy extension of the Semantic Web query language SPARQL. FSA-SPARQL works with fuzzy RDF datasets and allows the definition of fuzzy queries involving fuzzy conditions through fuzzy connectives and aggregators. However, there are two main challenges to be solved for the practical applicability of FSA-SPARQL . The first problem is the lack of fuzzy RDF data sources. The second is how to customize fuzzy queries on fuzzy RDF data sources. Our research group has also recently proposed a fuzzy logic programming language called F A S I L L that offers powerful tuning capabilities that can accept applications in many fields. The purpose of this paper is to show how the F A S I L L tuning capabilities serve to accomplish in a unified framework both challenges in FSA-SPARQL : data fuzzification and query customization. More concretely, from a FSA-SPARQL to F A S I L L transformation, data fuzzification and query customization in FSA-SPARQL become F A S I L L tuning problems. We have validated the approach with queries against datasets from online communities.

Metamorphic testing (MT) is a useful tool to test systems where an oracle is not available. MT relies on the definition of metamorphic relations (MR), that is, certain properties that relate a set of inputs and the set of outputs produced by the system under test (SUT) as response to these inputs. Usually, a violation of an MR implies that the SUT is faulty. However, some work on MT accepts, for certain SUTs, that the violation of an MRalmost alwaysis a symptom of an error but assumes the potential existence of false positives. This is the case, for instance, of our recent work where we applied MT to improve OpenStreetMap (OSM). Our MRs were able to uncover a large amount of errors in all the analyzed maps but we suffered the presence of a nonnegligible number of false positives. Therefore, an expert had to manually check the suspicious elements identified by our MRs. If we analyze large maps, then this manual task is unfeasible. In this article we solve the main limitation of our previous approach: we accurately and automatically discard false positives. Our new framework combines MT, along the same lines of our previous work, and machine learning. Specifically, we provide three models, one for each MR, based on the random forest model. The models were extensively trained with real data obtained from the application of MRs to maps of cities located in different continents. In order to evaluate the usefulness of our models, we tested them using different cities, in countries that were not considered in the training set. The results were very good: accuracy of the models is never lower than 0.90, it is usually much higher and in many situations reaches 1.0. The computation of the F1-scores yielded similar results.

We present a metamorphic testing approach to validate the information included in OpenStreetMap, a collaborative effort to produce a free map of the world. We focus on the quality of the tags storing the information about the elements of the map. We identified metamorphic relations with the potential to detect different types of tagging errors. In particular, we carefully designed mechanisms to automatically generatefollow-up inputs, a fundamental component in the successful application of a metamorphic testing approach. The intrinsic nature of automatically analysing tags implies that we will detect real errors but some false positives as well. In order to obtain a good trade-off between real errors and false positives, we introducethresholds. Our MRs will raise an error associated with a certain value if, depending on the nature of the MR, we have a certain number of elements (not) fulfilling a given condition. In order to evaluate the goodness and versatility of our framework, we chose four cities in different continents with the goal of analysing very heterogeneous contributors adding information in different languages. The application of this framework to the analysis of the chosen cities revealed errors in all of them and in all the considered categories. In addition, around 66% of the errors found by our MRs in the analysed areas have not been previously reported byOsmose, the de facto standard OSM error checker.

Aggregation is a very useful operation in database query languages. Through count, sum, min, max and avg operators database instances can be counted and summarized. Attached to such operators, group by and having clauses make it possible to define partitions on database instances as well as filter partitions according to Boolean conditions. In this paper, we define aggregation operators for the language FSA-SPARQL, which is a fuzzy extension of the Semantic Web query language SPARQL. We present the semantics of such operators with regard to fuzzy RDF triple patterns. We also provide mechanisms in FSA-SPARQL for the partition of fuzzy RDF triple patterns with regard to fuzzy sets, as well as for the filtering of partitions. The proposed extension has been implemented and it can be tested from the FSA-SPARQL Web site.

OpenStreetMap represents a collaborative effort of many different and unrelated users to create a free map of the world. Although contributors follow some general guidelines, unsupervised additions are prone to include erroneous information. Unfortunately, it is impossible to automatically detect most of these issues because there does not exist an oracle to evaluate whether the information is correct or not. Metamorphic testing has shown to be very useful in assessing the correctness of very heterogeneous artifacts when oracles are not available. The main goal of our work is to provide a (fully implemented) framework, based on metamorphic testing, that will support the analysis of the information provided in OpenStreetMap with the goal of detecting faulty information. We defined a general metamorphic testing framework to deal with OpenStreetMap. We identified a set of good metamorphic relations. In order to have as much automation as possible, we paid special attention to the automatic selection of follow-up inputs because they are fundamental to diminish manual testing. In order to assess the usefulness of our framework, we applied it to analyze maps of four cities in different continents. The rationale is that we would be dealing with different problems created by different contributors. We obtained experimental evidence that shows the potential value of our framework. The application of our framework to the analysis of the chosen cities revealed errors in all of them and in all the considered categories. The experiments showed the usefulness of our framework to identify potential issues in the information appearing in OpenStreetMap. Although our metamorphic relations are very helpful, future users of the framework might identify other relations to deal with specific situations not covered by our relations. Since we provide a general pattern to define metamorphic relations, it is relatively easy to extend the existing framework. In particular, since all our metamorphic relations are implemented and the code is freely available, users have a pattern to implement new relations.

We have recently designed FSA-SPARQL, an extension of the SPARQL query language for querying fuzzy RDF datasets. Answers of FSA-SPARQL queries are usually annotated with truth degrees which are computed from fuzzy connectives and operators that act on truth degrees associated to RDF triples. While FSA-SPARQL offers a rich repertoire of fuzzy connectives and operators, it is not always easy to retrieve the user's expected answers. This is very often due to wrong formulation of queries, caused by inadequate use/combination of fuzzy connectives, operators and thresholds. For instance, a high threshold for truth degrees in some RDF datasets can lead to an empty set of answers, some strong or weak restrictive combination of fuzzy conditions might produce few or too many answers, etc. On the other hand, our research group has also developed the fuzzy logic programming language $\mathcal{F}\mathcal{A}\mathcal{S}\mathcal{I}\mathcal{L}\mathcal{L}$, which has been equipped with tuning techniques for enabling the customization of queries from test cases. In this paper, our goals are: (1) to provide a FSA-SPARQL translation to $\mathcal{F}\mathcal{A}\mathcal{S}\mathcal{I}\mathcal{L}\mathcal{L}$ and (2) apply the tuning techniques to FSA-SPARQL queries for getting more precise formulation of queries from test cases.

In recent years, Open Street Map (OSM) has evolved into a highly popular geospatial system. The key of success of OSM is that OSM is open to absolutely everyone. OSM is not dependent on any one government, company, university or international organization. OSM is based on crowdsourcing, in which users collaborate to collect spatial data of urban and rural areas on the earth. With the arising of Linked Open Data (LOD) initiative, and more concretely with Linked Geo Open Data (LGOD), many Web resources have been made available to everyone, providing geo-located datasets. In this paper, a framework, called XOSM (XQuery for OpenStreetMap), for integrating and querying OSM and LGOD resources, is presented. The framework is equipped with a Web tool and a rich XQuery-based library, enabling the definition of queries combining OSM layers and layers created from LGOD resources (KML, GeoJSON, CSV and RDF (and also XML)). The framework also provides an API to execute XQuery queries using the library.

SPARQL has been adopted as query language for the Semantic Web. RDF and OWL have also been established as vocabularies to describe ontologies in this setting. While RDF/OWL/SPARQL have been designed for querying crisp information, some contexts require to manage uncertainty, vagueness and imprecise knowledge. In this paper a SPARQL extension, called FSA-SPARQL (Fuzzzy Sets and Aggregators based SPARQL) is proposed, in which queries can involve different fuzzy connectives and (aggregation) operators. The language has been implemented as an extension of the ARQ Jena SPARQL engine and it is equipped with a Web tool from which queries can be executed on-line.

Property-based testing has gained popularity in recent years in many areas of software development. The specification of assertions/properties helps to understand the semantics of pieces of code, and in modern programming environments, it can serve to test the program behavior. In this paper an XQuery property-based testing tool is presented, which enables to automatically test XQuery programs. The tool is able to systematically generate XML instances (i.e., test cases) from a given XML schema, and to filter XML instances with input properties specified by the programmer. Additionally, the tool automatically checks output (respectively, input-output) properties in each output instance (respectively, each pair of input-output instances). The tool is able to report whether the XQuery program passes the test, that is, if all the test cases satisfy the (input-)output property, as well as the number of test cases used for testing. In addition, if the XQuery program fails the test, the tool shows counterexamples found in the test cases. Properties are specified with XQuery Boolean functions, and the testing tool has been implemented in XQuery. Additionally, an XQuery path validation tool is presented. This tool is able to detect wrong paths in XQuery expressions. The path validation tool takes as input an XML schema, and it reports those paths on the XQuery program that do not match the XML schema. The path validation tool is a complement to the testing tool rejecting XQuery programs that do not conform to the XML schema. The path validation tool has been also implemented in XQuery. Finally, a web tool has been developed enabling to test and validate XQuery programs.

In this paper we present a tool for the automatic validation of XQuery programs. Firstly, the tool is able to detect wrong paths in XQuery expressions with respect to an XML Schema. Secondly, it makes possible the specification of input and output properties, as well as input-output properties (i.e., properties relating input and output data) of programs. Thirdly, the tool is able to filter randomly generated test cases with input properties, as well as to test output and input-output properties on randomly generated test cases and the corresponding output. It reports counterexamples when output or input-output properties are not satisfied. The tool has been implemented as an XQuery library which can be used from any XQuery interpreter.

Abstract Extensible Markup Language (XML)is a simple, very flexible text format derived from SGML. Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere.XPathlanguage is the result of an effort to provide address parts of an XML document. In support of this primary purpose, it becomes in aquery languageagainst an XML document. In this paper we present a proposal for the implementation of theXPathlanguage in logic programming. With this aim we will describe the representation of XML documents by means of alogic program.Rulesandfactscan be used for representing the document schema and the XML document itself. In particular, we will presenthow to index XML documentsin logic programs: rules are supposed to be stored inmain memory, however facts are stored insecondary memoryby using two kind of indexes: one for each XML tag, and other for each group of terminal items. In addition, we will study how to query by means of theXPathlanguage against a logic program representing an XML document. It evolves thespecialization of the logic programwith regard to theXPathexpression. Finally, we will also explain how tocombine the indexing and the top-down evaluationof the logic program.