Data integration systems provide a transparent access to heterogeneous, possibly distributed, sources; deductive database and their extensions allow to easily address complex issues arising in data integration. However, the gap between state-of-the-art deductive databases and data integration systems is still to be closed. In this paper we focus on some recent advancements implemented in the I-DLV system, and point out how these can facilitate the development of advanced data integration systems.
The task of an information integration system is to combine data residing at di erent sources, providing the user with a uni ed view called global schema. Users can formulate queries in a transparent and declarative way over the global schema: they do not need to be aware of details about the sources: the information integration system automatically retrieves relevant data from the sources, and suitably combines them to provide answers to user queries [16]. The global schema may also contain integrity constraints (such as key dependencies, inclusion dependencies, etc.).
Recent developments in IT, have made available a huge number of
information sources, typically autonomous, heterogeneous and widely distributed. As a
consequence, information integration has emerged as a crucial issue in several
application domains, e.g., distributed databases, cooperative information
systems, data warehousing, ontology-based data access, or on-demand computing.
Deductive database systems in general, and Answer Set Programming (ASP)
in particular, are powerful tools in this context, as demonstrated, for instance,
by the approaches formalized in [
In this paper we discuss some of the most recent database oriented innovations in ASP as implemented in the I-DLV system, and we point out how such improvements may enhance advanced data integration systems. 2
The I-DLV System
The I-DLV system [
I-DLV supports the ASP-Core-2 [
{ Body-reordering techniques aim at nding an optimal execution ordering
for the join operations, by varying the order of literals in the rule bodies.
Di erent orderings have been de ned for I-DLV; the one adopted by default
has been speci cally designed by considering the e ects of each literal on the
binding of variables [
Query answering in I-DLV is empowered with the magic-sets technique [
Customizability. I-DLV provides a ne-grained control over the whole computational process, allowing for enabling/disabling each one of the many optimization techniques both via command-line options and inline annotations. More in detail, I-DLV programs can be enriched by global and local annotations (i.e., on a per-rule basis), for customizing some machineries such as body ordering and indexing. For instance, the indexing schema of a speci c atom in a rule can be constrained to satisfy some speci c conditions, annotating the rule as follows: %@rule atom indexed(@atom=a(X,Y,Z), @arguments=f0,2g). when instantiating the annotated rule, the atom a(X; Y; Z) will be indexed, if possible, with a doubleindex on the rst and third arguments.
Since its release, I-DLV proved its reliability and e ciency as both ASP
grounder and deductive database engine. Recently, in the latest ASP
Competition [14] I-DLV ranked both as rst and second combined with an automatic
solver selector [12] that inductively chooses the best solver depending on some
inherent features of the instantiation produced, and with the state-of-the-art
solver clasp [13], respectively. Moreover, I-DLV performance results are
promising also as deductive database system [
In this section we brie y illustrate mechanisms and tools of I-DLV for (i) interoperability with external systems, (ii) accommodation of external sources of computation, and (iii) value invention/modi cation within logic programs. In particular, I-DLV supports direct connection with relational databases and SPARQL enabled ontologies via explicit import/export directives, and access to external data via calls to Python scripts with external atoms.
RDBMS Data Access. I-DLV can import relations from an RDBMS by means of an #import sql directive. For instance, #import sql(DB, "user", "pass", "SELECT * FROM t", p) can access database DB and import all tuples from table t into facts with predicate name p. Similarly, #export sql directives are used to populate speci c tables with the extension of a predicate.
Ontology-Based Data Access. Data can also be imported from local RDF/XML les and from remote EndPoints via SPARQL queries by means of directives of form: #import local sparql("file","query",pred name,pred arity[,types]). or #import remote sparql("endpoint url","query",pred name,pred arity[,types]). where query is a SPARQL statement de ning data to be imported and the optional types speci es the conversion for mapping data types to ASP-Core2 terms. For the local import, file can be either a local or remote URL pointing to an RDF/XML le: in the latter case, the le is downloaded and treated as a local RDF/XML le; in any case, the ontology graph is built in memory. As for the remote import, the endpoint url refers to a remote endpoint and building the graph is up to the remote server; this second option might be very convenient in case of large datasets.
Generic Data Access via Python scripts. Input programs can be enriched by external atoms of the form: &p(i1; : : : ; in; o1; : : : ; om), where p is the name of a Python function, i1; : : : ; in and o1; : : : ; om (n; m 0) are input and output terms, respectively. For each instantiation i01; : : : ; i0n of the input terms, function p is called with arguments i01; : : : ; i0n, and returns a set of instantiations for o1; : : : ; om. For instance, a single line of Python: def rev(s): s[::-1] is su cient to de ne a function rev that reverses strings, and which can be used within a rule of the following form: revW ord(Y ) :{ word(X); &rev(X; Y): External atoms give the user a powerful tool for signi cantly extending interoperability, granting access to virtually unlimited external data sources. Hence, additional import/export features to speci c semistructured or unstructured data sources can be externally de ned by suitable Python scripts. Obviously, \native" support for interoperability should be preferred whenever available. In fact, it is intuitive to understand that native support allows much better performance; experiments
OPTIMIZER DATA PROCESSOR Magic Sets
SkolEeTmLizer BIJnoodidneyxOOinprgtdimSetririzanatgtesigoiness
Hypertree Decompositions SQL
SPARQL PYTHON
reported in [
Value invention/modi cation. The availability of both external atoms and function symbols, included in the ASP-Core-2 compliance, allows to address very interesting issues from a database perspective. First of all, it is well known that function symbols allow to implement value invention by skolemization. This turns out to be a very useful feature when dealing with ontologies. Moreover, the generality of external atoms allows to include in logic rules data modi cation processes, typical of ETL work ows. In [26] we already described how external atoms may help data cleaning processes in a logic-based scenario. 3
Application of I-DLV Features for Data Integration The adoption of deductive database technology for data integration solutions is not new [16, 17, 25, 19, 23]; however, the recent developments on ASP described in this paper, allow a more concrete application of deductive systems in realworld applications requiring integration of heterogeneous data such as RDBMS, Ontologies and Semi-structured information sources. A general architecture for a modern integration system based on I-DLV is presented in Figure 1, where both main architectural elements and speci c I-DLV functionalities oriented to data integration are highlighted; these will be described next by layers.
The Data Layer, which comprises the set of input information sources, can handle several kind of data types: (i) standard databases can be directly accessed through the import sql directives included in I-DLV; (ii) graph databases, RDF ontologies, and more generally SPARQL-enabled ontologies, can be accessed by the import local sparql and import remote sparql directives; (iii) interoperability with any other kind of input format can be granted by external atoms relying on suitable Python scripts.
The Schema Layer includes everything that describes the data integration
context from a conceptual point of view, namely source and global schemas,
mappings and constraints, in a way similar to what has been widely studied in
the literature [16]. The support to this design phase could be provided by already
available external graphical tools, such as the one presented in [
The Evaluation Layer includes everything that allows to transform input data, schemas, and queries into answers in an e ective way. The core role is played by I-DLV which, as previously pointed out, has been incorporated as the grounding module of the DLV system. Here we concentrate our attention on three main logical portions: the Data Processor, the Optimizer, and the CQA Rewriter.
The Data Processor highlights some of the advanced functionalities included in I-DLV; in more detail, the general capabilities of Python-based external atoms put into play the possibility to include ETL processes inside the ASP engine. This is a particularly interesting innovation, since reasoning on deductive databases usually excluded ETL processes that were con ned to external work ows. Moreover, ASP-Core-2 compliance of the I-DLV language implies the possibility to exploit function symbols as predicate arguments; in a database oriented setting, this allows to easily simulate skolemization. This is a particularly interesting feature when ontologies are among the inputs; in fact, it is well known that, in particular cases, value invention in ontologies can be handled via skolemization. This opportunity signi cantly expands data integration potentialities of the system w.r.t. existing proposals. It is worth observing that, in a parallel project involving DLV, a more general extension of ASP supporting existentially quanti ed rule heads, and consequently more complex axioms in ontologies, named DLV9 , has been proposed [18]; however this language extension and the corresponding evaluation engine is not included in I-DLV yet.
The Optimizer applies to the resulting ASP program all database oriented optimizations previously outlined, and included in I-DLV. In more detail, magic sets, join optimizations, hypertree decompositions, body orderings and indexing strategies may altogether provide crucial speedup in query answering processes, thus allowing the adoption of the system in real application scenarios.
In order to complete the picture relative to the Evaluation Layer, it is worth observing that, if the global schema is equipped with constraints that must be satis ed during data integration, Consistent Query Answering techniques and optimizations such as the ones presented in [21, 22] can be applied. In Figure 1, this is represented as a functionality external to DLV since it is not included inside the engine yet. However, it would be straightforward to incorporate them inside the system since they are based on rewritings of ASP programs.
Finally, the Presentation Layer is devoted to allow users to compose queries
and get the corresponding results. Again available external graphical tools [
Future Work In this paper we brie y reported on the most recent advancements on the deductive system I-DLV for database oriented features, and we have shown their application to a data integration setting. In particular, reported features clearly show that data integration is still a very active and promising research area, which is kept strongly alive by new challenges arising from ontologies, semistructured and unstructured information sources. Given the positive results in terms of e ciency and extensibility we obtained for the I-DLV system, rst of all we plan to incorporate in I-DLV the features already developed in parallel projects, such as the CQA rewriting and optimizations techniques and the support to existential rules introduced in DLV9 for ontology querying. Moreover, we plan to explicitly implement connectors to di erent data formats. As a matter of facts, reasoning on top of big data is also part of ongoing projects in the research group. 12. Fusca, D., Calimeri, F., Zangari, J., Perri, S.: I-DLV+MS: preliminary report on an automatic ASP solver selector. In: RCRA@AI*IA. CEUR Workshop Proceedings, vol. 2011, pp. 26{32. CEUR-WS.org (2017) 13. Gebser, M., Kaminski, R., Kaufmann, B., Romero, J., Schaub, T.: Progress in clasp series 3. In: LPNMR. Lecture Notes in Computer Science, vol. 9345, pp. 368{383.
Springer (2015) 14. Gebser, M., Maratea, M., Ricca, F.: The sixth answer set programming competition. J. Artif. Intell. Res. 60, 41{95 (2017) 15. Lembo, D., Lenzerini, M., Rosati, R., Ruzzi, M., Savo, D.F.: Inconsistency-tolerant query answering in ontology-based data access. J. Web Sem. 33, 3{29 (2015) 16. Lenzerini, M.: Data integration: A theoretical perspective. In: PODS. pp. 233{246.
ACM (2002) 17. Leone, N., Gottlob, G., Rosati, R., Eiter, T., Faber, W., Fink, M., Greco, G., Ianni, G., Kalka, E., Lembo, D., Lenzerini, M., Lio, V., Nowicki, B., Ruzzi, M., Staniszkis, W., Terracina, G.: The INFOMIX System for Advanced Integration of Incomplete and Inconsistent Data. In: Proceedings of the 24th ACM SIGMOD International Conference on Management of Data (SIGMOD 2005). pp. 915{917. ACM Press, Baltimore, Maryland, USA (Jun 2005) 18. Leone, N., Manna, M., Terracina, G., Veltri, P.: E ciently computable datalog9 programs. In: KR. AAAI Press (2012) 19. Leone, N., Ricca, F., Rubino, L.A., Terracina, G.: E cient application of answer set programming for advanced data integration. In: PADL. Lecture Notes in Computer Science, vol. 5937, pp. 10{24. Springer (2010) 20. Liang, S., Fodor, P., Wan, H., Kifer, M.: OpenRuleBench: An Analysis of the Performance of Rule Engines. In: Proceedings of the 18th International Conference on World Wide Web, WWW 2009, Madrid, Spain, April 20-24, 2009. pp. 601{ 610. ACM (2009). https://doi.org/10.1145/1526709.1526790, http://doi.acm.org/ 10.1145/1526709.1526790 21. Manna, M., Ricca, F., Terracina, G.: Consistent query answering via ASP from di erent perspectives: Theory and practice. Theory and Practice of Logic Programming 13(2), 277{252 (2013) 22. Manna, M., Ricca, F., Terracina, G.: Taming primary key violations to query large inconsistent data via ASP. TPLP 15(4-5), 696{710 (2015). https://doi.org/10.1017/S1471068415000320, http://dx.doi.org/10.1017/ S1471068415000320 23. Nardi, B., Reale, K., Ricca, F., Terracina, G.: An integrated environment for reasoning over ontologies via logic programming. In: RR. Lecture Notes in Computer Science, vol. 7994, pp. 253{258. Springer (2013) 24. Swift, T., Warren, D.S.: XSB: Extending Prolog with Tabled Logic Programming. Theory and Practice of Logic Programming 12(1-2), 157{187 (2012). https://doi.org/10.1017/S1471068411000500, http://dx.doi.org/10.1017/ S1471068411000500 25. Terracina, G., Leone, N., Lio, V., Panetta, C.: Experimenting with recursive queries in database and logic programming systems. Theory and Practice of Logic Programming 8, 129{165 (2008) 26. Terracina, G., Martello, A., Leone, N.: Logic-based techniques for data cleaning: An application to the italian national healthcare system. In: LPNMR. Lecture Notes in Computer Science, vol. 8148, pp. 524{529. Springer (2013) 27. Ullman, J.D.: Principles of Database and Knowledge-Base Systems, Volume I.
Computer Science Press (1988)