Verbeterde toegankelijkheid voor een databankbeheersysteem...

Lynne Vandousselaere

kwantorendatabankbeheersysteem: modelleren van vageVerbeterde toegankelijkheid voor een

Academiejaar 2008-2009Faculteit IngenieurswetenschappenVoorzitter: prof. dr. ir. Herwig BruneelVakgroep Telecommunicatie en informatieverwerking

Master in de ingenieurswetenschappen: computerwetenschappen Masterproef ingediend tot het behalen van de academische graad van

Begeleiders: Axel Hallez, ir. Tom MatthéPromotor: prof. dr. Guy De Tré

Verbeterde toegankelijkheid voor een databankbeheersysteem - modellerenvan vage kwantoren

doorLynne Vandousselaere

Masterproef ingediend tot het behalen van de graad van Master in de ingenieursweten-schappen: computerwetenschappen

Academiejaar 2008–2009

Universiteit GentFaculteit Ingenieurswetenschappen

Promotor: prof. dr. Guy De Tre

Samenvatting

Bij het bevragen van een databanksysteem moeten zoekparameters scherp begrensdopgegeven worden, maar de preferenties van gebruikers zijn meestal niet scherp begrensd.Het doel van deze masterproef is om gebruikers toe te laten hun “vage” preferenties opte geven aan de hand van linguıstische termen (zoals de meeste, ongeveer 8, ...) in plaatsvan deze te beperken tot strikte zoekcriteria (zoals alle, = 8, > 500).

Concreet zal dit worden toegepast via het opgeven van vage kwantoren, die dan internworden omgezet naar scherpe grenzen en een corresponderende waarde geassocieerd krijgendie aangeeft in welke mate het resultaat correspondeert met de gewenste zoekparameter.

Trefwoorden: vage kwantoren, vaagverzamelingen, possibiliteitstheorie, uitgebreidepossibilistische waarheidswaarden.

i

Improved accessibility for a database managementsystem: modeling of fuzzy quantors

Lynne Vandousselaere

Supervisor(s): Guy De Tre, Axel Hallez, Tom Matthe

Abstract—This article describes a way to extend SQL with fuzzy quan-tors, such as most, about 5 etc. The quantors are evaluated and an EPTVis assigned to each returned row, that represents in which degree the rowcorresponds to the given query.

Keywords—Fuzzy quantors, fuzzy sets, extended possiblistic truth values(EPTV’s).

I. INTRODUCTION

FUZZY quantors can play an important role in the flexiblequerying of relational databases. They provide the user

with the means to not only provide crisp boundaries, but alsofuzzy boundaries in their query. Some concrete examples toclarify this are given below.

A user can for example request the classes or courses wheremost of the students passed. With some SQL-knowledge fol-lowing query could be made:

SELECT coursename FROM courses cWHERE 10 <= QUANTOR MOST

( SELECT score FROM coursesWHERE coursename = c.coursename)

But more simple queries are also possible, like all students,courses who got a score of about 10:

SELECT course, studentid FROM courses cWHERE score = QUANTOR ABOUT 10

Tuples that are satisfied in a greater degree, will receive ahigher associated EPTV value and so will be higher in the resultlist. E.g. a score of 10 can be found before a score of 9 in theresult list.

Remark: So quantors can be easily self-defined, the keywordQUANTOR needs to be placed before all quantors.

In order to realise this, we:1. defined a syntax that allows the recognition of quantors, to-gether with it’s associated concepts e.g. the number 5 in an ab-solute quantor “ABOUT 5”.2. provide an implementation that is able to:• transform the given query to a valid SQL-query that can be

passed on to a relational database.• evaluate the results, given the quantor. More precise: each

record in the result needs to be associated with an appropriateEPTV.

II. CONCEPTS

A fuzzy set V is a set where a membershipfunction µV isassigned to each member ∈ [0, 1]. Elements that belong com-pletely to the set, will have µV = 1. Elements completely aren’tpart of the set, will have µV = 0. A fuzzy set is often noted

Fig. 1. Trapezium function

with the element’s membershipfunction written as subscript, e.g.V (‘around 5’) = {41/2, 51, 61/2}.

An easy (but limited) way to represent the membershipfunc-tion of a fuzzy set is to use a trapezium function (figure 1).These functions are very easy to use, because they are com-pletely dependent on only four parameters a, b, c, d who deter-mine the complete function.

An extended possibilistic truth value or eptv is a fuzzyset t(p) = {(T, µ(T )), (F, µ(F )), (⊥, µ(⊥))} that associates3 fuzzy values with each proposition p: a truth value that ex-presses in which degree the proposition can be regarded as true,a false value that expresses the degree to which p is false and a⊥ value that expresses extent in which the proposition is unde-fined (e.g. a contact’s telephone number, when the person has notelephone).

III. FLEXQL SYNTAX

The entire syntax will not be encluded here, only the essentialsyntax. The ‘Quantor’ part is allowed inside the Comparissonpart of a query. Examples will be given further for clarification.

QUANTOR:= <QUANTOR> (Quantor)* (<NUMBER>)?( "(" SubSelect ")" )?

where the ? means 0 or 1, the * means 1 or more. The Quan-tor part is a linguistic quantor (one or more, to allow modifi-cationfunctions). The number is needed for absolute quantors.The SubSelect is used to perform the quantor on a subquery.

A. Example query

SELECT coursename FROM courses cWHERE 10 <= QUANTOR MOST

( SELECT score FROM coursesWHERE coursename = c.coursename)

Here the entire Where clause is the comparisson part, all coursesare requested which have scores greater or equal to 10 for MOSTscores.

(a)Quantor MOST (b)Quantor MORE LESS 50

Fig. 2. Example of a relative and absolute quantor

IV. EVALUATION OF FUZZY QUANTORS

Most quantors are defined as trapezium functions, because asmentioned earlier these are very easy to define and to work with.Some quantors could not be defined as a trapeziumfunction andwere implemented as a fuzzy set, e.g. ALL, ANY (quantor ∀,∃).Relative quantors, such as MOST were defined, see figure 2(a)for the associated membershipfunction. Absolute quantors thatdepend on a number were also defined, e.g. MORELESS 50which represents the linguistic term ‘more or less 50’ (see figure2(b)).

Because of the keyword <QUANTOR> in the syntax, quantorscan be easily self-defined or adapted when necessary.

A. Integrated subqueries

The evaluation of fuzzy quantors is usually pretty straight-forward. But quantors with integrated subqueries are more com-plex. Integrated subqueries are subqueries that have column ortable id’s that refer to the main query, which means that theycan’t be executed independently. There are two approaches pos-sible to fix this: one is to evaluate the mainquery result row-by-row with the subquery adapted to the appropriate item found inthe column, another is to integrate the subquery with mainqueryand later on remove the added columns and tables, offcourse.

We have chosen to use the first method, and in order to dealwith the so called bad id’s (the column or table id’s from themainquery), we will first iterate over all nodes (the query isparsed as a tree, with nodes), and for every subquery-node wewill search for these bad id’s. These id’s will then be stored asthe path in the tree, starting from the select-node. Everytime arow is evaluated, the subquery will be iterated again and all badid’s will be replaced with the appropriate components (e.g. forc.coursename, it could be replaced with [Math] if that isthe value of the current row).

V. ‘FUZZYQUERY’ FRAMEWORK

The used framework for the application is represented in fig-ure 3. There’s a webinterface that will call upon the FlexQLparser, who will generate a valid SQL query for a relationaldatabase. The returned result will then be evaluated and anEPTV will be associated with each record. Finally, the resultwill be sorted by it’s EPTV value so the best results are pre-sented first.

The framework is written in Java, and for the parser a modulecalled ‘JavaCC’ was used. The supported databases are MySQLand Ms Access. The framework is also written with attention toextensibility and reusability.

Fig. 3. Structure of the FuzzyQuery application

VI. CONCLUSION

The result is a easy-to-use application, for users with a ba-sic knowledge of SQL. The application can easily be extendedwith other fuzzy set concepts such as new quantors, operators,implicators, ...

REFERENCES

[1] L.A. Zadeh, Fuzzy Sets, Information and Control, vol.8-3, pp. 338-353,June 1965.

[2] L.A. Zadeh, Fuzzy sets as a basis for a theory of possibility, Fuzzy Setsand Systems, vol. 100-sup, pp. 9-34, April 1999.

[3] L.A. Zadeh, A Computational Approach to Fuzzy Quantifiers in NaturalLanguages, Computers and Mathematics, vol. 9-1, pp. 149-184, 1983.

[4] G.J. Klir, B. Yuan, Fuzzy Sets and Fuzzy Logic: Theory and Applications,Computer and Mathematics, vol. 1, pp. 149-184, Prentice Hall Inc., NewJersey, USA, 1995.

[5] Daniel Sanchez, Andrea G.B. Tettamanzi Generalizing Quantification inFuzzy Description Logics, Advances in Soft Computing, vol. 33, pp. 397-411, Springer Berlin/Heidelberg, 2005.

[6] Tom Matthe, Koen Tourne Flexibele bevraging van relationele databanken:studie en implementatie, Universiteit Gent, 2003.

Toelating tot bruikleen

De auteur geeft de toelating dit afstudeerwerk voor consultatie beschikbaar te stellenen delen van het afstudeerwerk te kopieren voor persoonlijk gebruik. Elk ander gebruikvalt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot deverplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit ditafstudeerwerk.

Lynne Vandousselaere 2 juni 2009

iv

Dankwoord

Graag zou ik iedereen willen bedanken die heeft bijgedragen tot de verwezenlijking vandeze masterproef, in het bijzonder dank ik mijn thesisbegeleiders Axel Hallez en TomMatthe en promotor Guy De Tre voor het scheppen van de mogelijkheid om dit onderzoekte verrichten.

Verder zou ik nogmaals professor Guy De Tre willen danken voor het verschaffen vande cursus Vage Databanken die een samenbundeling vormt van de belangrijkste begrippenuit de vaagverzamelingenleer, wat een grote hulp was.

v

Inhoudsopgave

Samenvatting i

Extended abstract ii

Toelating tot bruikleen iv

Dankwoord v

1 Inleiding 1

2 Theoretische onderbouw 32.1 Vaagverzamelingenleer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.1.1 Semantische interpretatie . . . . . . . . . . . . . . . . . . . . . . . . 32.1.2 Basisconcepten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.1.3 Kardinaliteit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.1.4 Bewerkingen op vaagverzamelingen . . . . . . . . . . . . . . . . . . . 6

2.2 Possibiliteitstheorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.2.1 Vaagmaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.2.2 Possibiliteitsdistributies . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.3 EPTV’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.3.1 Definitie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.3.2 Calculus voor EPTV’s . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.4 Flexibele bevraging van reguliere databanken . . . . . . . . . . . . . . . . . 142.4.1 Preferenties binnen bevragingscondities . . . . . . . . . . . . . . . . 142.4.2 Preferenties tussen bevragingscondities . . . . . . . . . . . . . . . . . 17

3 Praktische onderbouw 193.1 SQL syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.1.1 De existentiele kwantor ∃ . . . . . . . . . . . . . . . . . . . . . . . . 193.1.2 De absolute kwantor ∀ . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 FlexQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.2.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.2.2 Applicatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.2.3 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.3 Fuzzy sets (ddcm) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

vi

4 FuzzyQuery applicatie 294.1 FlexQL Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1.1 BNF Grammatica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.1.2 ‘Quantor’ uitbreiding . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.1.3 Semantiek van kwantoren . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2 Implementatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.2.1 Algemeen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.2.2 Uitbreiding van het ddcm-framework . . . . . . . . . . . . . . . . . . 374.2.3 ComparableFuzzySet<T> . . . . . . . . . . . . . . . . . . . . . . . . 374.2.4 Uitbreiding van FlexQL framework . . . . . . . . . . . . . . . . . . . 384.2.5 Voorbeelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5 Evaluatie 435.1 Algemeen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.2 Evaluatie van kwantoren zonder subqueries . . . . . . . . . . . . . . . . . . 435.3 Evaluatie van kwantoren met subqueries . . . . . . . . . . . . . . . . . . . . 44

5.3.1 Evaluatie van een rij . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.3.2 Evaluatie van een conditie . . . . . . . . . . . . . . . . . . . . . . . . 455.3.3 Bad ID’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465.3.4 Hulpmethodes in QuantorEvaluator . . . . . . . . . . . . . . . . . . 47

6 Uitbreidingen 486.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486.2 Implementatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.2.1 Toevoegen van kwantoren . . . . . . . . . . . . . . . . . . . . . . . . 486.2.2 Toevoegen van operatoren . . . . . . . . . . . . . . . . . . . . . . . . 496.2.3 Aanpassen van de View . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.3 Evaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496.3.1 Vage evaluatie van conditie . . . . . . . . . . . . . . . . . . . . . . . 50

6.4 Optimalisaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

7 Besluit 51

A Diagrammen 52

B JavaCC syntaxbestand 58

Lijst van figuren 66

Lijst van tabellen 67

Bibliografie 68

vii

Hoofdstuk 1

Inleiding

Situering Bij het bevragen van een databanksysteem moeten zoekparameters scherpbegrensd opgegeven worden, e.g. een maximumwaarde van 500 euro, of een interval [500−1000] euro. Gebruikers hebben echter preferenties die niet scherp begrensd zijn (bvb.goedkoop) en de objecten zullen hiermee in verschillende mate overeenstemmen, bvb. eenlage prijs zal in hoge mate overeenstemmen met het concept goedkoop. De gezochteresultaten zullen dus slechts in bepaalde mate voldoen aan de opgegeven zoekcriteria.

Om deze gradaties te modelleren, kan men een vaagverzameling gebruiken. Een vaag-verzameling is een uitbreiding op het begrip verzameling en zal gebruik maken van hetinterval [0, 1] als lidmaatschapsgraad van een element, om aan te duiden in welke mateeen element behoort tot de vaagverzameling. Kwantoren, zoals de universele kwantor ∀en de existentiele kwantor ∃, worden in de vaagverzamelingenleer opgesplitst in absoluteof relatieve kwantoren. Absolute kwantoren zullen een getal of aantal aanduiden (eentwaalftal), terwijl de relatieve kwantoren verwijzen naar een proportie van het geheel (demeeste).

Voorgaand onderzoek Het thesisonderzoek van Tom Matthe en Koen Tourne behan-delt flexibele bevraging voor relationele databanken. Er werd onderzoek gedaan naarflexibele bevraging op basis van uitgebreide possibilistische waarheidswaarden (EPTV’s),gevolgd door de praktische ontwikkeling van een flexibele bevragingstaal FlexQL en webge-baseerde applicatie voor de bevraging van een relationele databank. De meest opvallendetoegevoegde functionaliteit aan SQL is die van de trapeziumfuncties, gewichten en het ge-bruik van uitgebreide possibilistische waarheidswaarden voor het ordenen van resultaten.

Doelstelling Vage kwantoren kunnen een belangrijke rol spelen in de flexibele bevragingvan relationele databanken. Ze maken het de gebruiker immers mogelijk om niet enkelscherpe grenzen op te geven in hun bevraging. Het doel van dit eindwerk is om dezemiddelen te voorzien als een uitbreiding van SQL.

Enkele concrete voorbeelden volgen om dit beter te verduidelijken. Een gebruiker kanbvb. de klassen of de vakken opvragen waar de meeste studenten geslaagd zijn. Maar ookmeer eenvoudige bevragingen zijn mogelijk, zoals alle studenten en vakken die ongeveer10 haalden als score. Tuples die in hogere mate voldoen aan de opgegeven kwantor, zulleneen hogere geassocieerde EPTV waarde krijgen en dus hoger in de lijst teruggevondenworden. Een score 10 zal dus hoger te vinden zijn, dan score 9.

1

Structuur Om dit te realiseren zullen volgende stappen doorlopen worden:

1. Definieren van een syntax die de kwantoren kan herkennen (samen met de bijhorendebegrippen, zoals bvb. bij een absolute kwantor “ONGEVEER 5”).

2. De query omzetten naar een geldige SQL-query die een relationele databank kanbevragen.

3. Evalueren van de resultaten t.o.v. de kwantor, m.a.w. met elk resultaat dient eenEPTV geassocieerd te worden.

Eerst wordt de theoretische onderbouw besproken in hoofdstuk 2, deze is nodig omde verschillende begrippen gehanteerd in dit eindwerk te begrijpen. Daarna worden reedsbestaande frameworks overlopen in hoofdstuk 3.

Een overzicht van de applicatie FuzzyQuery is terug te vinden in hoofdstuk 4, waarin degedefinieerde syntax en implementatiedetails besproken wordt. Een uitgebreide besprekingover de vage evaluatie van o.a. de kwantoren is terug te vinden in hoofdstuk 5.

Ten slotte volgt in hoofdstuk 6 nog een overzicht van mogelijke uitbreidingen.

2

Hoofdstuk 2

Theoretische onderbouw

Om verdere hoofdstukken te kunnen interpreteren, dienen eerste enkele basisbegrippenbehandeld te worden. Deze begrippen hebben vooral betrekking tot de vaagverzamelin-genleer, bewerkingen op vaagverzamelingen, possibiliteitstheorie en uitgebreide possibili-stische waarheidswaarden. Dit deel wordt ten slotte afgesloten met een samenvatting vande besproken delen en hoe deze verder effect zullen hebben in de rest van het eindwerk.

2.1 Vaagverzamelingenleer

Een vaagverzameling wordt beschouwd als een veralgemening van het wiskundig conceptverzameling en werd in 1965 geıntroduceerd door L.A. Zadeh [Zad65].

Een verzameling V ⊆ U wordt gekarakteriseerd door een lidmaatschapsfunctie µV :U → {0, 1} die elk element van het universum U afbeeldt op 0 of 1. Als x ∈ V dan isµV (x) = 1, als x /∈ V dan µV (x) = 0. Om een duidelijk onderscheid te maken met vageverzamelingen worden deze vaak scherpe verzamelingen genoemd.

Een vaagverzameling V over een universum U wordt gedefinieerd a.d.h.v. µV die metelk element van het universum U een lidmaatschapsgraad µV (x) ∈ [0, 1] associeert, metvolgende interpretatie:

µV (x) = 1 betekent dat x volkomen behoort tot VµV (x) = 0 betekent dat x niet behoort tot VµV (x) =∈]0, 1[ betekent dat x in beperkte mate behoort tot V

De vage machtsverzameling F(U) wordt gedefinieerd als de verzameling van alle mo-gelijke vaagverzamelingen die gedefinieerd kunnen worden over een universum U .

2.1.1 Semantische interpretatie

De lidmaatschapsgraden µV (x) kunnen op verschillende manieren worden geınterpreteerd,namelijk als graad van overeenstemming, waarheid of onzekerheid. [DP97]

Graad van overeenstemming µV bepaalt in welke mate het element x overeenstemtmet het prototype element van V . Bvb. Welke leeftijd wordt beschouwd als een ‘oude’leeftijd, µV (70 jaar) = 0.77.

3

Figuur 2.1: Trapezoıdale vormfunctie

Graad van waarheid µV bepaalt in welke mate het element x waar is in V . Bvb. Dekennis van talen waar iemand over beschikt, µV (Frans) = 0.6.

Graad van onzekerheid µV bepaalt in welke mate het mogelijk is dat een enkelwaar-dige parameter P ∈ U de waarde x ∈ V aanneemt. Bvb. Stel dat geweten is dat depersoon 70 jaar is, dan kan men zich afvragen in welke mate deze persoon nu p = ‘oud’is, µV (oud) = 0.77.

2.1.2 Basisconcepten

Vormfuncties

Een continue lidmaatschapsfunctie kan worden benaderd door een zogenoemde vormfunc-tie. Veel gebruikte vormfuncties zijn: de S-functie, de π-functie en de Π-functie. Andere,voor de praktijk belangrijke vormfuncties zijn de trapezoıdale en triangulaire lidmaat-schapsfuncties.

Trapezoıdale functies Deze vormfuncties worden omwille van hun eenvoud vaak ge-bruikt. Trapezoıdale vormfuncties worden volledig gekarakteriseerd door vier domeinwaar-den a, b, c en d, zie ook figuur 2.1. Deze functie, ook wel een trapeziumfunctie genoemd,wordt als volgt gedefinieerd:

fabcd(x) =

0 als x ≤ a of x ≥ dx−ab−a als a < x < b

1 als b ≤ x ≤ cd−xd−c als c < x < d

(2.1)

Niveauverzameling ΛV

De α-snede van V is een scherpe verzameling Vα waarvoor geldt:

Vα = {x ∈ U | µV (x) ≥ α} met α ∈ [0, 1]

Indien alle lidmaatschapsgraden bovendien strikt groter zijn dan α, spreekt men vaneen sterke α-snede. De verzameling van alle niveaus α ∈ [0, 1] die de distincte α-snedesrepresenteert van een gegeven vaagverzameling V , noemt men de niveauverzameling ΛVvan V . Er geldt: ΛV = {α | µV (x) = α, for some x ∈ U}.

4

2.1.3 Kardinaliteit

In klassieke verzamelingen wordt de kardinaliteit gedefinieerd als het aantal elementen inde verzameling, genoteerd als |A|. Analoog kunnen we de kardinaliteit van een vaagver-zameling V voorstellen als de som van de lidmaatschapsgraden µV (x) van alle elementenx in U , ook de Σ-count genoemd.

card(V ) =∑x∈U

µV (x) (2.2)

De kardinaliteit is nu niet langer een natuurlijk getal, maar een reeel getal dat deglobale lidmaatschap van alle elementen van de vaagverzameling weergeeft en kan dus nietlanger beschouwd worden als een aanduiding voor het aantal elementen.

Vage kardinaliteit De kardinaliteit kan ook gedefinieerd worden als een vaagverzame-ling, het concept van fuzzy cardinality werd geıntroduceerd in [Zad83] als

cardF (V ) =⋃

α∈ΛV

α

|Vα|(2.3)

waar |Vα| de kardinaliteit is van de scherpe verzameling Vα. Aangezien de kardinali-teit een vaagverzameling is, dient men de formule (2.3) niet letterlijk als een sommatiete interpreteren, maar wel als volgt: het element |Vα| heeft een lidmaatschapsgraad α.Aangezien Vα een scherpe verzameling is, zal de kardinaliteit ervan een natuurlijk getalzijn en het aantal elementen van de verzameling voorstellen.

Voorbeeld Als illustratie wordt de vaagverzameling “rond 5” weergeven, eerst metz’n lidmaatschapsfuncties en daarna de vage kardinaliteit.

V (“rond 5”) = {40.5, 51, 60.5}cardF (“rond 5”) = {30.5, 11}

Vage begrippen zijn niet algemeen gedefinieerd, maar worden geınterpreteerd en kunnendusdanig op vele verschillende manieren gedefinieerd worden, afhankelijk van de keuze vande auteur. (zie ook sectie 2.1.4 over kwantoren)

Opmerking Alhoewel vage kardinaliteit een meer natuurlijke extensie van het con-cept kardinaliteit is dan de Σ-count, is het een complexer concept en moeilijker te mani-puleren.

Relatieve kardinaliteit In een scherpe verzameling kunnen relatieve kardinaliteiteneenvoudig bekomen worden van absolute kardinaliteiten, namelijk het percentage van ele-menten van A dat zich in D bevindt.

cardR(A/D) =|A ∩D||D| (2.4)

Voor vaagverzamelingen is het nemen van bovenstaand quotient niet zo evident. In[Zad83] wordt volgende definitie gegeven voor de relatieve kardinaliteit van een vaagver-zameling A ten opzichte van een vaagverzameling D:

5

cardRF (A/D) =∑α

α/|Aα ∩Dα||Dα|

(2.5)

2.1.4 Bewerkingen op vaagverzamelingen

Unie en doorsnede

De standaarddefinitie voor doorsnede en unie, origineel gedefinieerd door Zadeh in [Zad65],zijn resp. de minimum en maximum functie.

Axioma’s We definieren twee begrippen t-normen en t-conormen, die functies re-presenteren die voldoen aan 4 axioma’s [KY95], nl. randvoorwaarde, monotoniteit, com-mutativiteit en associativiteit.

− Axioma’s voor t-norm:

◦ Axioma i1: ∀a ∈ [0, 1] : i(a, 1) = a (randvoorwaarde)

◦ Axioma i2: ∀a, b, d ∈ [0, 1] : b ≤ d⇒ i(a, b) ≤ i(a, d) (monotoniteit)

◦ Axioma i3: ∀a, b ∈ [0, 1] : i(a, b) = i(b, a) (commutativiteit)

◦ Axioma i4: ∀a, b, d ∈ [0, 1] : i(a, i(b, d)) = i(i(a, b), d) (associativiteit)

− Axioma’s voor t-conorm:

◦ Axioma u1: ∀a ∈ [0, 1] : u(a, 0) = a (randvoorwaarde)

◦ Axioma u2: ∀a, b, d ∈ [0, 1] : b ≤ d⇒ u(a, b) ≤ u(a, d) (monotoniteit)

◦ Axioma u3: ∀a, b ∈ [0, 1] : u(a, b) = u(b, a) (commutativiteit)

◦ Axioma u4: ∀a, b, d ∈ [0, 1] : u(a, u(b, d)) = u(u(a, b), d) (associativiteit)

De axioma’s zorgen ervoor dat een functie intuıtief aanvaardbaar is als doorsnede,resp. unie, m.a.w. elke t-norm kan fungeren als doorsnede-operator en elke t-conorm alsunie-operator. Een t-norm wordt ook genoteerd als i(a, b), een t-conorm als u(a, b).

Verbanden De wetten van de Morgan gelden ook op deze functies, m.a.w. i(a, b) =¬(u(¬a,¬b)) en vice versa. Hierdoor bestaat er voor elke t-norm een corresponderendet-conorm. Verder gelden volgende ongelijkheden:

i(a, b) ≤ a ≤ u(a, b)i(a, b) ≤ b ≤ u(a, b)

Voorbeelden Enkele bekende voorbeelden van t-normen en t-conormen, ook genoteerdals resp. i(a, b) en u(a, b), werden opgenomen in tabel 2.1. De Zadeh t-norm en t-conormworden vaak gebruikt omwille van hun eenvoudige berekenbaarheid, in figuur 2.2 wordteen voorbeeld gegeven.

6

t-norm i(a, b) t-conorm u(a, b)Zadeh min(a, b) max(a, b)

Lukasiewics max(a+ b− 1, 0) min(a+ b, 1)Probabilistisch ab a+ b− ab

Tabel 2.1: Voorbeelden van t-normen en t-conormen

Figuur 2.2: Voorbeeld van de Zadeh t-norm voor de definitie “groot en zeer groot”

Implicatieoperatoren

De traditionele implicatie (P ⇒ Q), dus als P dan Q, komt neer op de logische expressie(¬P )∨Q. De functie is meer waar (resp. vals) naarmate de functiewaarde dichter ligt bij1 (resp. 0).

Er bestaan verschillende families van vage implicatoroperators, met daarin telkensverschillende implicatoren afhankelijk van t-(co)normen. Veel gebruikte implicatie familieszijn: S-implicaties, R-implicaties en contraposities van R-implicaties.

Ook belangrijk in de praktijk zijn de zogenaamde coimplicaties, waarbij een coim-plicatie functie als volgt gedefinieerd wordt:

f coim(x, y) = ¬(fim(¬x,¬y)) (2.6)

S-implicaties De definitie van S-implicaties is gebaseerd op de expressie (P ⇒ Q) ⇔((¬P )∨Q), en maakt gebruik van een t-conorm. Algemeen kan een S-implicatie als volgtgedefinieerd worden:

(P ⇒S−i Q) = u(¬p, q) (2.7)

Met behulp van de De Morgan formule kan een S-coimplicatie dan eenvoudigweg alsvolgt gedefinieerd worden:

(P ⇒S−co Q) = i(¬p, q) (2.8)

waar u(p, q) een t-conorm is en i(p, q) een t-norm. Hieruit kunnen we besluiten datS-(co)implicaties volledig afhankelijk zijn van de gekozen t-(co)norm. In tabel 2.2 wordenenkele S-implicaties en hun bijhorende t-norm opgesomd.

R-implicaties Deze familie maakt gebruik van het principe van residuatie, waaruit vol-gende expressie bekomen wordt: (p ∧ (p ⇒ q)) ≤ q die gebruik maakt van een t-normi(a, b). Dit geeft aanleiding tot de volgende algemene definitie:

(P ⇒R−i Q) = supx∈[0,1]

{x|i(p, x) ≤ q} (2.9)

7

Definitie Gebruikte t-(co)normKleene-Dienes (P ⇒K−D Q) = (max(¬p, q)) u(a, b) = max(a, b)Reichenbach (P ⇒Rb Q) = (¬p+ p · q) u(a, b) = a+ b− a · b

Tabel 2.2: Voorbeelden van S-implicaties

Een andere, meer gebruikte vorm om R-implicaties voor te stellen, waarbij een functief de R-implicatie karakteriseert, is volgende definitie van implicatie en co-implicatie:

(P ⇒R−i Q) =

{1 als p ≤ qf(p, q) anders.

(2.10)

(P ⇒R−co Q) =

{0 als p ≥ qf co(p, q) anders.

(2.11)

Een bekende R-implicatie is deze van Godel waar f(p, q) = f co(p, q) = q waar de Zadeht-norm i(a, b) = min(a, b) gebruikt wordt.

(P ⇒Go Q) =

{1 als p ≥ qq anders.

Kwantoren

Kwantoren kunnen gebruikt worden in de zin van ‘Q X voldoen aan A’ met Q een kwantor,A een conditie en X een collectie van elementen, bvb. ‘de meeste (Q) huizen (X) voldoenaan huurprijs ≤ 500 (A)’. Bij flexibele bevraging kunnen kwantoren gebruikt wordenwanneer aan zo’n voorwaarde voldaan dient te worden, men dient dan te bepalen in welkemate Q elementen van X voldoen aan conditie A.

Kwantoren gedefinieerd over scherpe verzamelingen, zullen sterk gelinkt zijn aan hetbegrip kardinaliteit aangezien een scherpe kwantor Q een scherpe deelverzameling S(Q)voorstelt van absolute (waarden in N) of relatieve (waarden in Q ∩ [0, 1]) kardinalitei-ten. Bvb. de kwantor ∀ zal een deelverzameling van relatieve kardinaliteiten S(∀) = {1}voorstellen en op dezelfde manier zal S(≥ n) = N\{0, ..., n − 1} een deelverzameling vanabsolute kardinaliteiten voorstellen.

Vage kwantoren Kwantoren gedefinieerd over vaagverzamelingen kunnen omschrevenworden door linguıstische termen, zoals ‘ongeveer’. Het concept kardinaliteit speelt hiereen belangrijke rol, algemeen kan een vage kwantor geınterpreteerd worden als een vage ka-rakteristering van absolute of relatieve kardinaliteit van een of meer (vaag)verzamelingen.Men maakt een onderscheid tussen absolute en relatieve kwantoren: [Zad83]

− Absolute kwantoren beschrijven een getal of aantal (bvb. een twaalftal) en kunnenvoorgesteld worden door een vaagverzameling QA ⊆ R+ met µQA

: R → [0, 1]. Wekunnen QA(x) interpreteren als de mate waarin x ∈ R+ voldoet aan het conceptvoorgesteld door QA.

8

− Relatieve kwantoren verwijzen naar een proportie van het geheel (bvb. de meeste) enkunnen voorgesteld worden door een vaagverzameling QR ⊆ [0, 1] met µQR

: [0, 1]→[0, 1]. Hier kan QR(x) geınterpreteerd worden als de mate waarin het ratio x ∈ [0, 1]het concept QR representeert.

Vage kwantoren kunnen voorgesteld worden als vage getallen. Met vage getallen wor-den getallen bedoeld die gekarakteriseerd worden door een possibiliteitsdistributie (ziesectie 2.2) of een vaagverzameling zijn van reele getallen, een speciaal geval van vage ge-tallen is een interval. Een vaag getal zal niet steeds een vage kwantor zijn, bvb. in ‘Vickyis verscheidene jaren jonger dan Marie’ zal het vaag getal verscheidene geen vage kwantorzijn, terwijl dit in ‘Vicky heeft verscheidene goede vrienden’ wel het geval is.

Extensieprincipe van Zadeh

Een traditionele relatie, gedefinieerd over een eindig aantal universa, kan dusdanig wordenveralgemeend tot een veralgemeende realtie die inwerkt op vaagverzamelingen en resulteertin een vaagverzameling. Een methode om dergelijke veralgemeningen te bekomen wordteen extensieprincipe genoemd. Een van de bekendste extensieprincipe is het extensie-principe van Zadeh [Zad75]. Dit extensieprincipe wordt gebruikt voor het berekenen vande unie/doorsnede van (E)PTV’s en is gebaseerd op de t-(co)norm van Zadeh.

Definitie Zijn U1, . . . , Un en Y universa (n ∈ N0), V1, . . . , Vn vaagverzamelingen en is

R : U1 × . . .× Un → Y

een relatie, dan wordt de veralgemeende relatie R van R gedefinieerd als:

R : F(U1)×F(U2)× . . .×F(Un)→ F(Y )

V1, V2, . . . , Vn 7→ R(V1, V2, . . . , Vn)

Hierbij is R(V1, V2, . . . , Vn) de vaagverzameling die over het universum Y gedefinieerd isals:

R(V1, V2, ..., Vn) : Y → [0, 1]y 7→ sup

(x1,...,xn)∈VR,y

min(µV1(x1), . . . , µVn(xn)),∀y ∈ wd(R)

y 7→ 0,∀y /∈ wd(R)

waarbij wd(R) de waardenverzameling van de relatie R voorstelt, d.i.

wd(R) = {y|y ∈ Y ∧ ∃(x1, . . . , xn) ∈ U1 × . . .× Un : R(x1, . . . , xn) = y}

en VR,y de verzameling is van alle n-tuples die door middel van de relatie R worden afge-beeld op de waarde y, d.i.

VR,y = {(x1, . . . , xn)|(x1, . . . , xn) ∈ U1 × . . .× Un ∧R(x1, . . . , xn)) = y}

9

2.2 Possibiliteitstheorie

De possibiliteitstheorie wordt gebruikt voor het modelleren van onzekerheid of mogelijkheiden is nauw verwant met de vaagverzamelingenleer. Het dient niet verward te worden metde probabiliteitstheorie, waar de waarschijnlijkheid van evenementen gemodelleerd wordt.

Probabiliteiten Probabiliteiten drukken informatie uit m.b.t. het relatieve voorkomenvan een evenement (Prob(A) = frequentie waarmee A voorkomt). De probabiliteit van detegenovergestelde gebeurtenis kan zodus worden afgeleid uit de probabiliteit van de ge-beurtenis, er geldt immers Prob(A) = 1−Prob(A). Als een gebeurtenis dus volledig waar-schijnlijk is (Prob=1), dan is de tegenovergestelde gebeurtenis volledig onwaarschijnlijk(Prob=0).

Possibiliteiten Bij de possibiliteitstheorie geldt vorige veronderstelling niet. Zowel eengebeurtenis als z’n complement kunnen volledig mogelijk zijn (Pos=1 voor beide), in ditgeval kunnen we echter stellen dat beide gebeurtenissen niet noodzakelijk zeker zijn.

Possibiliteiten op zichzelf zijn dus feitelijk niet informatief, maar drukken voorkeu-ren uit. Het is pas als de possibiliteiten tegenover andere possibiliteiten worden ge-plaatst dat we informatie verkrijgen. Hiermee zien we een nood aan een tweede maat,de necessiteitsmaat, die de noodzakelijkheid van een gebeurtenis modelleert. Er geldtNec(A) = 1− Pos(A).

Er bestaan veel verschillende verbanden tussen possibiliteitstheorie en probabiliteits-theorie. Hieronder enkele verbanden die naar voor gebracht werden door L.A.

− Wat niet mogelijk is, is niet waarschijnlijk - ∀A ∈ F(U) : Nec(A) ≤ Prob(A)

− Wat waarschijnlijk is, is mogelijk - ∀A ∈ F(U) : Prob(A) ≤ Pos(A)

2.2.1 Vaagmaten

Twee bijzondere types van vaagmaten spelen een belangrijke rol in de possibiliteitstheorie:de possibiliteitsmaten en de necessiteitsmaten.

Possibiliteitsmaat

Een possibiliteitsmaat Pos, gedefinieerd over U , geeft de mate Pos(A) aan waarin hetmogelijk geacht wordt dat een element van het universum U behoort tot de verzamelingA ∈ F(U). De possibiliteitsmaat wordt gedefinieerd als Pos : F(U)→ [0, 1] met

− Randvoorwaarden: Pos(∅) = 0 en Pos(U) = 1

− Monotoniteitsvoorwaarde: ∀A,B ∈ F(U) : A ⊆ B ⇒ Pos(A) ≤ Pos(B)

− Voor elke verzameling {Ak|k ∈ K} ⊆ F(U) met K een willekeurige indexverzame-ling, geldt dat:

Pos(⋃k∈K

Ak) = supk∈K

Pos(Ak)

10

Necessiteitsmaat

Een necessiteitsmaat, gedefinieerd over U , geeft de mate Nec(A) aan waarin het noodzake-lijk of zeker wordt geacht dat een element van het universum U behoort tot de verzamelingA ∈ F(U). De necessiteitsmaat wordt gedefinieerd als Nec : F(U)→ [0, 1] met

− Randvoorwaarden: Nec(∅) = 0 en Nec(U) = 1

− Monotoniteitsvoorwaarde: ∀A,B ∈ F(U) : A ⊆ B ⇒ Nec(A) ≤ Nec(B)

− Voor elke verzameling {Ak|k ∈ K} ⊆ F(U) met K een willekeurige indexverzame-ling, geldt dat:

Nec(⋂k∈K

Ak) = infk∈K

Nec(Ak)

− Verband met possibiliteitsmaat

Nec(A) = 1− Pos(A)

Enkele belangrijke eigenschappen kunnen afgeleid worden uit deze definities:

− ∀A,B ∈ F(U) : Pos(A ∪B) = max(Pos(A),Pos(B))

− ∀A,B ∈ F(U) : Nec(A ∩B) = min(Nec(A),Nec(B))

2.2.2 Possibiliteitsdistributies

Elke possibiliteitsmaat, gedefinieerd over de machtsverzameling F(U) van een universumU , wordt op een unieke manier bepaald door een zgn. possibiliteitsdistributie

π : U → [0, 1]x 7→ Pos({x})

Algemeen:∀A ∈ F(U) : Pos(A) = max

x∈Aπ(x)

De possibiliteitsdistributie π bepaalt dus volledig de possibiliteitsmaat en speelt een-zelfde rol als een probabiliteitsdistributie in de probabiliteitstheorie.

Uit het verband tussen de possibiliteitsmaat en de necessiteitsmaat volgt dat een pos-sibiliteitsdistributie π eveneens de necessiteitsmaat volkomen bepaald:

∀A ∈ F(U) : Nec(A) = minx/∈A

(1− π(x))

Normaliseringsconditie De enige vereiste is dat er minstens een element met possibi-liteit 1 moet zijn of

maxx∈U

π(x) = 1

Verband met vaagverzamelingen Een possibiliteitsdistributie wordt volledig bepaalddoor de lidmaatschapsgraad µV van een vaagverzameling V , m.a.w. ∀x ∈ U : πX(x) =µV (x). De lidmaatschapsgraden worden hier dan geınterpreteerd als graden van onzeker-heid, µV zal dus bepalen in welke mate X = x mogelijk is.

11

2.3 EPTV’s

Om het begrip uitgebreide possibilistische waarheidswaarden of extended possibilistic truthvalues (EPTV’s) te begrijpen, dienen eerst de begrippen waarheidswaarde, uitgebreidewaarheidswaarde en possibilistische waarheidswaarde uitgelegd te worden.

2.3.1 Definitie

Waarheidswaarde t(p)

In de tweewaardige logica stelt het principe van bivalentie:

Elke propositie is ofwel waar, ofwel vals.

Er wordt m.a.w. van uitgegaan dat elke propositie in de realiteit kan worden getest enofwel volledig waar, ofwel volledig vals is.

Stel een universum P van alle proposities p. Men kan dus met elke propositie eenwaarheidswaarde associeren die aangeeft of de propositie waar (T ) of vals (F ) is, er geldtt : P → I met I = {T, F} en t(p) = T als p waar, t(p) = F als p vals.

Voorbeeld: t(‘2 is een even getal’) = T.

Uitgebreide waarheidswaarde t∗(p)

In informatiesystemen ontbreken vaak gegevens omdat ze betrekking hebben op uitzon-deringsgevallen die niet opgevangen zijn in het ontwerp. Indien deze gegevens door ‘T’ of‘F’ voorgesteld worden, zou informatieverlies optreden. Hiervoor kunnen we het principevan trivalentie gebruiken:

Elke propositie is ofwel waar, ofwel vals,ofwel is zijn waarheidswaarde niet gedefinieerd.

Om dit formeel te kunnen ondersteunen, wordt een waarheidswaarde ⊥ geıntroduceerd.We krijgen nu een uitgebreide verzameling I∗ = {T, F,⊥} en kunnen het begrip uitgebreidewaarheidswaarde definieren als t∗ : P → I∗ met t(p) = T of F als p waar, resp. vals ent(p) = ⊥ als p niet gedefinieerd.

We gebruiken de waarheidswaarde niet gedefinieerd als een propositie p (gedeeltelijk)niet van toepassing is, niet gedefinieerd is, niet bestaat of ondersteund wordt; in dezegevallen is het niet zinvol te beslissen of p al dan niet correspondeert met de werkelijkheid,d.i. p is dan noch waar, noch vals maar niet gedefinieerd.

Possibilistische waarheidswaarde t(p)

Door de klassieke twee-waardige waarheidswaarden te veralgemenen wordt het principevan bivalentie vervangen door een algemener principe van valentie, dat stelt dat:

Elke propositie heeft een (possibilistische) waarheidswaarde.

12

De possibilistische waarheidswaarde t(p) is gedefinieerd als t(p) : P → F(I). Elkepropositie zal dus afgebeeld worden op een vaagverzameling t(p), die een possibiliteitsdis-tributie voorstelt.

Algemeen is een possibilistische waarheidswaarde van de volgende vorm:

t(p) = {(T, VT ), (F, VF )}

Voor de eenvoud zullen we telkens VT noteren i.p.v. de meer complexe uitdrukkingµt(p)(T ), waarbij t(p) afgekort voorgesteld wordt door de vaagverzameling V (analoog voorde F en later ⊥ waarde).

Uitgebreide possibilistische waarheidswaarde t∗(p)

Om te kunnen omgaan met proposities waarvan de waarheidswaarde (deels) niet gede-finieerd is, werd het concept ‘uitgebreide possibilistische waarheidswaarden’ of EPTV’sgedefinieerd.

Een EPTV t∗(p) wordt gedefinieerd door: t∗ : P → F(I∗) met I∗ = {T, F,⊥}, metelke propositie p ∈ P wordt een vaagverzameling t∗ geassocieert, die opnieuw een possibi-liteitsdistributie voorstelt. Algemeen is een uitgebreide possibilistische waarheidswaardevan de volgende vorm:

t(p) = {(T, VT ), (F, VF ), (⊥, V⊥)}

Voorbeeld: t(‘het huis is goedkoop’) = {(T, 1.0), (F, 0.7), (⊥, 0.5)} heeft als betekenis:het is volkomen mogelijk dat het huis goedkoop is, in mindere mate mogelijk dat het huisniet goedkoop is en in nog mindere mate is het mogelijks niet zinvol is om uitspraken tedoen over de prijs van het huis (bvb. omdat het huis niet te koop is).

2.3.2 Calculus voor EPTV’s

De rekenregels voor negatie, conjunctie, disjunctie, implicatie en equivalentie zijn gedefini-eerd als veralgemeningen van hun tegenhangers voor uitgebreide waarheidswaarden, doortoepassing van het extensieprincipe van Zadeh. Enkel de uitgebreide rekenregels voornegatie, conjunctie en disjunctie worden hieronder verder besproken.

Volgende rekenregels worden besproken voor een of meerdere EPTV’s, gekarakteriseerddoor de vaagverzamelingen V en U . De lidmaatschapsgraden zullen opnieuw genoteerdworden als VT i.p.v. µt(p)(T ) etc. voor de eenvoud.

Regel voor negatie

¬ t(p) = {(T, VF ), (F, VT ), (⊥, V⊥)} (2.12)

Regel voor conjunctie

t(p) ∧ t(q) = {(T, µF ), (F, µT ), (⊥, µ⊥)}

13

met µT , µF , µ⊥:

µT = min(UT , VT )

µF = max

min(UT , VF )min(UF , VT )min(UF , VF )min(UF , V⊥)min(U⊥, VF )

µ⊥ = max

min(UT , V⊥)min(U⊥, VT )min(U⊥, V⊥)

(2.13)

Regel voor disjunctie

t(p) ∨ t(q) = {(T, µF ), (F, µT ), (⊥, µ⊥)}met µT , µF , µ⊥:

µT = max

min(UT , VT )min(UT , VF )min(UT , V⊥)min(UF , VT )min(U⊥, VT )

µF = min(UF , VF )

µ⊥ = max

min(UF , V⊥)min(U⊥, VF )min(U⊥, V⊥)

(2.14)

2.4 Flexibele bevraging van reguliere databanken

De kerngedachte bij flexibele bevraging is dat er preferenties worden geıntroduceerd in devraagstellingen. Dit kan gebeuren op twee niveaus: binnen of tussen bevragingscondities.

In de volgende delen zal telkens de benadering met uitgebreide possibilistische waar-heidswaarden worden beschouwd, maar dit is niet de enige benadering.

2.4.1 Preferenties binnen bevragingscondities

Preferenties binnen bevragingscondities geven aanleiding tot flexibele zoekcriteria en latenhet toe om uit te drukken dat sommige waarden meer gepast zijn dan andere. Een gebrui-ker zal slechts bij benadering opgeven welke waarden hij zoekt in de databank, omdat hijbvb. enige tolerantie wenst te hanteren bij het bevragen van de databank.

Modellering m.b.v. linguıstische termen

Gewenste waarden slechts bij benadering opgeven, komt neer op aangeven welke waardenmeer en minder geschikt zijn. Dit kan worden gemodelleerd m.b.v. vaagverzamelingenwaarbij de lidmaatschapsgraden worden geınterpreteerd als graden van overeenstemming.

14

Aangezien het nogal omslachtig is om telkens de volledige vaagverzameling uit te schrij-ven, wordt meestal met een linguıstische term gewerkt die de vaagverzameling beschrijft(vb. “rond 1920”) en als label wordt gebruikt voor de vaagverzameling. De lidmaat-schapsgraad µV (x) met label L drukt uit in welke mate x typerend is als waarde voorde linguıstische term L. Indien L de vaagverzameling V identificeert, kan µV wordengenoteerd als µL.

In de praktijk zal veelal gewerkt worden met vaagverzamelingen die gedefinieerd zijnover een domein. Als dit domein meetbaar is zal de vaagverzameling meestal gedefinieerdworden aan de hand van een trapezoıdale lidmaatschapsfunctie. Bij onmeetbare domeinenwerkt men met vaagverzamelingen met een discrete lidmaatschapsfunctie.

Modificatiefuncties De betekenis van een linguıstische term kan worden versterkt ofafgezwakt door bijwoorden, bvb. ‘zeer kostbaar’.

Dit concept kan wiskundig gemodelleerd worden m.b.v. van een modificatiefunctie dieinwerkt op de corresponderende lidmaatschapsfunctie. Men kan een onderscheid makentussen premodificatie en postmodificatie.

− Bij premodificatie zal de lidmaatschapsfunctie µL inwerken op de modificatiefunc-tie mpre. Premodificatie verandert de vorm en de plaats van de lidmaatschapsfunctieen is daardoor het meest geschikt bij het modelleren van vaagheid en onnauwkeu-righeid.

∀x ∈ U : µLmod(x) = µL(mpre(x))

− Bij postmodificatie werkt de modificatiefunctie mpost in op de lidmaatschapsfunc-tie µL. Postmodificatie verandert enkel de vorm van de lidmaatschapsfunctie en isdaardoor het meest geschikt bij het modelleren van onzekerheid.

∀x ∈ U : µLmod(x) = mpost(µL(x))

De meest gebruikte versterkende modificatiefuncties zijn de kwadrateringsfunctie (.2)en de vierde machtsfunctie (.4). De meest gebruikte verzwakkende modificatiefuncties zijnde vierkantswortelfunctie (.1/2) en de vierdewortelfunctie (.1/4).

Evaluatie met EPTV’s

Flexibele zoekcriteria in de vraagstelling zorgt ervoor dat databankobjecten slechts inbeperkte mate kunnen voldoen aan de opgelegde criteria, elk object dient dan ook ge-evalueerd te worden t.o.v. de criteria.

In dit eindwerk wordt enkel de meer geavanceerde benadering opgenomen, waarbij deevaluatie zal resulteren in een EPTV die dan verder met het object wordt geassocieerd.Het achterliggende idee is dat recordtypedefinities kunnen worden gezien als predikatenen de records zelf als proposities. Om een gradatie van waarheid te modelleren, kunnenEPTVs worden gebruikt die uitdrukken in welke mate men zeker (of onzeker) kan zijn datvoldaan is aan de betreffende propositie. De EPTV’s worden berekend m.b.v. aangepasteevaluatiefuncties.

15

Enkelvoudige condities Bij flexibele bevraging kunnen zowel klassieke bevragingscon-dities voorkomen als flexibele. Voor de evaluatie van de klassieke condities wordt gesteundop klassieke (Booleaanse) logica. Als een conditie evalueert naar waar (T ), dan is de cor-responderende EPTV {(T, 1)} het is zeker dat voldaan is aan de conditie. Evalueert deconditie naar vals (F ), dan is de corresponderende EPTV {(F, 1)} het is zeker dat nietvoldaan is aan de conditie.

Voor enkelvoudige (of atomaire) flexibele bevragingscondities zijn de meest couranteevaluatiefuncties de vergelijkingsoperatoren en de compatibiliteitsoperator.

Gelijkheidsoperatoren (=, 6=) Voor het modelleren van de gelijkheidsoperator =kan men steunen op de standaard gelijkheidsoperator van Zadeh of op de graduele gelijk-heidsoperator. Daarbij dient de scherp omschreven attribuutwaarde a uit de databank teworden omgezet naar een vaagverzameling {(a, 1)}.

− Gelijkheid volgens de standaard gelijkheidsoperator correspondeert met {(T, 1)};

− Ongelijkheid volgens de standaard gelijkheidsoperator correspondeert met {(F, 1)}.

Bij toepassing van de graduele gelijkheidsoperator wordt de resulterende EPTV alsvolgt bekomen uit de bekomen graad van gelijkheid deg :

{(T, degmax(deg, 1− deg)

), (F,1− deg

max(deg, 1− deg))} (2.15)

Vergelijkingsoperatoren (<,>,≤,≥) De vergelijkingsoperatoren kunnen via hetextensieprincipe van Zadeh bekomen worden. Met op ∈ {<,>,≤,≥} en L de vaagver-zameling met aanvaardbare waarden wordt de EPTV bij de operator op dan bekomenals:

{(T, µTmax(µT , µF )

), (F,µF

max(µT , µF ))} (2.16)

waarbij µT = sup{x|x∈U∧a op x} µL(x) en µF = sup{x|x∈U∧NOT(a op x)} µL(x).

Compatibiliteitsoperator (IS) De mate van e(A IS L)(r) compatibiliteit tussende attribuutwaarde a die bekomen wordt uit het record r van de databank en de aan-vaardbare waarden uit de bevragingsconditie kan worden bepaald als

e(A IS L)(r) = {(T, µL(a)max(µL(a), 1− µL(a))

, (F,1− µL(a)

max(µL(a), 1− µL(a)))} (2.17)

Evaluatie van samengestelde condities Voor samengestelde condities gebeurt deevaluatie volkomen analoog als in Booleaanse logica: eerst worden de enkelvoudige condi-ties geevalueerd (wat resulteert in EPTV’s), daarna wordt de expressie geevalueerd reke-ning houdend met voorkomende haakjes.

Voor de conjunctie, disjunctie en negatie van de EPTV’s kan men gebruik maken vande rekenregels die zijn gegeven in sectie 2.1.4.

16

2.4.2 Preferenties tussen bevragingscondities

Preferenties tussen bevragingscondities worden gebruikt om verschillende graden van be-langrijkheid te associeren met de condities.

Traditioneel zijn alle enkelvoudige condities die voorkomen in een samengestelde be-vragingsconditie even belangrijk. Nochtans kan het voorkomen dat de gebruiker bepaaldeprioriteiten (voorkeuren of preferenties) heeft en wenst dat bepaalde condities een grote-re impact hebben op (of meer relevant zijn voor) het resultaat van de vraagstelling danandere. Dit kan worden gerealiseerd door gewichten te associeren met de condities.

Modellering

Het associeren van gewichten met bevragingscondities kan worden gemodelleerd door aanelke conditie een getal uit het eenheidsinterval te koppelen. Om een zinvolle modelleringvan gewichten te zijn, moeten deze getallen voldoen aan de volgende voorwaarden [16]:

Veronderstel dat wi ∈ [0, 1] het gewicht is dat geassocieerd is met conditie ci , waarbijwi = 0 totaal niet belangrijk aanduidt en wi = 1 totaal belangrijk aanduidt.

− Om een geschikte referentie en schaling te hebben, moet er gelden dat: maxi(wi) = 1.

− Als wi = 1 en ci = F , moet de impact van het gewicht gelijk zijn aan ‘vals’ (F ).

− Als wi = 1 en ci = T , moet de impact van het gewicht gelijk zijn aan ‘waar’ (T ).

− Ten slotte, als wi = 0 moet de impact van het gewicht het neutraal element opleve-ren.Bij de conjunctie (∧) is dit ‘waar’ (T ), bij de disjunctie (∨) ‘vals’ (F ). M.a.w.als ci totaal niet belangrijk is, moet de impact van het gewicht dusdanig zijn, dathet lijkt alsof ci niet bestaat.

Evaluatie met (E)PTV’s

Om de impact van gewichten adequaat te kunnen modelleren binnen het raamwerk dat ge-bruikt wordt voor de ondersteuning van flexibele bevraging, kunnen implicatieoperatorenworden gebruikt. De twee benaderingen uit sectie 3.2 worden hieronder verder beschreven.Benadering met (uitgebreide) possibilistische waarheidswaarden.

Bij deze benadering resulteert de evaluatie van een conditie in een EPTV (cf. 3.2).Volkomen analoog aan voorgaande benadering kunnen gewichten in rekening gebrachtworden door:

1. De enkelvoudige condities te evalueren alsof er geen gewichten meespelen. Dit resul-teert voor elke enkelvoudige conditie in een EPTV. Het gewicht van de enkelvoudigeconditie wordt geassocieerd met de EPTV.

2. Een implicatoroperator ∧⇒f (resp. ∨⇒f ) te beschouwen voor conjunctie (resp. dis-junctie).

3. Een uitgebreide versie ∧wi (resp. ∨wu) te definieren van de conjunctieoperator ∧(resp. disjunctieoperator ∨), gebruik makende van de implicatoroperator ∧⇒f (resp.∨⇒f ). Deze uitgebreide operatoren werken in op EPTVs met geassocieerde gewichtenen resulteren in een geaggregeerde EPTV met geassocieerd geaggregeerd gewicht.

17

4. Een uitgebreide versie ¬w te definieren van de negatieoperator ¬. Deze uitgebreideoperator werkt in op een EPTV met geassocieerd gewicht en resulteert in de negatievan de EPTV met hetzelfde geassocieerd gewicht.

5. Bij de evaluatie van de samengestelde conditie wordt gebruik gemaakt van de uitge-breide operatoren voor conjunctie, disjunctie en negatie (∧wu,∨wu en ¬w).

Definitie implicatoroperatoren Voor de definitie van de implicatoroperatoren voorconjunctie ∧⇒f en disjunctie ∨⇒f kan een vage implicatoroperator⇒f , zoals geıntroduceerdin sectie 2.1.4, worden gebruikt. Algemeen krijgt men dan met I = {T, F}:

− Implicatoroperator voor conjunctie ∧⇒f (w, V ) waarbij:

µ ∧⇒f (w,V )(T ) = (w ⇒f µV (T ))

µ ∧⇒f (w,V )(F ) = (¬w ⇒co

f µV (F ))(2.18)

− Implicatoroperator voor disjunctie ∨⇒f (w, V ) waarbij:

µ ∨⇒f (w,V )(T ) = (¬w ⇒co

f µV (T ))

µ ∨⇒f (w,V )(F ) = (w ⇒f µV (F ))

(2.19)

Definitie uitgebreide conjunctie, disjunctie en negatie De uitgebreide versies vande conjunctie (∧wi), disjunctie (∨wi) en negatie (¬w) operatoren kunnen als volgt wordengedefinieerd:

− Uitgebreide operator voor conjunctie ∧wi:

((w1, V1), (w2, V2)) 7→ (u(w1, w2), ∧⇒f (w1, V1)∧i ∧⇒f (w2, V2)) (2.20)

− Uitgebreide operator voor disjunctie ∨wi:

((w1, V1), (w2, V2)) 7→ (u(w1, w2), ∨⇒f (w1, V1)∨u ∨⇒f (w2, V2)) (2.21)

− Uitgebreide operator voor negatie ¬w : (w, V ) 7→ (w, ¬(V )).

waarbij ∧i (resp. ∨u) een conjunctie (resp. disjunctie) operator voor PTV’s is, geba-seerd op een (t-norm,t-conorm)-koppel (i, u) en ¬ de negatieoperator voor PTV’s zoalsbesproken in sectie 2.4.1.

Normalisering Het dient opgemerkt te worden dat na toepassing van de uitgebreideoperators de verkregen PTV’s niet genormaliseerd zijn.

18

Hoofdstuk 3

Praktische onderbouw

Er werd eerst onderzoek gedaan naar welke frameworks reeds aanwezig waren, en of dezekonden hergebruikt worden. Eerst werd gekeken naar het gebruik van kwantoren in stan-daard SQL. Reden hiervoor is een syntax te definieren die goed aansluit bij de bestaandeSQL-syntax.

Verder zal gebruik gemaakt worden van het reeds bestaande framework omtrent “Flex-QL” uit het thesiswerk van T. Matthe en K. Tourne [MT03]. Het thesiswerk met als titel“Flexibele bevraging van relationele databanken: studie en implementatie” waar in de im-plementatie SQL wordt uitgebreid met de mogelijkheid trapeziumfuncties, gewichten entreshold waarden (om aantal tuples in resultaat te beperken) op te geven. Dit frameworkzal als basis gebruikt worden voor de implementatie.

Als laatste is er een reeds bestaand framework die vaagverzamelingen, bewerkingen opvaagverzamelingen (t-normen en t-conormen), implicatoren voor het gebruik van gewich-ten en EPTV’s implementeert. Dit framework werd verder uitgebreid met de benodigdefunctionaliteit en volledig geıntegreerd met het FlexQL raamwerk. Op deze manier ishet heel eenvoudig om andere aggregatoren/implicatoren te definieren en gebruiken in hetFlexQL raamwerk.

In dit hoofdstuk worden bovenstaande technologieen uitgebreid besproken.

3.1 SQL syntax

Volgende informatie werd teruggevonden op de site van Sun Microsystems in MySQL 5.0Reference Manuel [Mic] in verband met het gebruik van kwantoren in de SQL syntax.

3.1.1 De existentiele kwantor ∃operand comparison_operator ANY (subquery)operand IN (subquery)operand comparison_operator SOME (subquery)

Het ANY sleutelwoord zal TRUE teruggeven als de vergelijking waar is voor minstenseen waarde in de kolom die teruggegeven wordt door de subquery. Het sleutelwoord IN iseen synoniem voor = ANY en kan bovendien gebruikt worden met een expressie lijst.

19

uitdrukking betekenisM | N Alternatie, kies tussen M en NM N Concatenatie, M gevolgd door NM* Repetitie, 0 of meerdere keren MM+ Repetitie, 1 of meerdere keren MM? Optioneel, 0 of 1 maal M“x” Letterlijk het symbool x[a-z] Een willekeurig symbool tussen a en z∼M De negatie, dus alles uitgezonderd M“\x” Letterlijk x, met x “ of ‘ of \

Tabel 3.1: Reguliere expressieregels

3.1.2 De absolute kwantor ∀operand comparison_operator ALL (subquery)operand NOT IN (subquery)

Het sleutelwoord ALL zal TRUE teruggeven als de vergelijking waar is voor alle waardenin de kolom bepaald door de subquery. Het sleutelwoord NOT IN is een synoniem voor<> ALL.

3.2 FlexQL

Hier wordt het reeds bestaande framework omtrent “FlexQL” uit het thesiswerk van T.Matthe en K. Tourne besproken. [MT03]

3.2.1 Syntax

Men gebruikt de BNF syntax omdat deze het mogelijk maakt op een consistente maniereen parser voor de FlexQL taal te construeren. De BNF methode syntax werd uitgebreidmet syntaxregels van reguliere expressies zodat het geheel compacter en meer leesbaar zouzijn. De reguliere expressieregels kunnen teruggevonden worden in tabel 3.1.

Verder zijn volgende sleutelwoorden gedefinieerd in de FlexQL taal: as, and, distinct,from, imp, like, not, or, select, trapezium, where. De sleutelwoorden zijn hoofdletter-ongevoelig en worden voorgesteld tussen < en >.

Vervolgens worden reguliere expressies en grammaticale BNF regels gedefinieerd. Be-merk het verschil tussen beide: de reguliere expressies stellen enkel de opeenvolgendetekensequenties voor, en alle mogelijke invoersequenties kunnen voorgesteld worden dooreen deterministische eindige toestandsautomaat. De grammaticale regels daarentegen bie-den meer mogelijkheden, door gebruik te maken van recursie waardoor men meer complexeuitdrukkingen kan bekomen.

Samengevat dienen de reguliere expressies opgevat te worden als symbolen van deFlexQL taal en kan men dan door toepassing van de grammatica regels een set van geldigezinnen bekomen.

20

Reguliere expressies

Een aantal veel voorkomende tekensequenties worden eveneens voorgesteld tussen < en>. Het betreft hier tekensequenties die gedefinieerd kunnen worden aan de hand vanreguliere expressies.

<PLUSINF> := "+inf"<MININF> := "-inf"<COMPARATOR> := "=" | "<>" | "<=" | ">=" | "<" | ">"<ID> := <LETTER> (<LETTER>|<DIGIT>)*<INTEGER> := (<DIGIT>)+<FLOAT> := (<DIGIT>)+ "." (<DIGIT>)*<TEXTSTRING> := ("\"" (~["\""]|"\\\"")* "\"")

| ("\’" (~["\’"]|"\\\’")* "\’")<DATE> := <INTEGER>"/"<INTEGER>"/"<INTEGER>

| <INTEGER>"-"<INTEGER>"-"<INTEGER>

Met hierbij nog volgende hulpterminalen verondersteld:

<LETTER> := ["_","a"-"z","A"-"Z"]<DIGIT> := ["0"-"9"]

Voor de volledigheid dient ook de <EOF> marker opgenomen te worden die aanduidtdat het einde is bereikt.

Semantiek De <mininf> en <plusinf> stellen respectievelijk −∞ en +∞ voor. Inde huidige versie van FlexQL kunnen ze enkel worden gebruikt in combinatie met detrapezium functies.

De (nogal complexe) definitie van <textstring> definieert enkel de standaard notatievoor objecten van het type string.

BNF Grammatica

Select := <SELECT> (<DISTINCT>)? (TresHold)? Columns <FROM> Tables( <WHERE> Conditions )? <EOF>

SubSelect := <SELECT> (<DISTINCT>)? (TresHold)? Columns <FROM> Tables( <WHERE> Conditions )?

Columns := ( ( <ID> "." )? <ID> ( (<AS>)? <ID> )?( "," ( <ID> "." )? <ID> ( (<AS>)? <ID> )? )* | "*" )

Tables := ( "(" SubSelect ")" ( (<AS>)? <ID> )?| <ID> ( (<AS>)? <ID> )? )

( "," ( "(" SubSelect ")" ( (<AS>)? <ID> )?| <ID> ( (<AS>)? <ID> )? ) )*

Conditions := OrCondOrCond := ( AndCond ( <OR> AndCond )* )AndCond := ( UnaryCond ( <AND> UnaryCond )* )

21

UnaryCond := ( <NOT> ( "(" OrCond ")" | Comparisson ) )| "(" OrCond ")"| Comparisson

Comparisson := PartComp ( ( <COMPARATOR> ( PartComp | FuzzyTrapezium ))| ( <LIKE> StringComp ) ) ImpComp

PartComp := IDComp | NumberComp | StringComp | DateComp

IDComp := <ID> ( "." <ID> )?StringComp := <TEXTSTRING>NumberComp := ( <INTEGER> | <FLOAT> )DateComp := <DATE>ImpComp := ( ( <IMP> ( <FLOAT> | <INTEGER> ) )? )

FuzzyTrapezium := <TRAPEZIUM> "(" (( ( <INTEGER> | <FLOAT> | <MININF> )"," ( <INTEGER> | <FLOAT> )"," ( <INTEGER> | <FLOAT> ) ","( <INTEGER> | <FLOAT> | <PLUSINF> )

) |( ( <MININF> | <DATE> ) ","

<DATE> "," <DATE> ","( <DATE> | <PLUSINF> ) ))

")"

TresHold := "[" (( "n" "=" <INTEGER> ) |( "r" "=" ( <INTEGER> | <FLOAT> )) |( "t" "=" "(" ( <INTEGER> | <FLOAT> ) ";"

( <INTEGER> | <FLOAT> ) ";"( <INTEGER> | <FLOAT> )

")"))*

"]"

Semantiek Naast de syntax dient er uiteraard betekenis gehecht te worden aan alleverschillende FlexQL constructies. Er wordt verondersteld dat de lezer reeds vertrouwd ismet standaard SQL, en gerelateerde constructies worden niet verder besproken.

Om zoveel mogelijk abstractie te maken van bestaande SQL implementaties wordendaar waar mogelijk verschillende SQL dialecten gelijktijdig ondersteund. Een eerste voor-beeld hiervan is de specificatie van een kolom- of tabelalias. Zowel “tabel AS alias” als“tabel alias” zijn geldig om een alias te specificeren.

Toekennen van gewichten aan enkelvoudige condities

Gewichten kunnen als volgt gespecificieerd worden:

conditie <imp> weight

22

Hierbij kan conditie eender welke restrictie zijn zoals gedefinieerd in de syntax en is weighteen waarde in [0, 1]. Bemerk dat wanneer er geen weight gespecificeerd is, dit overeenstemtmet weight = 1.

Verder dient nog opgemerkt dat de huidige theorie enkel gewichten ondersteunt toege-kend aan enkelvoudige condities. Bijgevolg is (c1 AND c2) imp 0.7 geen geldige specificatie.

Trapeziumfuncties

Trapeziumfuncties werden al gedefinieerd in Hfst. 2, de definitie kan teruggevonden wordenin formule 2.1. EPTV’s worden hieruit geconstrueerd als:

p(T, F,⊥) =

{{(T, 0), (F, 0), (⊥, 1)} als x is NULL{(T, fabcd), (F, 1− fabcd), (⊥, 0)} elders

(3.1)

Merk op dat deze formule kan niet-genormaliseerde EPTV’s teruggeven en dat deze -indien gewenst - nog genormaliseerd moeten worden.

De trapeziumfuncties zijn enkel gedefinieerd voor numerieke datatypes (datum veldenkunnen door interne conversie naar een numeriek type nog bruikbaar zijn). Vage bevragingvan tekstuele data is bijgevolg nog niet mogelijk.

Treshold waarde

Treshold specificaties worden gebruikt om het aantal tupels in het resultaat te beperken.Om de gebruiker een maximum aan vrijheid te geven, worden drie verschillende wijzenondersteund waarop een dergelijke restrictie kan worden gespecificeerd.

- n ∈ N: Geeft het maximaal aantal tupels op die in het resultaat mogen wordenopgenomen.

- r ∈ [0, 1]: Geeft de minimale waarde aan die de ordeningsfunctie moet teruggevenvoor elk individueel tupel.

- t = (x; y; z) met x, y, z ∈ [0, 1]: Alle tupels die een EPTV bevatten die groter is dandeze gespecificeerde waarde worden behouden.

Indien meerdere treshold restricties gelijktijdig worden gespecificeerd, wordt steeds demeest restrictieve toegepast.

Subqueries

Het nesten van FlexQL uitdrukkingen wordt in de huidige versie slechts in beperkte mateondersteund. Zo wordt reeds toegestaan dat een bevraging gebeurt op een resultaat vaneen andere FlexQL bevraging (een nieuwe select-from-where toevoegen in het from gedeeltevan de hoofdbevraging is toegestaan).

3.2.2 Applicatie

De implementatie van FlexQL zoals gedefinieerd is complexer dan op het eerste zichtte verwachten valt. De reden hiervoor is dat een uitbreidbare applicatie een volledigesemantische analyse moet uitoefenen op de FlexQL vraag die wordt gesteld. Dit is onder

23

Figuur 3.1: Algemene structuur applicatie

meer vereist om consistente foutboodschappen mogelijk te maken, maar ook om volledigeabstractie te kunnen maken van de gebruikte relationele databank. De ontwikkeling vaneen dergelijke FlexQL interpreter blijkt dan ook reeds nauw aan te leunen bij het ontwerpvan een volledig databanksysteem voor vage bevraging.

Een volledige grondige bespreking van de ontwikkelde applicatie valt buiten het kadervan dit eindwerk, slechts enkele (van de meest interessante) aspecten zullen worden bespro-ken. Er wordt vooral de nadruk gelegd op de aangeboden interfaces en de mogelijkhedenhiervan.

Algemene architectuur

Een grafische voorstelling kan meer inzicht verschaffen in de algemene structuur van deapplicatie, deze is terug te vinden in figuur 3.1. De applicatie is toegankelijk via eenwebgebaseerde interface en geımplementeerd in Java.

Verder wordt de webgebaseerde interface en de parser besproken. De EPTV-gebaseerdeclassificatie kon teruggevonden worden in de semantiek van o.a. trapeziumfuncties en mo-delleren van gewichten (in sectie 3.2.1). Slechts de belangrijkste informatie is opgenomen indit werk, meer informatie over alle delen kan uitgebreid teruggevonden worden in [MT03].

Webgebaseerde interface

Om een ruime gebruikersbasis te kunnen verzorgen, zijn meerdere interfaces gedefinieerd.Zo ligt de keuze bij de gebruiker om een ruim aanbod aan functionaliteit, of een gemak-kelijke interface aanbieden.

Query Form Ten eerste wordt een zeer eenvoudige interface aangeboden die enkel con-junctieve aggregatie ondersteunt. Hierbij wordt slechts 1 restrictie per kolom uit de da-tabank aangeboden. De voordelen zijn dat deze interface totaal geen kennis van FlexQLvereist en automatisch opgebouwd wordt via metadata uit de database. Dit maakt elkekennis van de structuur van de onderliggende databank eveneens overbodig.

De interface is vrij eenvoudig en vergt weinig uitleg. Verder biedt de interface demogelijkheid om een join uit te voeren tussen twee tabellen, wat standaard gebeurt door

24

Figuur 3.2: Plain FlexQL Query Interface

een carthesisch product te maken van de geselecteerde tabellen.

Extended Query Form Een tweede meer complexe interface laat toe om naast con-junctieve ook disjunctieve aggregatie toe te passen. Verder wordt de mogelijkheid gebodenom structuur aan te brengen in de bevraging. Een eenduidige interface hiervoor ontwik-kelen blijkt niet eenvoudig. Bovendien worden de mogelijkheden nog beperkt door dewebgebaseerde HTML interface die weinig geavanceerde GUI mogelijkheden biedt. Verderis de interface ontwikkeld naar het voorbeeld van “Microsoft Access”software. Verderedetails over deze webinterface kunnen teruggevonden worden in [MT03].

Plain FlexQL Query Interface De derde interface laat ten slotte toe om algemeneFlexQL bevragingen uit te voeren. De vorige formulieren lieten de gebruiker toe ombevragingen uit te voeren met een beperkte tot geen kennis van FlexQL, het is duidelijkdat dit beperkingen inhoud. Het derde formulier laat toe om ook zelf FlexQL bevragingenrechtstreeks in te geven. Deze worden zonder verdere bewerkingen doorgegeven aan deparser, zodat alle formeel gedefinieerde mogelijkheden van FlexQL ook in de praktijk tetesten zijn. Een screenshot van de applicatie is terug te vinden in figuur 3.2.

Ook hier behoeft de interface weinig verduidelijking. Bemerk dat het resultaat nu ophetzelfde scherm kan worden getoond als de vraagstelling, wat het overzicht zeker ten goedekomt. Het bovenstaande voorbeeld is uitgevoerd op een fictieve personeelsdatabank. Uitdeze databank worden alle personeelsleden opgevraagd met een middelmatige intelligentie,bij voorkeur van het mannelijke geslacht.

25

JavaCC parser

Het volledig handmatig ontwikkelen van code om een taal als FlexQL te interpreteren isvrij omslachtig. Bovendien is het zeer moeilijk om in een dergelijk ontwerp een volledigescheiding tussen syntax en semantiek van de taal te realiseren. Om deze redenen is ge-opteerd om gebruik te maken van een automatische parser generator. Voor Java zijn demogelijkheden beperkt, er is gekozen voor JavaCC, ontwikkeld door MetaMata in samen-werking met Sun Microsystems. Het betreft een open source programma dat min of meerals standaard wordt aanvaard binnen de Java omgeving. Bovendien zijn er standaardimplementaties te vinden van heel wat talen, waaronder ook SQL. Deze implementatieblijkt echter niet bruikbaar voor het ontwerp van FlexQL aangezien deze laatste een grootaantal mogelijkheden van standaard SQL nog niet ondersteund.

Op basis van de formele FlexQL definities kan vrijwel onmiddellijk een parser wordengegenereerd. De definities zijn dan ook bewust zo opgesteld dat ze nauw aanleunen bijde invoer die een automatische parser generator aanvaardt. Dit heeft als voordeel dat dekans op inconsistenties tussen de formele definities van FlexQl en de implementatie ervansterk verkleinen.

De door JavaCC automatisch gegenereerde parser code zal uit de FlexQL invoer eenabstracte syntaxboom construeren. Het is op basis van deze boom dat verdere verwerkingmogelijk wordt, na het uitvoeren van een aantal transformaties voor het omzetten van deboom naar een eenvoudiger vorm.

Op basis van de vereenvoudigde syntaxboom wordt vervolgens de SQL code gegene-reerd waarmee de relationele databank kan worden bevraagd. Hierbij worden in de matevan het mogelijke alle scherpe criteria geextraheerd uit de boom en verwerkt in de SQLcode.

3.2.3 Besluit

Enkele problemen zijn nog terug te vinden. Een ervan is deze van het carthesisch productnemen. Na de scherpe bevraging wordt alle informatie uit de databank gehaald en op-geslagen in het geheugen. Hiermee wordt dan verder gewerkt om de vage criteria toe tepassen. Het nadeel hiervan is dat wanneer een carthesis product dient genomen te wordenvan enkele tabellen dit zeer snel voor een geheugen “overflow”zal zorgen. Dit probleem isvrij fundamenteel en een oplossing is dan ook niet zomaar voor handen. Verder onderzoekis hier zeker nog nodig over hoe de classificatie kan gebeuren zonder eerst alle data in hetgeheugen te laden. Vooral het tussenliggend optimaliseren, waarbij ongeldige tupels reedsin een vroegtijdig stadium geelimineerd worden, verdient hierbij extra aandacht.

De ontwikkelde EPTV technieken blijken reeds goed inzetbaar in een realistische om-geving als de vage databankbevraging. Tijdens het ontwerp en implementatie blijk datnog heel wat details betreffende FlexQL verder onderzoek behoeven. De huidige imple-mentatie moet dan ook meer als een eerste prototype worden beschouwd dat reeds eendemonstratie geeft van de mogelijkheden die een taal als FlexQL te bieden heeft. Verderis het duidelijk dat een realistische implementatie van een taal als FlexQL verre van een-voudig is. De overstap van de huidige implementatie naar een volledig databanksysteemdat ook voor eigen dataopslag en verwerking zorgt is dan ook niet zo groot meer.

26

3.3 Fuzzy sets (ddcm)

Binnen de onderzoeksgroep (DDCM) was reeds een raamwerk aanwezig voor vaagverza-melingen. Wat vooral belangrijk is, dat reeds een doordachte structuur aanwezig was, diegebruik maakt van Java Generics en interface methodes zodat een logische (doch com-plexe) structuur bekomen wordt. Onder andere (E)PTV’s, trapeziumfuncties, t-normen,t-conormen, unie, disjunctie, etc. waren reeds geımplementeerd.

Een vereenvoudigd klassendiagram is terug te vinden in figuur 3.3. Niet alle packagesen klasses zijn opgenomen in dit diagram om het niet onnodig complex te maken, enkelde essentiele klasses voor dit eindwerk zijn opgenomen.

Hoe dit raamwerk verder uitgebreid werd is terug te vinden in sectie 4.2.2.

Overzicht

We zien de interface FuzzySet die een vaagverzameling voorstelt, EvaluationValue dieeen waarheidswaarde voorstelt en hoe (E)PTV’s beide interfaces implementeren. De Unitklasse stelt een (double) waarde voor tussen 0 en 1, en wordt doorheen de package vaakgebruikt om waarden terug te geven.

Andere gebruikte klasses zijn deze van FuzzyTrapezium, die een trapeziumfunctievoorstelt en als constructor waarden a,b,c en d neemt. De klasse kan dan via de methodegetMembershipFunction de corresponderende lidmaatschapsgraad van een gegeven getalteruggeven.

De package operator heeft een bijzonder complexe structuur. De (Non)AssociativeAggregator klasses worden gebruikt om de aggregate(Collection<T> values metho-des te implementeren. Deze klasse wordt dan ook bij implementatie gebruikt van det-(co)normen.

In de package operator zit een subpackage unit waarin de operatoren met betrekkingtot de Unit kunnen teruggevonden worden. De ZadehTNorm implementeert bvb. deConjunction<Unit> interface.

27

Figuur 3.3: Vereenvoudigd klassendiagram van het ddcm-package

28

Hoofdstuk 4

FuzzyQuery applicatie

In dit hoofdstuk wordt de syntax, semantiek, implementatie en andere details i.v.m. deeindapplicatie FuzzyQuery besproken.

Er dient eerst een syntax gedefinieerd worden die de gebruiker toelaat om vaagkwanto-ren te gebruiken in SQL. Voor de definitie van de syntax werd rekening gehouden met dereeds bestaande SQL-syntax (sectie 3.1) en de reeds gedefinieerde FlexQL syntax (sectie3.2.1).

Bij de implementatie werd verdergebouwd op het FuzzyQuery raamwerk (sectie 3.2.2),dat volledig geıntegreerd werd met het package van de onderzoeksgroep omtrent vaagver-zamelingen (sectie 3.3). Ook werd op een modulaire, onafhankelijke manier gewerkt zodatop eenvoudige manier verdere uitbreidingen kunnen geımplementeerd worden. Voor meerinformatie over mogelijke uitbreidingen, zie Hoofdstuk 6.

4.1 FlexQL Syntax

Zoals eerder vermeldt, zal eerst de reeds bestaande FlexQL syntax en grammatica vol-ledig overgenomen worden (zie ook sectie 3.2.1 waar ook het verschil tussen syntax engrammatica opgemerkt wordt.)

De syntax blijft onveranderd, dit is een logische interpretatie van de sleutelwoordenPLUSINF, MININF, COMPARATOR, ID, INTEGER, FLOAT, TEXTSTRING, DATE, LETTER, DIGIT enENDOFLINE.

4.1.1 BNF Grammatica

De grammatica zal verder aangevuld worden met de nodige regels voor het opgeven vankwantoren in de bevraging. Hiervoor werd de component Comparisson lichtjes aangepast(toevoegen van QUANTOR) en een component Quantor achteraan toegevoegd.

Een volledig overzicht van de BNF grammatica is nu :

Select := <SELECT> (<DISTINCT>)? (TresHold)? Columns <FROM> Tables( <WHERE> Conditions )? <EOF>

SubSelect := <SELECT> (<DISTINCT>)? (TresHold)? Columns <FROM> Tables( <WHERE> Conditions )?

29

Voor de syntax i.v.m. toekennen van gewichten, threshold waarden en trapeziumfunc-ties, wordt verwezen naar de reeds bestaande syntax en semantiek gedefinieerd in sectie3.2.1.

4.1.2 ‘Quantor’ uitbreiding

Quantor := <QUANTOR> ( Quantor )* ( <INTEGER> )? ( "(" SubSelect ")" )?

Er wordt gebruikgemaakt van het sleutelwoord <QUANTOR> om de kwantoren aan teduiden, en op eenvoudige manier herkenbaar te maken voor de parser (zie ook verder).De syntax is redelijk breed gelaten, om zoveel mogelijk soorten kwantoren toe te staan.

Het spreekt voor zich dat niet alleen vage kwantoren, maar ook de basiskwantoren(FOR ALL ∀ en EXISTS ∃) gebruikt kunnen worden, hoewel deze laatste voorgesteldworden door resp. ALL en ANY aangezien deze beter aansluiten op de niet-wiskundigecontext waarin ze gebruikt worden.

De term “Quantor”

Volgende begrippen worden in deze context door de syntax ondersteund:

− Modificatiefuncties: een versterkende/verzwakkende kwantor die voor (premodifica-tie) of na (postmodificatie) een andere kwantor geplaatst kan worden. Deze kwantorverandert de lidmaatschapsgraad, zie ook sectie 2.4.1. Een voorbeeld is de kwantorVERY, die geımplementeerd is als een versterkende postmodificatiefunctie (.2).

− Absolute kwantor : een absolute kwantor, bestaat uit een linguıstische term gevolgddoor een aantal, bvb. ABOUT 5, AROUND 20.

− Relatieve kwantor : een relatieve kwantor, zoals ALL, ANY of MOST. Deze zullen meestalsamen met een SubSelect gebruikt worden (zie ook verder).

De term “SubSelect”

De eenvoudigste manier is om algemeen vage begrippen op te geven, zonder daar eensubquery op te laten volgen. Doch is het vaak gewenst om, naar analogie met de SQL-standaard ALL en ANY een kwantor te laten volgen door opnieuw een SELECT-statementwaaruit dan een veld zal geselecteerd worden die dient vergeleken te worden met de opge-geven parameter.

Voorbeeld Een gebruiker wenst alle testen waarvoor de meeste studenten geslaagd zijn(e.g. een score ≥ 10). Volgende FlexQL-syntax wordt bekomen:

SELECT testname FROM testscores tWHERE 10 <= QUANTOR MOST ( SELECT score FROM testscores

WHERE testname = t.testname)

31

kwantor f(x)any f(x) = 0 als x = 0, anders f(x) = 1all f(x) = 1 als x = 1, anders f(x) = 0most ftrap(0.5, 0.8, 1, 1)many ftrap(0.5, 0.7, 1, 1)several ftrap(0.1, 0.4, 1, 1)half of ftrap(0.25, 0.5, 0.5, 0.75)

Tabel 4.1: Functies geassocieerd met de relatieve kwantoren

kwantor f(x)exactly ftrap(0.95 · γ, γ, γ, 1.05 · γ)about ftrap(0.9 · γ, γ, γ, 1.1 · γ)around / approximately ftrap(0.7 · γ, γ, γ, 1.3 · γ)more or less ftrap(0.6 · γ, γ, γ, 1.4 · γ)at most / less than ftrap(−∞, γ, γ, 1.1 · γ)at least / more than ftrap(0.9 · γ, γ, γ,+∞)

Tabel 4.2: Functies geassocieerd met de absolute kwantoren

4.1.3 Semantiek van kwantoren

De semantiek hoort eigenlijk gedeeltelijk bij de implementatie, aangezien het eenvoudigeris de semantiek uit te leggen a.d.h.v. de gebruikte implementatie, zoals tijdens het lezenwel zal gemerkt worden.

Een overzicht van alle gedefinieerde kwantoren, m.b.v. de lidmaatschapsfunctie vande bijhorende vaagverzameling, wordt verder gegeven. Voor de eenvoud zijn de meestekwantoren gedefinieerd m.b.v. trapezoıdale functies. Voor enkele kwantoren was dit echterniet mogelijk, en deze werden als vaagverzamelingen gedefinieerd en geımplementeerd(zie package fuzzy.quantors). Het gaat hier om de existentiele kwantor ANY, de absolutekwantor ALL en het kwantor bijwoord VERY.

Relatieve kwantoren

De geımplementeerde sleutelwoorden zijn MOST, ALL, ANY, HALFOF, MANY en SE-VERAL. Deze functies zijn van de vorm f : [0, 1] → [0, 1] (zie sectie 2.1.4). De lidmaat-schapsfuncties geassocieerd met deze sleutelwoorden zijn terug te vinden in tabel 4.1 enfiguur 4.1. De trapezoıdale functie wordt genoteerd als ftrap en neemt als argument dewaarden a, b, c, d zoals gedefinieerd in formule 2.1.

Absolute kwantoren

Absolute kwantoren zijn volledig afhankelijk van het meegegeven getal γ (sectie 2.1.4). Degeassocieerde lidmaatschapsfuncties f(x) zijn terug te vinden in tabel 4.2. In figuur 4.2kan een grafisch overzicht teruggevonden worden, waar telkens γ = 50.

32

(a) Kwantor ANY (b) Kwantor ALL

(c) Kwantor MOST (d) Kwantor MANY

(e) Kwantor SEVERAL (f) Kwantor HALF OF

Figuur 4.1: Relatieve kwantoren

33

(a) Kwantor EXACTLY 50 (b) Kwantor ABOUT 50

(c) Kwantor AROUND / APPROXIMATELY50

(d) Kwantor MORE OR LESS 50

(e) Kwantor AT MOST / LESS THAN 50 (f) Kwantor AT LEAST 50

Figuur 4.2: Absolute kwantoren

34

Modificatiefuncties

Zoals vermeldt in sectie 4.1.2 zijn ook modificatiefuncties gedefinieerd. Bij wijze vanvoorbeeld is een Er is slechts een modificatiefunctie gedefinieerd, bij wijze van voor-beeld. Het gaat hier om de versterkende postmodificatiefunctie VERY die gedefinieerdis als mpost(µL(x)) = (µL(x))2.

Merk op dat de combinatie met bijwoorden niet steeds linguıstisch “mooi” klinkt.Bvb. bij very less than zou bvb. het bijwoord much veel beter klinken. Het probleemmet deze bijwoorden is, dat ze vaak sterk afhankelijk zijn van de gebruikte kwantoren.Voor deze reden werd enkel het bijwoord very bij wijze van voorbeeld geımplementeerden veronderstellen we dat de gebruiker beseft dat de kwantoren niet “mooi” hoeven teklinken.

Evaluatiefuncties

Zoals gezien in sectie 2.4.1 over preferenties binnen bevragingscondities, zijn de meestcourante evaluatiefuncties de gelijkheidsoperatoren, vergelijkingsoperatoren en compatibi-liteitsoperator.

De gelijkheidsoperator is op eenvoudige manier te begrijpen, deze specificeert name-lijk in welke mate voldaan is aan de conditie. De noemer van formule 2.15 is dan gewoonhet normaliseren van de EPTV.

Om het mogelijk te maken vergelijkheidsoperatoren te gebruiken, diende de func-tionaliteit van de vaagverzamelingen in het ddcm framework uitgebreid te worden. Ditgebeurde met zgn. ComparableFuzzySet waarin in de reeds bestaande methode get mem-bership function nu ook een operator kan meegegeven worden. Hierdoor kan op eenvoudigemanier deze vergelijkheidsoperatoren gedefinieerd worden, en kunnen heel wat if lussenvermeden worden om de verschillende gevallen aan te duiden.

De compatibiliteitsoperator is momenteel niet ondersteunt, maar zou eenvoudigkunnen gedefinieerd worden bij de vergelijkheidsoperatoren.

Voorbeeld Analoog aan de algemene formules gedefinieerd in sectie 2.4.1, worden voorde trapeziumfuncties worden de verschillende operatoren als volgt gedefinieerd:

− Voor groter dan (>)

f(x,>) =

1 als x > bx−ab−a als b ≥ x > a

0 anders

(4.1)

− Voor kleiner dan (<)

f(x,>) =

1 als x < cx−ab−a als c ≤ x < d

0 anders

(4.2)

35

4.2 Implementatie

Meer implementatiedetails zijn in deze sectie terug te vinden met uitzondering van deevaluatie van de kwantoren in de bevraging, wat teruggevonden kan worden in hoofdstuk5.

4.2.1 Algemeen

In Bijlage A kunnen algemene en specifieke klassendiagrammen teruggevonden wordenvan de verschillende packages. Er zal nu kort overlopen worden hoe de applicatie werkten communiceert.

Programmaverloop

De webinterface zal de Servlets in het view package oproepen. Deze zullen:

− de DatabaseAdapter initialiseren via de setDatabase methode.

− de FlexQlProcessor oproepen via constructor en vervolgens getQueryResult metho-de die zal:

◦ Het parser package, meerbepaald de FlexQLParser, aanspreken om de tree tegenereren.

◦ Vervolgens zal gezocht worden naar subqueries in de Quantor -nodes, meer be-paald naar subqueries met bad id’s. De slechte id’s zijn de kolom id’s die ver-wijzen naar de hoofdquery, deze id’s worden in de quantor-node bijgehoudenen zijn belangrijk bij de evaluatie van de subqueries.

◦ De CrispProcessor construct en opnieuw getQueryResult. Deze methode zal:

∗ Een geldige SQL-String genereren na de tree volledig te doorlopen en dezete genereren.∗ De databank bevragen (via de DatabaseAdapter) met deze SQL-String.∗ De resultaten teruggeven als een QueryResult-object.

◦ Vervolgens wordt de FuzzyProcessor aangesproken, met de bekomen resulta-ten en zal via de getFuzzyResult methode de vage componenten toegevoegdworden aan het resultaat.

∗ Via de klasse Classify wordt met alle resultaten een EPTV geassocieerddie weerspiegelt in welke mate de record aan de query voldoet. 1

∗ De threshold wordt toegepast (o.a. FALSE records worden verwijderd).∗ De resultaten teruggeven als een QueryResult-object, waarbij de fuzzy data

nu wel zal ingevuld zijn.

◦ Ten slotte worden de resultaten teruggegeven aan de webinterface.

− de resultaten worden gesorteerd op hun fuzzy value, die wordt berekend uit de EPTV.1Meer details over de evaluatie kunnen teruggevonden worden in hoofdstuk 5.

36

4.2.2 Uitbreiding van het ddcm-framework

Het ddcm-framework is de code die reeds aanwezig was in de onderzoeksgroep, en heeft be-trekking op vaagverzamelingen, waarheidswaarden en bewerkingen op vaagverzamelingen.Zie ook sectie 3.3. De klassendiagrammen van de bijhorende packages kunnen terugge-vonden worden in figuur A.4 (package operator), figuur A.3 (package fuzzy) en figuur A.2(package eval).

Aggregatie

Met aggregatie worden de EN/OF/NIET operatoren of conjunctie/disjunctie/negatie ope-ratoren bedoeld. Hiervoor werd de probabilistische t-(co)norm geımplementeerd, en ver-volgens ook de conjunctie/disjunctie operatoren voor EPTV’s (terug te vinden in packageddcm.operator.eptv). Ten slotte werd ook nog een implementatie van de negatie voor-zien.

Gewichten

Voor het werken met gewichten, dienden verschillende nieuwe begrippen geıntroduceerd teworden in het ddcm framework (zie sectie 2.4.2). Deze veranderingen zijn terug te vindenin het package operator.

1. Uitbreiding met implicatoren, met name de implicator van Godel, Kleene-Dienesen Reichenbach. Het spreekt voor zich dat andere implicatoren eenvoudig kunnengedefineerd en geıntegreerd worden.

2. Als twee diende een uitgebreide operator voor conjunctie/disjunctie beschouwd teworden, die terug te vinden zijn in de interfaces “WeightedOperator, Abstract-WeightedConjunction en AbstractWeightedDisjunction”. Deze werden dan verdervoor EPTV’s geımplementeerd in het bijhorende package operator.eptv.

Normalisatie

Enkele operatoren leiden tot niet-genormaliseerde resultaten, nl. de uitgebreide conjunctieen disjunctie gedefinieerd in sectie 2.4.2 en de trapeziumfuncties zoals gedefinieerd informule 3.1.

De genormaliseerde EPTV wordt bekomen via een schaling zodat de onderliggenderelatie tussen de lidmaatschapsgraden onveranderd blijft.

{(T, µTmax

), (F,µF

max), (⊥, µ⊥

max)} (4.3)

waar max = max(µT , µF , µ⊥) en de µ-waarden de lidmaatschapsgraden van de corres-ponderende EPTV voorstellen.

4.2.3 ComparableFuzzySet<T>

De reeds bestaande implementatie van een vaagverzameling of fuzzy set werd uitgebreidmet de interface voor een comparable fuzzy set die toelaat om bij het opvragen van delidmaatschapsgraad een operator op te geven, zodat niet enkel de = operator beschouwdwordt, maar ook andere evaluatiefuncties (<,>, . . .) zoals gedefinieerd in sectie 2.4.1.

37

4.2.4 Uitbreiding van FlexQL framework

De eerste stap om de bestaande applicatie (zoals besproken in sectie 3.2.2) verder uit tebreiden, was het doorvoeren van de nieuwe syntax en grammatica definitie via JavaCC.Hiervoor dienden de JavaCC bestanden (.jj en .jjt) verder aangevuld worden met de nieuwesyntax. Daarna genereert het programma de parser en bijhorende klassen, zoals terug tevinden in de package parser (zie ook figuur A.7). Na de generatie van de bestanden,dienen de meeste klassen opnieuw aangepast te worden. Elke component wordt immersgedefinieerd als een klasse, en er is meestal nood aan extra functionaliteit voor eenvoudigmet deze klassen te kunnen werken.

Doordat deze aanpassingen telkens opnieuw doorgevoerd moeten worden, is het nietaan te raden om frequent de parsersyntax aan te passen. Het is weliswaar wel mogelijkom de extra code die in de klassen wordt aangevuld, reeds in de JavaCC syntaxbestandente stoppen. Maar dit zou leiden tot een heel groot en onleesbaar bestand, en daarom werddaar niet voor geopteerd.

Vervolgens werd de reeds verouderde code opgefrist met Java Generics, enkele data-types (QueryResult, WEPTV, etc.) werden gedefinieerd en een DatabaseAdapter werdaangemaakt voor eenvoudig databankgebruik. Verder werden enkele methodes die enkeltrapeziumfuncties toelieten (zoals add trapezium in de Classify klasse verruimt tot het toe-laten van vaagverzamelingen in het algemeen (voorgesteld door klasse FuzzySet in ddcmpackage).

Ook hier werd de normalisatie doorgevoerd zoals gedefinieerd in formule 4.3 in sectie4.2.2. Verder was in het FlexQL framework reeds een tweede manier van normalisatiemogelijk, die door de auteurs zelf gedefinieerd was, die ook verder behouden is.

Integratie met ddcm-framework

De code omtrent bewerkingen op vaagverzamelingen was verspreid over enkele klasses enzonder overerving etc. geımplementeerd. Daarom werd besloten om het te integreren methet bestaande framework, zodat toekomstige veranderingen of uitbreidingen op eenvoudigemanier zouden kunnen doorgevoerd worden.

Merk op dat deze integratie niet voor extra functionaliteit heeft gezorgd in het fra-mework, maar wel het implementeren van verdere uitbreidingen aanzienlijk eenvoudigermaakt. Zie ook hoofdstuk 6 voor meer informatie omtrent mogelijke uitbreidingen.

Uitbreiding van de functionaliteit

Zoals eerder vermeldt, werd rekening gehouden met uitbreidbaarheid naar de toekomsttoe (zie ook hoofdstuk 6).

Algemeen werden volgende functies/klasses toegevoegd:

− De singleton-klasse Quantor die alle bestaande linguıstische kwantors definieert alstrapeziumfuncties, en bovendien nog enkele handige hulpfuncties bezit.

− De CrispProcessor klasse werd verder uitgebreid om de kwantoren op te nemen inde SQL-databankbevraging en maakt gebruik van de Quantor klasse. Analoog aande trapeziumfuncties gebeurt door alle waarden tussen a en d op te vragen.

38

− De QuantorEvaluator verzorgt de evaluatie van kwantoren en wordt opgeroepenin de Classify klasse, die opgeroepen wordt door de FuzzyProcessor voor de vageevaluatie van het resultaat. Zie hoofdstuk 5.

− De mogelijkheid om queries met/zonder gewichtenpropagatie uit te voeren. Hier-bij dient opgemerkt te worden dat gewichtenpropagatie niet associatief is en dat hetin de meeste gevallen niet zinnig is om queries zonder gewichtenpropagatie uit tevoeren.

Verdere optimalisatie

Bij een normale query, kan het vaak voorkomen dat eenzelfde fuzzy value herberekendwordt omdat de gebruikte waarden in bepaalde rijen gelijk is. In het geval van subqueriesneemt dit behoorlijk wat tijd in beslag. Merk op dat de distinct operator pas na de vageevaluatie wordt toegepast en dus geen tijdswinst oplevert.

Daarom werd een cache geımplementeerd, die bijhoudt welke rijen reeds geevalueerdzijn en naar welke waarde de rij evalueerde. Hierdoor werd de tijd gereduceerd naar 10%van de niet-geoptimaliseerde tijd. De gebruikte queries zijn deze opgenomen in sectie 4.2.5‘Voorbeelden’.

4.2.5 Voorbeelden

Hieronder worden enkele voorbeeld queries samen met hun resultaat uitvoerig besproken.

Voorbeeld 1

Dit is een voorbeeld die het gebruik van distinct toelicht. Volgende query werd uitgevoerd:

SELECT distinct firstname, lastname, p.person, scoreFROM testscores as t, persons pWHERE p.person = t.person AND firstname=‘fred’

AND 6.9 <= quantor most ( SELECT score FROM testscoresWHERE person = p.person)

Resultaat Het resultaat, en de gebruikte instellingen (implicator, aggregator), is te zienin figuur 4.3. Merk op dat doordat de ‘score’ kolom werd opgevraagd, verschillende rijenvan dezelfde persoon voorkomen. Wat meteen opvalt is dat rij 1 en 2 verschillend zijn,alsook rij 3 en 4. Aangezien de vage evaluatie enkel betrekking heeft op de persoon zouverwacht worden dat in deze rijen de vage waarde gelijk is. Maar de distinct zorgt ervoordat verschillende rijen worden samengenomen, en bij het samennemen zal telkens eendisjunctie worden uitgevoerd op de verschillende vage waarden. We zien dat 0.64 = 0.8∗0.8wat precies de algebraısche of probabilistische t-norm is.

Ter vergelijking kan in figuur 4.4 het resultaat gezien worden bij het gebruik van deaggregator extensieprincipe van Zadeh. Daar zullen de waarden wel gelijk zijn omdat eenminimum wordt genomen.

39

Figuur 4.3: Voorbeeld 1 - resultaat

Figuur 4.4: Voorbeeld 1 - resultaat met andere aggregator

40

Voorbeeld 2

Dit is een eenvoudig voorbeeld die alle testen opvraagt waarvoor de meeste scores ≥ 5zijn. Volgende query werd uitgevoerd:

SELECT distinct testFROM testscores as tWHERE 5 <= quantor most (SELECT score FROM testscores

WHERE test = t.test )

Resultaat Het resultaat, en de gebruikte instellingen (implicator, aggregator), is te zienin figuur 4.5.

Voorbeeld 3

Dit voorbeeld, die een uitbreiding is van het voorbeeld uit de originele FlexQL, vraagtalle personen en scores op van de test ‘IQ’, waarbij de personen voor de meeste testeneen score hoger dan 6.9 behaalden. Hierbij wordt ook nog een gewicht aan de conditie‘geslacht = man’ gehangen van 0.7. Volgende query werd uitgevoerd:

SELECT firstname, lastname, score, p.personFROM persons p, testscores tWHERE p.person = t.person

AND sex LIKE ’M’ IMP 0.7AND test=’IQ’AND 6.9 <= quantor most (SELECT score FROM testscores test

WHERE test.person = p.person)

Resultaat Het resultaat, en de gebruikte instellingen (implicator, aggregator), is te zienin figuur 4.6. Merk op dat voor de evaluatie van de kwantor subquery wordt gekeken naaralle scores, niet enkel deze van de ‘IQ’-test.

Opmerking Er valt op dat in de hoofdquery de kolom ‘p.person’ werd opgegeven, terwijldeze de interne id van een persoon voorstelt en dus geen nut voor de gebruiker heeft. Dereden hiervoor is dat er niet verwezen kan worden vanuit de subquery naar kolommen inde hoofdquery die niet bestaan.

Een verdere uitbreiding zou er kunnen voor zorgen dat dit niet langer nodig is, en datdeze kolommen ook automatisch worden meegenomen in de hoofdquery en dan achterafopnieuw verwijderd.

41



42

Hoofdstuk 5

Evaluatie

In dit hoofdstuk wordt de evaluatie van de vage componenten in de query besproken. Ditomvat het evalueren van de afzonderlijke records tot een EPTV die dan bepaald in welkemate elke resultaat voldoet aan het concept dat uitgedrukt wordt door de vage component.

Vooral de evaluatie van bevragingen met subqueries in de quantor clause vraagt watextra uitleg.

5.1 Algemeen

De algemene evaluatie van condities, m.a.w. het associeren van een EPTV met elke record,gebeurt bij trapeziumfuncties, gewichten en kwantoren.

De formule voor evaluatie van trapezoıdale functies kan teruggevonden worden informule 3.1 in sectie 4.2.4.

De evaluatie van gewichten gebeurt zoals theoretisch besproken in sectie 2.4.2, enwas reeds aanwezig in het programma. Hier werd enkel de mogelijkheid van gewichten-propagatie toegevoegd.

De evaluatie van kwantoren gebeurt via de QuantorEvaluator, die opgeroepen wordtin de process quantor methode in de Classify klasse. Deze klasse staat in voor het bereke-nen van de vage waarden van de records en is eigenlijk een uitbreiding van de FuzzyPro-cessor die instaat voor het classificeren van de afzonderlijke records.

5.2 Evaluatie van kwantoren zonder subqueries

Volgende stappen worden in het programma doorlopen in het geval zonder subquery :

− Ophalen van de vaagverzameling corresponderend met de kwantor via de Quantor -get double fuzzy set methode.

− Evalueer deze vaagverzameling via de standaardmethode add double fuzzy set in deClassify klasse.

43

5.3 Evaluatie van kwantoren met subqueries

Voor de eenvoud zal gewerkt worden met volgend voorbeeld die alle testen opvraagt waar-voor de meeste scores groter dan 10 zijn.

SELECT testname FROM testscores tWHERE 10 <= QUANTOR MOST ( SELECT score FROM testscores

WHERE testname = t.testname)

De voorbeeld query zal zoveel mogelijk in rekening gebracht worden met onderstaandprogrammaverloop, door tussen vierkante haakjes [] de relevante waarden te plaatsen.Volgende stappen worden in het programma doorlopen in het geval met subquery :

− Ophalen van de select-column [score], dit is de naam van de kolom die in desubquery werden opgegeven in select clause. Dit gebeurt via een hulpmethode dieitereert over de select-node van de subquery.

− De bad id’s zoeken, d.i. alle kolomid’s in de subquery die refereren naar de hoofd-query [t.testname]. De locatie van de slechte id’s wordt opgeslagen via het padvan kinderen die doorlopen worden in de tree vanaf de select clause [2-1-0] (zie ookverder).

− Initialiseren van de cache en de array met vage waarden.

− Er wordt geıtereerd over alle rijen uit het resultaat van de hoofdquery, waarbijtelkens de bekomen EPTV in een array lijst wordt bijgehouden, afhankelijk van hetrijnummer.

◦ Zoeken of de huidige rij kan teruggevonden worden in de cache. Zo ja, wordtde EPTV uit de cache gebruikt en naar de volgende rij gegaan.

◦ Het vervangen van de slechte ID’s door de variabele van deze rij (zie ook verder).

◦ Het resultaat van de subquery opvragen door de select node door te geven aande FlexQLProcessor, die deze subquery zal uitvoeren. (recursief)

◦ Evaluatie van de rij t.o.v. de bekomen subquery (via de evaluate row methode- zie ook verder).

◦ Normalisatie van de EPTV (indien van toepassing).

◦ Toevoegen van de EPTV aan de array lijst.

◦ Toevoegen van de huidige rij en EPTV aan de cache.

− Ten slotte wordt via de add fuzzy vals methode de waarden toegevoegd aan de data,dit is een interne methode van de klasse Classify.

In de volgende secties worden de methodes uit de klasse QuantorEvaluator, die instaanvoor bovenstaande stappen, in meer detail besproken.

44

5.3.1 Evaluatie van een rij

Elke rij wordt geevalueerd m.b.v. de evaluate row methode in de QuantorEvaluator. Hoede rij geevalueerd wordt, is afhankelijk van de component voor de operator. De syntaxlaat volgende mogelijkheden toe:

− Number (getal), zoals bvb. 5.2 >= ALL ( subquery ) waarin “5.2” het getal is.

− Date of String (analoog)

− ID (column naam), zoals bvb. myscore >= MOST ( subquery ) waarbij mysco-re een id is voor een kolomnaam, die opgevraagd werd in de select clause van dehoofdquery. [niet geımplementeerd]

Hieruit kunnen we besluiten dat enkel een scherpe evaluatie zal optreden, er kan immersgeen vaag getal voor de operator staan, waardoor telkens de conditie op een scherpemanier zal geevalueerd kunnen worden. Onderstaand doorlopen we het geval van deNumberComponent, de String en Date component zijn analoog geımplementeerd:

− De betreffende component wordt uit de corresponderende node gehaald. [10]

− Initialisatie van twee variabeles: amount = 0 en total = size().

− Er wordt geıtereerd over de rijen in de subquery, elke rij wordt (scherp) geevalueerdvia evaluate condition methode (zie verder). De methode zal true of false terug-geven, afhankelijk van de voldaanheid van de rij aan de conditie. Indien voldaan is,wordt amount met 1 verhoogt.

− Uiteindelijk wordt de lidmaatschapsgraad µ(amounttotal ) berekend van de vaagverzame-ling die de kwantor definieert, en deze waarde wordt teruggegeven.

5.3.2 Evaluatie van een conditie

Zoals eerder vermeldt, zal de huidige syntax enkel scherpe evaluatie van een conditietoelaten. M.a.w. de conditie zal altijd ofwel volledig voldaan ofwel niet voldaan zijn. Eenmogelijke uitbreiding is dat er ook nog in een bepaalde mate kan voldaan zijn aan eenconditie, maar dan is vereist dat voor de operator ook een vaag getal kan voorkomen. Zieook hoofdstuk 6 een overzicht van mogelijke uitbreidingen.

− Per soort component (number, string, date) is een afzonderlijke methode voorzien.Dit is nodig omdat de onderlinge evaluatie enorm verschilt.

− Voor de Number component zal eenvoudigweg component < op > x worden uitge-voerd, hierbij is x de huidige waarde die geevalueerd moet worden en component devaste waarde. [10 ≤ x]

− Voor de Date component wordt de Comparable interface gebruikt, en dus de me-thode compare to.

− Voor de String component is enkel de = en de 6= operator gedefinieerd, en wordende strings vergeleken via de equals ignore case methode.

45

5.3.3 Bad ID’s

Er werd eerder al gesproken van bad id’s, met betrekking tot subqueries. De betekenis vandeze slechte id’s is dat ze niet onafhankelijk zijn van het hoofdquery, meer bepaald hebbenze betrekking op een bepaalde kolom en/of tabel uit de hoofdquery. Hierdoor kunnen zeniet zomaar onafhankelijk uitgevoerd worden, maar dienen ze ingevuld te worden met dehuidige rij-waarde (rij-per-rij evaluatie) of geıntegreerd te worden met de hoofdquery. Wenoemen deze subqueries verder geıntegreerde subqueries genoemd.

Methodes in FlexQlProcessor

Enkele methodes zijn voorzien in FlexQlProcessor, deze zouden eigenlijk evengoed in deQuantorEvaluator geplaatst kunnen worden. De reden dat dit niet gedaan wordt, is omdatze de quantor-nodes zullen instellen met de locatie van de bad id’s, wat op zich geen‘evaluatie’ kan genoemd worden. Verder zou naar optimalisatie toe de subqueries laterkunnen geıntegreerd worden met de hoofdquery, wat tijdswinst zou opleveren (zie ookhoofdstuk 6).

De volgende methodes zullen de slechte id’s identificeren en opslaan in de correspon-derende quantor-node.

− searchForQuantorIntegratedSubqueries(SimpleNode temp)

Deze zal recursief de kinderen van de temp-node overlopen, op zoek naar quantor-node’s. Indien zo’n node gevonden wordt, zal de volgende methode (search for badsubqueries) opgeroepen worden.

− searchForBadSubqueries(ASTQuantor parent, ASTSelectClause tree)

In deze methode zullen eerst de tables-node uit de tree geextraheerd worden, vervol-gens zal hieruit een map met de namen en aliassen van de tabellen gecreerd worden.Daarna zal de volgende methode (search bad id’s) opgeroepen worden met deze data.

− searchBadIDs(ASTQuantor parent, SimpleNode node, Map<String, String>tables, List<Integer> path)

Hier zal opnieuw de node recursief doorlopen worden, de quantor-node dient telkensmeegegeven te worden om de bad id’s te kunnen instellen. De map die de tabellenbevat wordt gebruikt om te bepalen of de id’s geldig zijn en de lijst path houdt hethuidige pad van doorlopen kinderen bij.

Telkens een id-node wordt tegengekomen, zal gecontroleerd worden of dit een geldigeid is a.d.h.v. de meegegeven tabellen. Er wordt m.a.w. gecontroleerd of de kolom-naam teruggevonden kan worden in de tabellen. Indien geen geldige tabel gevondenkan worden, zal het huidige pad worden toegevoegd aan de kwantor-node als eenslechte id.

Het gebruik van drie methodes kan misschien wat overkill lijken, maar dit was nood-zakelijk om de recursie correct en eenvoudig te laten verlopen.

46

Methodes in QuantorEvaluator

− List<int> getColNrBadids(ASTSelectClause select, List<List<int>>badids)

Deze methode zal de bijhorende kolom nummers zoeken van de bad id’s in hetresultaat van de hoodquery. Deze kolom nr’s worden opgeslagen in een array list,waarbij elk element zal verwijzen naar een bad id, m.b.v. de index.

− replaceBadIDs(ASTSelectClause select, int row, List<List<int>>badids, List<int> colnr badids)

Dit is de belangrijkste bad id-methode, deze zal de slechte id’s vervangen door debijhorende waarde uit de huidige rij van het resultaat van de hoofdquery. Indienwe in bovenstaand voorbeeld een rij [(IQ)] (dit is de testname) evalueren, zal de[t.testname] in de subquery vervangen worden door een simpele string-componentmet daarin [‘IQ’]. Deze methode wordt voor elke bad id toegepast en voor elke rijzullen telkens de bad id’s opnieuw ingevuld worden.

5.3.4 Hulpmethodes in QuantorEvaluator

Verder zijn nog enkele (kleine) hulpmethodes voorzien in de klasse QuantorEvaluator, dezeworden hier verder toegelicht.

− getNormalisedWeptv(double value, double weight)

Vraagt via de OperatorAdapter de genormaliseerde weptv op. Gegeven is de lidmaat-schapsgraad value van de vaagverzameling, dit is de true-waarde. De false-waardewordt op 1− value en de ⊥-waarde wordt op 0 gezet.

− getSelectColumn(ASTSelectClause select)

In de kinderen van de select-node zal gezocht worden naar de kolommen. Indien meerdan een kolom gevonden wordt, wordt een exceptie gegenereerd. Men kan immersgeen conditie evalueren op meerdere kolommen.

47

Hoofdstuk 6

Uitbreidingen

In de tekst is al vaak aangehaald dat de implementatie gekozen is zodat deze gemak-kelijk uitbreidbaar is. In dit hoofdstuk wordt een kort overzicht gegeven van mogelijkeuitbreidingen, en hoe ze gerealiseerd kunnen worden.

6.1 Syntax

Voor syntax veranderingen dient de JavaCC-main bestand aangepast te worden (.jjt), de.jj-file wordt dan gegenereerd via de jjtree applicatie. Om het syntaxbestand op te stellen,en de parser klassen te genereren, wordt verwezen naar het JavaCC project. Op de websitekan heel wat nuttige informatie teruggevonden worden, zoals voorbeelden en tutorials. Hetis ook zeker aan te raden om de reeds gedefinieerde syntax te bestuderen (zie ook bijlageB).

Na de generatie van de parser-bestanden zullen ook alle AST*-klassen gegenereerdzijn. Deze bevatten slechts basisfunctionaliteit, en dienen verder uitgebreid te wordenom op te kunnen interageren met de rest van de applicatie. Sommige klassen zullenonveranderd blijven door de nieuwe syntax, maar andere zullen gewijzigd zijn. Om deaanpassingen door te voeren naar de vers gegenereerde bestanden kan gebruik gemaaktworden van een programma die veranderingen tussen bestanden bestudeerd, bvb. eensubversionprogramma zoals TortoiseSVN.

Een andere mogelijkheid is om alle uitgebreide functionaliteit op te nemen in hetsyntaxbestand. Dit zou echter betekenen dat het bestand enorm lang, omslachtig enonoverzichtelijk wordt. Daarom is het misschien beter om een ruime syntax te kiezen, deparser bestanden te genereren, de aanpassingen door te voeren en dan langzaamaan defunctionaliteit uitbreiden.

6.2 Implementatie

6.2.1 Toevoegen van kwantoren

Hiermee wordt het toevoegen van vaagverzamelingen algemeen bedoeld. Een kwantorwordt gedefinieerd als een vaagverzameling, maar aangezien een trapeziumfunctie een uit-breiding is van de vaagverzameling, kan deze dus ook gebruikt worden voor het definierenvan de kwantor.

48

Een modificatiefunctie zal als vaagverzameling gedefinieerd moeten worden, aangeziendeze iets complexer zijn. Bij de implementatie kan dan bvb. de kwantorfunctie internworden opgeslagen waardoor de functie eenvoudig geevalueerd kan worden.

Nodige aanpassingen: in de klasse Quantor dient de linguıstische term aan de supportarray toegevoegd worden. Vervolgens dient de absolute kwantor, relatieve kwantor of mo-dificatiefunctie gedefinieerd te worden in de corresponderende methode (bvb. get absolutequantor). Indien gewenst kan de kwantor ook in een aparte klasse gedefinieerd worden,waarvan hier dan een instantie teruggegeven wordt.

In het package operator.quantors kunnen de reeds gedefinieerde quantor klassenteruggevonden worden, de kwantors gedefinieerd als trapeziumfuncties zijn in de klasseQuantor terug te vinden.

6.2.2 Toevoegen van operatoren

Indien men wenst nieuwe operatoren of implicatoren toe te voegen aan het project, dienenvolgende maatregelen in acht genomen te worden:

1. De operator/implicator dient gedefinieerd te worden in een klasse, die de bijhorendeinterface implementeert.

2. Vervolgens moet in de operator.enums package de enums uitgebreid worden met dezenieuwe operator/implicator.

3. Verder zal in de klasse OperatorAdapter bij de set * type methode de nieuweklasse(n) toegevoegd moeten worden.

4. Ten slotte dient in de view package, in de webpagina’s zelf, de operator/implicatorals optie toegevoegd worden.

6.2.3 Aanpassen van de View

De view heeft ook nog enkele kleine tekortkomingen. Als eerste zou de mogelijkheid tot hetopgeven van een databank locatie kunnen toegevoegd worden. In de DatabaseAdapterklasse is deze methode reeds aanwezig, dus dit zou enkel bij initialisatie in de Servlet-klassen aangepast moeten worden.

Er zou een nieuwe optie, nl. keuze van een gewichtaggregator, kunnen toegevoegdworden. Momenteel wordt voor de gewichtenaggregatie de bijhorende t-conorm van deimplicator gebruikt.

6.3 Evaluatie

Zoals eerder vermeld is tijdens de evaluatie van een kwantor met subquery, een id com-ponent voor de operator nog niet geımplementeerd. Dit is een conditie van de vorm id< quantor ( subquery ) waar id een kolomid voorstelt. Om dit te implementeren, dientenkel de methode evaluate row in QuantorEvaluator aangepast worden, meer bepaalddient volgende conditie ingevuld te worden:

if (ASTIDComp.class.isInstance(partcomp)){...

}

49

6.3.1 Vage evaluatie van conditie

Indien men wenst condities net enkel scherp, maar ook vaag te evalueren, zal de syntaxaangepast moeten worden. Momenteel laat de syntax het immers niet toe om voor eenoperator ook vaagverzamelingen (zoals een trapeziumfunctie of kwantor) op te geven. Eenvoorbeeld:

WHERE trapezium(8,9,10,10) > MOST ( subquery )

Om dit te bereiken zullen volgende veranderingen doorgevoerd moeten worden:

1. De syntax aangepast worden (jjt-bestand), meerbepaald in het Comparisson-deeldient toegelaten te worden dat voor de Comparator niet alleen een PartComp, maarook een FuzzyTrapezium, of Quantor kan geplaatst worden.

2. Generatie van de parserklassen via JavaCC (en JTree), en opnieuw de klassen metde nodige functionaliteit uitbreiden (copy-paste).

3. In de QuantorEvaluator zal bij de evaluate row methode een nieuwe if -lus komenmet ASTQuantor en/of ASTFuzzyTrapezium.

4. Een nieuwe methode evaluate fuzzy condition zal aangemaakt moeten wordenvoor de verschillende componenten (quantor/trapezium).

5. Voor de vage evaluatie zelf wordt verwezen naar [HTVM04], een paper die handeltover vage evaluatie van kwantoren.

6.4 Optimalisaties

Zoals eerder aangehaald, zal vooral het uitvoeren van de subqueries (rij-per-rij) veel tijdin beslag nemen. Een mogelijke optimalisatie is om de subquery te integreren met dehoofdquery, en dan nadien de subquery kolommen terug te verwijderen. Op deze manierzou slechts een databankbevraging vereist zijn.

Deze aanpassingen dienen te gebeuren in de FlexQlProcessor, waar na het zoeken naarbad id’s zou kunnen opgevraagd worden aan de quantor-node of de node een subquerybezit. Indien ja, kunnen de kolommen en tabellen uit de subquery opgehaald wordenin de CrispProcessor door i.p.v. enkel de rootnode door te geven bij constructor, ookde subquery rootnodes door te geven (dus een lijst van select-nodes). Er dient dan welnog extra aandacht besteed te worden aan dubbele definitie van tabellen, kolommen,verschillende aliassen, distinct, etc.

Vervolgens dienen na de evaluatie in de FuzzyProcessor de extra kolommen, gedefini-eerd in de subquery, terug verwijderd te worden.

50

Hoofdstuk 7

Besluit

In dit werk werd een applicatie ontwikkeld die de gebruiker toelaat kwantoren op te gevenin de vraagstelling.

De voorgestelde syntax is een logische uitbreiding van de algemene SQL-syntax, de syn-tax werd ruim gekozen zodat uitbreidingen mogelijk zijn. Uiteraard kan de syntax op velewijzen nog verder uitgebreid worden, en daarom werd een korte handleiding opgenomenvoor verdere syntaxuitbreiding.

Voor de implementatie werd verder gebouwd op een reeds bestaand framework (Fuz-zyQuery) en reeds bestaande taal (FlexQL) waarin gewichten, trapeziumfuncties en hetopgeven van threshold waarden reeds was opgenomen. Dit framework werd eenvoudiguitbreidbaar gemaakt door deze te integreren met een reeds bestaand framework die con-cepten uit de vaagverzamelingenleer implementeert. Op deze manier kunnen andere opera-toren of implicatoren eenvoudig worden toegevoegd. Alsook verbetert het de leesbaarheiden begrijpbaarheid van de code.

De uitbreiding van kwantoren, en vooral de subqueries in de kwantoren, bieden degebruiker een nieuwe manier om preferenties op te geven. Een gebruiker is niet langerbeperkt tot het opgeven van scherpe condities of langdradige queries om zijn preferentie teformuleren. De trapeziumfuncties gaven de gebruiker al enige vrijheid, maar de kwantorenzullen de gebruiker nog meer vrijheid geven, vooral m.b.v. de subqueries. Bovendien zullende beste resultaten steeds bovenaan weergeven worden, waardoor een gebruiker de meestgewenste resultaten eerst zal zien.

Ten slotte kunnen kwantoren op eenvoudige manier zelf gedefinieerd worden of gewij-zigd worden.

Het resultaat is een gebruikersvriendelijke applicatie, voor gebruikers met een basis-kennis van SQL. De applicatie kan eenvoudig verder uitgebreid worden met concepten uitde vaagverzamelingenleer zoals nieuwe kwantoren, operatoren, implicatoren, etc.

51

Bijlage A

Diagrammen

In deze bijlage worden alle package en klasdiagrammen weergeven. In figuur A.1 is eenoverzicht terug te vinden van de packages en een veralgemeende werking van de packages.Het programma start bij de view, hierin zitten de servlets voor de webinterface, die dan deprocessor zal oproepen met de gevraagde FlexQL string. De processor zal intern de parseroproepen om de String om te zetten in een tree die dan door de CrispProcessor gehaaldwordt voor de (relationele) databankbevraging (die via de DatabankAdapter verloopt) envervolgens door de FuzzyProcessor voor het toevoegen van de classificering van de recordsmet behulp van EPTV’s. Ten slotte wordt het resultaat teruggegeven aan de view.

Intern worden de fuzzy packages gebruikt voor de voorstelling en bewerking van vaag-verzamelingen en waarheidswaarden, dit is operator, fuzzy en eval. Verder is een opera-tor.enums package aanwezig die de Implicators en Aggregators (d.i. de t-norm, t-conormkoppels) representeert, alsook een ComparissonOperator die de toegestane operators defi-nieert (<,>,≤,≥,=, 6=).

Figuur A.1: Overzicht packages in ddcm

52

Figuur A.2: Package ddcm.eval

Figuur A.3: Package ddcm.fuzzy

53

Figuur A.4: Package ddcm.operator

54

Figuur A.5: Package ddcm.database

55

Figuur A.6: Package ddcm.processor

56

Figuur A.7: Package ddcm.processor.parser

57

Bijlage B

JavaCC syntaxbestand

/*** An FLEX-QL grammar definition, optimized for easy AST creation* Koen Tourne, Lynne Vandousselaere*/

options {MULTI=true;IGNORE_CASE=true;

}

PARSER_BEGIN(FlexQlParser)

package ddcm.processor.parser;

import java.io.*;class FlexQlParser {public static void main(String args[]) {

try {ASTSelectClause s = FlexQlParser.parseString

("select [t=(1;2;3.0)] a.b as c from b where c=d;");s.dump("");System.out.println("Thank you.");

} catch (Exception e) {System.out.println("Oops.");System.out.println(e.getMessage());e.printStackTrace();

}}

private static boolean called = false;

public static ASTSelectClause parseString(String s)throws ParseException {if(!called) {

58

called =true;Reader r = new BufferedReader(new StringReader(s));FlexQlParser t = new FlexQlParser(r);return t.SelectClause();

} else {Reader r = new BufferedReader(new StringReader(s));ReInit(r);return SelectClause();}

}

PARSER_END(FlexQlParser)

SKIP : { " " | "\t" | "\n" | "\r" }

TOKEN : /* SQL reserved tokens*/{

< SELECT: "select" | "SELECT">| < FROM: "from" | "FROM" >| < WHERE: "where" | "WHERE" >| < AND: "and" | "AND" >| < OR: "or" | "OR" >| < NOT: "not" | "NOT" >| < AS: "as" | "AS" >| < LIKE: "like" | "LIKE" >| < DISTINCT:"distinct"| "DISTINCT">| < END: ";" >

}

TOKEN : /* FLEX-QL reserved tokens*/{

< TRAPEZIUM: "trapezium" | "TRAPEZIUM">| < QUANTOR : "quantor" | "QUANTOR" >| < IMP : "imp" | "IMP" >| < PLUSINF : "+inf" | "+INF" >| < MININF : "-inf" | "-INF" >| < DATE : <INTEGER>"/"<INTEGER>"/"

<INTEGER>|<INTEGER>"-"<INTEGER>"-"<INTEGER> >| < COMPARATOR: "=" | "<>" | "<=" | ">=" | "<" | ">" >

}

TOKEN : /* IDENTIFIERS */{< ID: <LETTER> (<LETTER>|<DIGIT>)* > |< #LETTER: ["_","a"-"z","A"-"Z"] > |

59

< #DIGIT: ["0"-"9"] >}

TOKEN : /* Numericals */{< INTEGER: (<DIGIT>)+ > |< FLOAT: (<DIGIT>)+ "." (<DIGIT>)* >

}

TOKEN : /* Some String data */{< TEXTSTRING: ("\"" (~["\""]|"\\\"")* "\"") |

("\’" (~["\’"]|"\\\’")* "\’") >}

ASTSelectClause SelectClause() : {Token t1=null;}{<SELECT> (t1=<DISTINCT>)? (TresHold())? Columns() <FROM> Tables()(<WHERE> Conditions())? (<END>|<EOF>){ if(t1 != null)

{jjtThis.setDistinct(true);t1 = null;

}return jjtThis;

}}

ASTSelectClause SubSelectClause() #void: {Token t1=null;}{(<SELECT> (t1=<DISTINCT>)? (TresHold())? Columns() <FROM> Tables()(<WHERE> Conditions())?{ if(t1 != null)

{jjtThis.setDistinct(true);t1 = null;

}return jjtThis;

})#SelectClause(true)}

void Columns() : { Token table=null,name=null,alias=null;}{

(LOOKAHEAD(4) table = <ID> ".")? name = <ID> [(<AS>)? alias = <ID>]{

60

jjtThis.addColumn((table==null)?null:table.image,name.image,(alias==null)?null:alias.image);table=null;alias=null;

}( "," (LOOKAHEAD(4) table = <ID> ".")? name = <ID> [(<AS>)? alias = <ID>]

{jjtThis.addColumn((table==null)?null:table.image,name.image,(alias==null)?null:alias.image);table=null;alias=null;

})*

| "*" { jjtThis.addAll();}

}

void Tables() : { Token name=null,alias=null;}{( "(" SubSelectClause() ")" [(<AS>)? alias = <ID>]

{jjtThis.addSubqueryAlias((alias==null)?null:alias.image);alias=null;

}|name = <ID> [(<AS>)? alias = <ID>]

{if (alias!= null) jjtThis.addTable(name.image,alias.image);else

jjtThis.addTable(name.image,null);alias=null;

})

("," ("(" SubSelectClause() ")" [(<AS>)? alias = <ID>]

{jjtThis.addSubqueryAlias((alias==null)?null:alias.image);alias=null;

}|

name = <ID> [(<AS>)? alias = <ID>]{

if (alias!= null) jjtThis.addTable(name.image,alias.image);else jjtThis.addTable(name.image,null);alias=null;

})

)*

61

}

void Conditions() : {}{

OrCond()}

void OrCond() #void: {}{

( AndCond() ( <OR> AndCond() )* ) #OrCond(>1)}

void AndCond() #void: {}{

( UnaryCond() (<AND> UnaryCond())* ) #AndCond(>1)}

void UnaryCond() #void: {}{

( <NOT> ("(" OrCond() ")" | Comparisson()) ) #Not(true)

| "(" OrCond() ")" | Comparisson()}

void Comparisson() : {Token t1=null,t2=null;}{

PartComp() ( (t1=<COMPARATOR> (PartComp() | FuzzyTrapezium() |Quantor() ))|(t2=<LIKE> StringComp()) ) ImpComp()

{if(t2!=null) jjtThis.setOperator("=");else jjtThis.setOperator(t1.image);

}}

void PartComp() #void : {}{

LOOKAHEAD(2) IDComp() | NumberComp() | StringComp() | DateComp()}

void IDComp() : { Token t1=null; Token c1=null;}{t1 = <ID> ["." c1 = <ID>] {

if( c1 != null) { jjtThis.setTable(t1.image);jjtThis.setColumn(c1.image);}

else { jjtThis.setTable(null);jjtThis.setColumn(t1.image);}

}

62

}

void StringComp() : { Token t1;}{

t1 = <TEXTSTRING> { jjtThis.setText(t1.image); }}

void NumberComp() : { Token t1;}{

t1 = <INTEGER> { jjtThis.setInteger(t1.image); }| t1 = <FLOAT> { jjtThis.setFloat(t1.image); }

}

void DateComp() : { Token t1;}{

t1 = <DATE> { jjtThis.setDate(t1.image); }}

void ImpComp() #void : { Token t1=null;}{

((<IMP> (t1=<FLOAT> | t1=<INTEGER>) { jjtThis.addImp(t1.image);} )?)#imp(t1 != null)

}

void FuzzyTrapezium() : {Token t1=null,t2=null,t3=null,t4=null;}{

<TRAPEZIUM> "("

(LOOKAHEAD(4)((t1 = <INTEGER> | t1 = <FLOAT> | t1 = <MININF> )","(t2 = <INTEGER> | t2 = <FLOAT> )","(t3 = <INTEGER> | t3 = <FLOAT> )","(t4 = <INTEGER> | t4 = <FLOAT> | t4 = <PLUSINF> ) ")"

{jjtThis.setNumTrap(t1.image,t2.image,t3.image,t4.image);}

)|(

(t1 = <MININF> | t1 = <DATE>)"," t2 = <DATE>","t3 = <DATE>"," (t4 = <DATE> | t4 = <PLUSINF>) ")"

{jjtThis.setDateTrap(t1.image,t2.image,t3.image,t4.image);

}))

}

63

void Quantor() : {Token quantor=null,aquantor=null,subqueryalias=null;}{

<QUANTOR>( (quantor=<ID>) { jjtThis.addQuantor(quantor.image); } )*( aquantor=<FLOAT>)?( "(" SubSelectClause() ")" [(<AS>)? subqueryalias = <ID>] )?{if(aquantor != null)

jjtThis.setAbsoluteQuantor(aquantor.image);jjtThis.addSubqueryAlias((subqueryalias==null)?null:

subqueryalias.image);subqueryalias=null;}

}

void TresHold() : {Token id=null,n=null,t1=null,t2=null,t3=null,comp=null;}

{try{"["

(( id=<ID> comp=<COMPARATOR> ( LOOKAHEAD(4) (n=<INTEGER>|n=<FLOAT>) |

("(" (t1=<FLOAT> | t1=<INTEGER>) ";"(t2=<FLOAT> | t2=<INTEGER>) ";"

(t3=<FLOAT> | t3=<INTEGER>) ")" )){

try{if(!comp.image.equals("="))

throw new ParseException("Error parsing the treshold part, \"=\" expected");

if(id.image.equalsIgnoreCase("n")) {jjtThis.setN(n.image);}else if(id.image.equalsIgnoreCase("r")) {jjtThis.setR(n.image);}

else if(id.image.equalsIgnoreCase("t")) {jjtThis.setT(t1.image,t2.image,t3.image);}

else throw new ParseException("Error: expected n,r or t treshold indicator, Found"+generateParseException().currentToken);

} catch(java.lang.NullPointerException e){

throw new ParseException("Error: invalid Treshold Specification");

}}

64

) (",")?)*

"]"

}catch(parser.TokenMgrError e){

throw new ParseException("Unexpected character found while"+"parsing treshold specification: "+ getNextToken());

}}

65

Lijst van figuren

2.1 Trapezoıdale vormfunctie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Voorbeeld van de Zadeh t-norm voor de definitie “groot en zeer groot” . . . 7

3.1 Algemene structuur applicatie . . . . . . . . . . . . . . . . . . . . . . . . . . 243.2 Plain FlexQL Query Interface . . . . . . . . . . . . . . . . . . . . . . . . . . 253.3 Vereenvoudigd klassendiagram van het ddcm-package . . . . . . . . . . . . . 28

4.1 Relatieve kwantoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.2 Absolute kwantoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.3 Voorbeeld 1 - resultaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404.4 Voorbeeld 1 - resultaat met andere aggregator . . . . . . . . . . . . . . . . . 404.5 Voorbeeld 2 - resultaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.6 Voorbeeld 3 - resultaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

A.1 Overzicht packages in ddcm . . . . . . . . . . . . . . . . . . . . . . . . . . . 52A.2 Package ddcm.eval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53A.3 Package ddcm.fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53A.4 Package ddcm.operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54A.5 Package ddcm.database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55A.6 Package ddcm.processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56A.7 Package ddcm.processor.parser . . . . . . . . . . . . . . . . . . . . . . . . . 57

66

Lijst van tabellen

2.1 Voorbeelden van t-normen en t-conormen . . . . . . . . . . . . . . . . . . . 72.2 Voorbeelden van S-implicaties . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.1 Reguliere expressieregels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4.1 Functies geassocieerd met de relatieve kwantoren . . . . . . . . . . . . . . . 324.2 Functies geassocieerd met de absolute kwantoren . . . . . . . . . . . . . . . 32

67

Bibliografie

[DP97] Didier Dubois and Henri Prade. The three semantics of fuzzy sets. Fuzzy Setsand Systems, 90(2):141–150, September 1997.

[HTVM04] Axel Hallez, Guy De Tre, Jorg Verstraete, and Tom Matthe. Application offuzzy quantifiers on possibilistic truth values. Proceedings of the Eurofuse 2004Workshop on Data and Knowledge Engineering, pages 252–254, 2004.

[KY95] G.J. Klir and B. Yuan. Fuzzy sets and fuzzy logic: Theory and applications.Computers and Mathematics, (1):149–184, 1995.

[Mic] Sun Microsystems. MySQL 5.0 Reference Manuel.

[MT03] Tom Matthe and Koen Tourne. Flexibele bevraging van relationele databan-ken: studie en implementatie. Master’s thesis, Universiteit Gent, 2003.

[ST05] Daniel Sanchez and Andrea G.B. Tettamanzi. Generalizing Quantification inFuzzy Description Logics, volume 33 of Advances in Soft Computing, pages397–411. Springer Berlin / Heidelberg, 2005. ISBN 978-3-540-22807-3.

[Zad65] L.A. Zadeh. Fuzzy sets. Information and Control, 8(3):338–353, June 1965.

[Zad75] L.A. Zadeh. The concept of a linguistic variable and its application to ap-proximate reasoning i. Information Sciences, 8:199–251, 1975.

[Zad83] L.A. Zadeh. A computational approach to fuzzy quantifiers in natural langu-ages. Computers and Mathematics, 9(1):149–184, 1983.

[Zad99] L.A. Zadeh. Fuzzy sets as a basis for a theory of possibility. Fuzzy Sets andSystems, 100(sup):9–34, April 1999.

68

Verbeterde toegankelijkheid voor een databankbeheersysteem...

Documents

Transcript of Verbeterde toegankelijkheid voor een databankbeheersysteem...