A Knowledge Based Paradigm for Querying ... - Semantic Scholar

A Knowledge Based Paradigm for Querying Databases Paolo Bresciani, Michele Nori, and Nicola Pedot ITC-irst, Istituto per la Ricerca Scienti ca e Tecnologica, I-38050 Trento-Povo, Italy fbrescian, nori, [email protected]

Abstract. The so called Visual Query Systems try to support unskilled

users in formulating complex queries to highly structured databases, by providing graphic paradigms for visualizing the database conceptual models, and by allowing to build queries through visual interactions. In the present paper we propose a paradigm, for supporting the user in building sophisticated queries, based on a uniform graphical presentation of conceptual models and queries. Its most important novelty is that it is based on a semantic representation of the database conceptual models in terms of Description Logics. In this way it is possible to perform relevant inferential tasks on the query, in order to allow the user to: (i) interactively and iteratively build queries; (ii) be prevented from building inconsistent queries; (iii) interactively explore the database semantics; (iv) be gradually introduced only to those part of the conceptual model relevant for the query formulation; (v) be provided with simple, but eective, features for query re nement and query generalization.

1 Introduction The task of building a query for accessing data stored in a database can be aorded in dierent ways by dierent kinds of user. In any case, the query must be expressed in a form suitable to be processed by the system or the speci c application, and that, at the same time, possesses a clear meaning for the user. Users can be classi ed on the basis of their familiarity with databases, their knowledge of the application domain, the frequency of use of the application, and the heterogeneity and complexity of the queries they formulate [10, 11]. In particular, due to the increasing availability of complex and highly structured data sources, a growing number of unskilled users would like to access data, for several needs, by formulating sophisticated and extemporary queries. These users are likely to have no familiarity with structured query languages, and probably they are just occasional users, unwilling to spend many eorts in trying to understand the way the information is logically organized in the database. The \Visual Query Systems" (VQS) [11] try to overcome these diculties by providing graphic paradigms for visualizing the conceptual model of the available data, and by allowing to build queries by means of visual interactions. The VQS are, typically, addressed to all those situations in which: (i) the application

domain is complex, and, therefore, a simple form-based, or even QBE like [14], interface is insucient; (ii) the user is eager to discover interesting information and to educe knowledge from the highly structured set of available data. Nevertheless, most VQS still fail to adequately support the users in the task of understanding the semantics of the data at an intensional level. In fact, although they typically provide graphical representations of the data models, scarcely support the users in strictly linking it with their intuitive understanding of the domain scenario. In order to better understand this connection, the users must perform a set of trials, during which they can discover the real meaning of the stored data by analyzing and comparing the answers to dierent tentative queries. Instead, here we propose a more direct discovery process, during which query validation and comparison can be carried out at the intensional level. Moreover, even assuming a perfect understanding of the conceptual model, its complexity |specially the presence of possible interfering constraints| can lead to an objective diculty in avoiding inconsistent requests or in noticing similarities, or even equivalences, between apparently dierent queries. This can lead to two kinds of problem: 1. in the trys of iteratively building the intended query, the user can fail several times, because reiterating slightly dierent, but all inconsistent, queries; 2. it is possible that, after having submitted a query to a database, the answer is unexpectedly too large or too narrow: in this case, trying to modify the query in a structural and relevant way could be an hard task. In the present paper we propose a novel paradigm for supporting the user in building sophisticated queries in the context of highly structured object oriented databases. The proposed paradigm is relevant when: (i) the application domain is intrinsically complex; (ii) a hierarchical conceptual model of the domain is available; (iii) the queries the user wants to build are structurally complex; (iv) the user is eager to discover, for best formulating the intended query, the structure of the conceptual model, through an interactive and iterative process. The proposed paradigm uses, in order to convey the conceptual model and query contents and meanings to the user, a uniform graphical presentation. But the most important characteristic of the paradigm is that it is based on a semantic representation of the database conceptual model, coded into a knowledge base. Thus, it is possible to perform some relevant inferential tasks on the semantics of the queries. In particular, it is possible to allow the user to: (i) interactively and iteratively build queries; (ii) be prevented from building inconsistent queries; (iii) interactively explore the semantics of the queries and of the classes involved, using the classi cation of the queries in the taxonomical conceptual model; (iv) be gradually introduced only to those parts of the conceptual model that are relevant for the query formulation; (v) be provided with simple, but eective, features for query re nement and query generalization. In section 2, our interaction paradigm will be introduced. To support the paradigm, some reasoning services are needed. They will be discussed in section 3. In section 4, some notes about a rst prototypical realization of the paradigm will be given, and section 5 will draw some conclusions.

2 The Interaction Paradigm In general, submitting a query to a database involves three main steps: (i) build join paths through a set of relational dependencies: in order to do that with traditional systems, the user needs to know details not only on the application domain, but also on the implementation schema; (ii) de ne arithmetic constraints on the attributes, and select the attributes to be included in the answers; (iii) possibly de ne some aggregations, and decide a printout format. After these steps, the query can be submitted, and results printed out or shown otherwise. In the paradigm here presented only the rst of these steps is considered. During it, as said above, it is usually assumed that the user already has some knowledge about the application domain and the implementation schema. Instead, in our paradigm, the user is assisted in understanding the semantics of the model and the queries iteratively built through successive modi cations and re nements. To this end, it is necessary to provide a classi cation of the queries w.r.t. the set of classes that form the database conceptual model, providing, thus, a way for gradually understanding and learning the semantics of the model. Moreover, classifying the query at each step of the interaction allows to immediately detect semantic inconsistencies w.r.t. the database conceptual model.

2.1 The Approach In our paradigm a query intuitively corresponds to an object description, with nested relationships with other queries. Therefore, such kind of descriptions should be dynamically generated and managed. From the graphical point of view, a query can be represented as in g.1, that corresponds to the following: Q(x) Prof(x) ^ hold(x; y) ^ Lecture(y) ^ attend(z; y) ^ CS-stud(z )^ hold(x; w) ^ CS-lect(w): We believe that the graphical notation of g.1 is quite easily grasped by the unskilled user, because it is quite close to a natural language Noun Phrase (NP), but, at the same time, avoids referential ambiguities. Moreover, the representation shows only the necessary terms of the class hierarchy. It can be noticed that the query has only one free variable. This is not a real limitation: the selection of other variables can be postponed to the second phase of the list de ned before, but this is out of the scope of the present paper. In our approach, the user is allowed to interactively build sophisticated queries, like that shown in g.1, by choosing among the classes de ned in the conceptual model, and iteratively forming, with them, complex boolean expressions of literals connected by links representing relationships. Of course, it must be possible also to delete or replace parts of the query. In subsection 2.2 the main functionalities for building and modifying queries will be presented. An important aspect is that, during the interaction, the query that is going to be built is constantly guaranteed to be consistent, w.r.t. the conceptual model of the database, in order to avoid the problem 1 listed in section 1. Moreover, in our approach, the query is classi ed, w.r.t. the conceptual model, after each

Fig. 1. A possible interface for visually formulating queries. modi cation, so that the user can be informed about the position of the query in the conceptual taxonomy. In this way it is possible to face also the problem 2. Requiring that only consistent queries are built prevents the user to uselessly query the database. Indeed, in order to better achieve this goal, we require some more constraints on the kind of interactions allowed for building the query: { Only consistent actions (i.e., actions that lead to a new query that still is consistent) are allowed. { Only relevant modi cations (i.e., query transformations that lead to new queries that are semantically not equivalent to the original one) are proposed. { Only close modi cations (i.e., not all the consistent and relevant modi cations, but only those that lead to a new query with semantics close to the original query semantics) are proposed. This constraint is required in order to avoid to overload the user with too many options.1 In the following we shortly call these constraints \CRCP". A rst consequence of CRCP is that, at the beginning of the interaction, the user is allowed to choose among the top classes of the conceptual model hierarchy only. 1

This point is one of the most delicate. In fact, it is dicult, in general, to give a clear notion of close query and close modi cation. Moreover, in some cases, some overload could be acceptable, specially if it give the advantage of shortening the interaction. Anyway, closeness must not preclude reachability of every term in the taxonomy.

In the next subsection the principal kinds of interactions will be listed. In order to satisfy CRCP some reasoning tasks have to be performed. They will be dealt with in section 3.

2.2 The Detailed Functionalities

The graphical interface implied by our paradigm includes the following elements: (i) an area where to represent the query in the form shown in g.1; (ii) a list of names of classes more generic than the query (let's call it a generalization list ); (iii) a list of names of classes more speci c than the query (specialization list ); (iv) a list of names of classes equivalent to the query (equivalence list ); (v) a set of buttons or menu that allow to perform various actions for building the query. Moreover, the list of relationships that can be used to build or modify the query {or a portion of it{ must be shown on demand. As mentioned, the rst step of the interaction must be the selection of a starting term among the top classes of the conceptual model, that are shown in the specialization list. After that, the user must be able to modify iteratively the query through the following functionalities: { Query replacement. The goal is to allow the initial navigation in the taxonomy, and the substitution of the whole query with an atomic term semantically close to it, by selecting a replacement among the generalization, the specialization, or the equivalence lists. { Relation selection. It must be possible to restrict the query by imposing the existence of relationships with other atomic terms or complex expressions. A list of relations compatible with the present query must be shown, including, in agreement with CRCP, only those relations that, when used to restrict the query, would lead to a new query that still is consistent. Of course, also the coherent and most speci c relation range must be automatically proposed. { Propositional combination with other terms. It must be possible to combine selected parts of the query with other terms, to form boolean subexpressions. Also in this case the proposed terms must obey to CRCP, with respect to the kind of boolean combination required. { Negation. Literals should be allowed to be negated,2 but only if the resulting query will still be consistent the transformation must be allowed. { Re nement. The goal, in this case, is to replace selected subexpressions of the query, instead of combining them using boolean operators. It must be possible to select any kind of subexpression (i.e., also including relationship links). Both generalization and specialization lists for the selected parts must be presented, in order to be selected. Of course, also in this case, it is required that only those generalizations and specializations that satisfy CRCP are shown. A sample interaction with a rst prototypical implementation of the paradigm here presented can be found in [6]. 2

The possibility of negating non-literal expressions is prevented, in order to avoid misleading behaviors and meanings of the boolean combinations described above.

Construct FOL Semantics (:C ) :FC ( ) (C u D) FC ( ) ^ FD ( ) (C t D) FC ( ) _ FD ( ) (8R:C ) 8x:FR( ; x) ) FC (x) (9R:C ) 9x:FR( ; x) ^ FC (x) .. .. . . (R?1 ) FR ( ; ) (R  Q) 9x:FR (; x) ^ FQ (x; ) .. .. . .

Table 1. FOL transformational semantics for some DL operators.

3 Reasoning Services Let's recall that the main requirement of our paradigm is that each functionality that allow to modify a query must obey CRCP. To obtain this behavior some reasoning capabilities are needed. It is here proposed to obtain these capabilities by representing the conceptual model of the database and the query itself in terms of a Description Logic Knowledge Base. In fact, it has been show that Description Logics oer powerful formalisms for solving several problems [4, 3] concerning data modeling [2, 9] and access [2, 5], like, for example, the de nition of rich schema languages [8], the schema integration, the inter-view relationship managing, and, in particular, the intelligent query management [7, 3]. In the following we brie y recall some basic notions about Description Logics (DL), and then we exemplify how conceptual models and queries can be represented in terms of DL. Then, it will be possible to introduce the reasoning services that allow to guarantee CRCP for the functionalities listed in subsection 2.2.

3.1 Description Logics Description Logics are, essentially, variable-free concise reformulations of decidable restricted fragments of First Order Logic (FOL). The syntax of DL allows to express concepts (unary predicate symbols), roles (binary predicate symbols), and individuals 3 (constants). In dierent DL slightly dierent languages are used, with dierent levels of expressiveness. In all of them [12] concept expressions and role expressions can be built starting from the atomic concepts and roles, using dierent sets of operators, like the concept-forming operators: u; t; :; 8; 9, and the role-forming operators:
?1 ; . Description logics semantics can be given, for example, by mapping DL expressions into FOL formul [7]: an atomic concept A and an atomic role P are 3

Reasoning about individuals (the assertional reasoning ) is not relevant for our purposes; therefore, only the terminological aspects of DL will be considered.

(TOP-DISJOINT: (Prof Lect Stud)) (DEFCLASS Prof RELATIONS: ((hold Lect (0 inf)) ...))

(DEFCLASS Course ISA: (Lect) INVERSE: ((attend Stud (0 inf))) ...)

(DEFCLASS CS-Prof ISA: (Prof) RELATIONS: ((hold CS-Lect (0 inf))) ...)

(DEFCLASS Stud DISJOINT: ((CS-Stud Eng-Stud)) RELATIONS: ((participate Seminar (0 inf)) (attend Course (1 inf))) ...)

(DEFCLASS Eng-Prof ISA: (Prof) RELATIONS: ((hold Eng-Lect (0 inf))) ...)

(DEFCLASS CS-Stud ISA: (Stud) RELATIONS: ((attend CS-Course (1 inf))) ...)

(DEFCLASS Lect DISJOINT: ((Seminar Course)) DISJOINT-COVERING: ((CS-Lect Eng-Lect)) INVERSE: ((hold Prof (1 1))) ...)

(DEFCLASS Eng-Stud ISA: (Stud) RELATIONS: ((attend Eng-Course (1 inf))) ...)

(DEFCLASS CS-Lect ISA: (Lect) INVERSE: ((hold CS-Prof (1 1)) ...)

(DEFCLASS CS-Course ISA: (CS-Lect Course) INVERSE: ((attend CS-Stud (0 inf))))

(DEFCLASS Eng-Lect ISA: (Lect) INVERSE: ((hold Eng-Prof (1 1)) ...)

(DEFCLASS Eng-Seminar ISA: (Eng-Lect Seminar))

(DEFCLASS Seminar ISA: (Lect) INVERSE: ((participate Stud (0 inf))) ...)

(DEFCLASS CS-Seminar

ISA: (CS-Lect Seminar))

(DEFCLASS Eng-Course ISA: (Eng-Lect Course) INVERSE: ((attend Eng-Stud (0 inf))))

Fig. 2. Conceptual model. mapped {or interpreted { into the FOL open atomic formul A( ) and P (; ). In table 1, for some DL concept expressions C , D the corresponding FOL open formul FC ( ), FD ( ) are recursively given; similarly, for some DL role expressions R, Q the corresponding FOL open formul FR (; ), FQ (; ) are given. An important feature of DL is that they are equipped with a formal calculus that allows to perform some inferential tasks [12]. The most important are (i) consistency checking : a concept description C is said to be consistent i the corresponding FOL formula, FC ( ), is satis able; (ii) subsumption : a concept description C is said to subsume a concept description D (written D < C ) i 8x:FD (x) ) FC (x) is a FOL tautology. In DL it is possible to de ne knowledge-bases (KB) as sets of subsumption assertions. It is said that a subsumption is entailed by a KB (KB j= D < E ) i FKB j= 8x:FC (x) ) FD (x) in terms of FOL.4 The consistency of a concept description C w.r.t. a (consistent) KB can be expressed as: KB j= C 6 ?.5

3.2 Conceptual Modeling in DL

To see how a database conceptual model can be described in terms of Description Logics, let's consider the fragment shown in g.2 of a sample conceptual model.6 The corresponding Description Logic KB is sketched in g.3. Where FKB is the set of FOL axioms containing 8x:FC1 (x) ) FC2 (x) for each C1 < C2 in KB . 5 C  D stands for C < D ^ D < C , and the special concept ? correspond to the false symbol in FOL. Similarly, the special concept > corresponds to the truth in FOL. 6 Although, due to space limits, the formal semantics of the language used cannot be presented here, the meaning of the example should be quite intuitive and clear.

4

Stud u Lect  ? Stud u Prof  ? Prof u Lect  ? 9hold:> < Prof 9hold?1 :> < Lect Prof < 8hold:Lect Eng-Prof < Prof u 8hold:Eng-Lect CS -Prof < Prof u 8hold:CS -Lect 9attend:?>1 < Stud 9attend :> < Course 9participate:?>1 < Stud 9participate ?1:> < Seminar Lect < 8hold :Prof u 9=1 hold?1 Seminar u Course  ? CS -Lect u Eng-Lect  ? Lect < CS -Lect t Eng-Lect

Seminar < Lect u 8Participate?1 :Stud Course < Lect u 8Attend?1 :Stud CS -Lect < Lect u 8hold??1 :CS -Prof Eng-Lect < Lect u 8hold 1 :Eng-Prof ?1 CS -Course  CS -Lect u Course u 8attend :CS -Stud Eng-Course  Eng-Lect u Course u 8attend?1 :Eng-Stud CS -Seminar  CS -Lect u Seminar Eng-Seminar  Eng-Lect u Seminar Stud < 8paricipate:Seminar u 8attend:Course CS -Stud < Stud u 8attend:CS -Course u 91 attend Eng-Stud < Stud u 8attend:Eng-Course u 91 attend

Fig. 3. Translation of the conceptual model into a KB.

In our paradigm, the use of KB like that presented in g.3 must allow to infer, e.g., that a CS-stud (CS student) must attend only CS-Course (CS courses). Thus, according to CRCP, queries where a CS student is required to attend an engineering course (Eng-Course) must be immediately recognized as inconsistent, or, better, must be not even allowed to be built.

3.3 DL Reasoning and CRCP

Let's consider, for example, the query:

Q(x)

Stud(x) ^ :Eng-Stud(x) ^ attend(x; y ) ^ Course(y )

(1)

and consider the process needed to build it, according to to our paradigm. A step of the process could be conjoining :Eng-Stud(x) to

Q(x)

Stud(x) ^ attend(x; y ) ^ Course(y ):

Once query (1) is built, selecting Course for re nement must cause that it is evidenced that replacing Course(y) with CS-Course(y) would lead to an equivalent query: this is important, because the equivalence between the two forms conveys to the user more knowledge about the conceptual model. On the other hand, we could try to build the same query by another approach, i.e., by adding the association attend to Q(x) Stud(x) ^ :Eng-Stud(x). In this case, according to CRCP, attend(x; y) ^ CS-Course(y) must be directly proposed to the user, and not the less informative attend(x; y) ^ Course(y). Of course this is not an arbitrary action, because, as before:

Q(x) and

Q(x)

are equivalent.

Stud(x) ^ :Eng-Stud(x) ^ attend(x; y ) ^ CS-Course(y ) Stud(x) ^ :Eng-Stud(x) ^ attend(x; y ) ^ Course(y )

All these reasoning services can be performed by means of the basic inferential services of consistency checking and subsumption provided by a DL. In order to do this, it is necessary to represent the query in DL. For example, the query (1) is represented by:

Stud u :Eng-stud u 9attend:Course

(2)

It is quite easy to verify that:

KB j= Stud u :Eng-stud u 9attend:Course  Stud u :Eng-stud u 9attend:CS -course where KB is the knowledge base of g.3.

Of course, this is just one example of reasoning; in particular it is relevant for the functionality of relation selection seen in subsection 2.2. More systematically, the kinds of checks corresponding to each of the functionalities introduced in subsection 2.2 are sketched below: { Query replacement. It is enough to maintain a representation of the query in term of DL, like expression (2), and to classify it in the taxonomy implied by the KB. That is, the most speci c subsumers, MSS (Q), and the most generic subsumees, MGS (Q), of Q must be found in KB , in order to update the generalization and the specialization lists, respectively. { Relation selection. Here the task is more complex, and require two steps: 1. list all the compatible relationships by testing, for each relation name R in the KB, if Q u 9R:> is consistent (and similarly, for the inverse relation test if Q u 9R?1 :> 6 ?); 2. for each compatible relationships R (or R?1) determined in step 1, de ne the relevant range as MSS (9R?1 :Q) (or MSS (9R:Q)). { Propositional combination. Let's consider the case of AND combinations. Assume that q is the sub-query selected in Q. Let Qq=q0 denote the new query obtained from Q by replacing the sub-query q with q0 in Q. What must be checked is CRCP of Qq=(quC ) w.r.t. Q, for all the Ci 2 KB . It is worth noticing that only the specialization list is meaningful during this operation. Several strategies can be adopted in order to reduce the search of the Ci , as, e.g., following a top-down search in the taxonomy, with early prunings when inconsistent cases are found, and no further search when a relevant Ci is reached (in this case Qq=(quC ) will be the closest to Q, along the considered path, due the top-down search). The top-down strategy gives good results because, in practical cases, the conceptual model contains disjoint classes at a quite high level in the taxonomy, allowing for a good amount of pruning. For OR combinations the general approach is dual, even if the dual (bottomup) strategy is not as ecient as the top-down strategy for the conjunctions. { Negation. The case of negation is quite easy: it is enough to check if the query (Qq=:q ) will still be consistent. { Re nement. In this case the situation is similar to the case of propositional combination, seen above, but a bidirectional search must be performed. The CRCP must be checked on all the possible Qq=C . A possible heuristics is to i

i

i

start from MSS (q) and MGS (q), and search upward and downward respectively, in order to nd the generalization and the specialization lists. Also in this case, reaching a relevant Ci halts the search. Of course, the paradigm here proposed can be implemented only in presence of a DL automatic reasoner, capable to manage KB with circular de nitions (or general axioms). By the example it is clear that the DL language required must allow to express conjunctions, disjunctions, negations, quali ed quanti cations and number restrictions, and inverse roles; that is ALCNIF . iFaCT [13], already capable to perform reasoning over the ALCR+ HIF , has recently been improved with the capability of reasoning over quali ed number restrictions. It is, therefore, suited to be used to implement the paradigm here presented.

4 A Prototypical System Starting from the ideas presented in this paper and from the availability of iFaCT, we have implemented a rst prototype for testing our paradigm. The system uses iFaCT, at which the functionalities described in subsection 2.2 and subsection 3.3 have been added by us. A visual interface (see g.1) has been implemented, in order to test on users the impact of the semantic based interaction. More details on the prototype are given in [6]. The system architecture is based on a client-server paradigm. The visual interface is written in Java in order to allow the highest portability. The reasoning services run on Allegro Common Lisp, possibly on a remote machine. Socket channels provide the low level communication between the interface and the reasoning server. In [6] some more particulars are presented.

5 Conclusions The most important aspect of the paradigm for querying databases presented in the present paper consists on the fact that the use of knowledge based reasoning is proposed, in order to help the user in the task of building sophisticated queries through an iterative process of successive re nements and generalizations, that allow to progressively discover interesting meanings and consequences hidden in complex conceptual model descriptions, and prevents, at the same time, from submitting inconsistent queries. The paradigm, and its rst prototypical implementation, can be considered a rst step toward a practical and experimental activity oriented to face several issues about the application of knowledge based systems in the eld of database access and interfaces, as mentioned in section 1 and, in a more complete way, in [4]. How to translate the conceptual representation of the queries, sketched in this paper, into SQL queries, in order to access real DBMS, is detailed in [3]. Some more eorts are now necessary to complete the development of the prototype. At the same time, we plan to analyze and code some complex examples of conceptual models, in order to perform some tests with unskilled users, and

try some comparisons with other VQS, like, for example QBD, [10] and VISIONARY [1]. In any case, we foresee that the comparison will not be straightforward, because our approach stress semantic aspects, while others systems emphasize the visual interaction.

References 1. F. Benzi, D. Maio, and S. Rizzi. VISIONARY: a viewpoint-based visual language for querying relational databases. Journal of Visual Languages and Computing, 10:117{145, 1999. 2. Alex Borgida. Description logics for data management. IEEE Transactions on Knowledge and Data Engineering, 5(7), October 1995. 3. Paolo Bresciani. The challenge of integrating knowledge representation and databases. Informatica, 20(4):443{453, December 1996. 4. Paolo Bresciani. Some research trends in knowledge representation and databases. In F. Baader, M. Buchheit, M. A. Jeusfeld, and W . Nutt, editors, Working Notes of the ECAI-96 Workshop \Knowledg e Representation Meets Databas (KRDB-96)", pages 10{13, Budapest, August 1996. 5. Paolo Bresciani and Enrico Franconi. Description logics for information access. In Proc. of "Giornata di Lavoro su accesso, estrazione ed integrazione di conoscenza - V Convegno AI*IA", September 1996. 6. Paolo Bresciani, Michele Nori, and Nicola Pedot. QueloDB: a knowledge based visual query system. In Proceding of IC-AI: International Conference of Arti cial Intelligence, Las Vegas, June 2000. Forthcomming. 7. M. Buchheit, M. A. Jeusfeld, W. Nutt, and M. Staudt. Subsumption between queries to object-oriented databases. Information Systems, 19(1):33{54, 1994. 8. D. Calvanese, G. De Giacomo, and M. Lenzerini. Structured objects: Modeling and reasoning. In Proc. of the 4th International Conference on Deductive and Object-Oriented Databases, DOOD'95, Singapore, December 1995. 9. D. Calvanese, M. Lenzerini, and D. Nardi. Description logics for conceptual data modeling. In Jan Chomicki and Gunter Saake, editors, Logics for Databases and Information Systems, pages 229{263. Kluwer Academic Publisher, 1998. 10. T. Catarci, S.K. Chang, M.F. Costabile, S. Levialdi, and G. Santucci. A graphbased framework for multiparadigmatic visual access to databases. IEEE Transactions on Knowledge and Data Engineering, 8(3):455{475, 1996. 11. T. Catarci, M. F. Costabile, S. Levialdi, and C.Batini. Visual query systems for databases: a survey. Journal of Visual Languages and Computing, 8(2):215{260, April 1997. 12. F. M. Donini, M. Lenzerini, D. Nardi, and W. Nutt. The complexity of concept languages. In Proc. of the 2 nd International Conference on Principles of Knowledge Representation and Reasoning, pages 151{162, Cambridge, MA, 1991. 13. I. Horrocks, U. Sattler, and S. Tobies. Practical reasoning for expressive description logics. In H. Ganzinger, D. McAllester, and A. Voronkov, editors, Proceedings of the 6th International Conference on Logic for Programming and Automated Reasoning (LPAR'99), number 1705 in Lecture Notes in Arti cial Intelligence, pages 161{180. Springer-Verlag, 1999. 14. M. M. Zloof. Query{by{example: A database language. IBM System Journal, 16(4):324{343, 1977.