Knowledge-Based Systems 38 (2013) 62–73

Contents lists available at SciVerse ScienceDirect

Knowledge-Based Systems

journal homepage: www.elsevier .com/locate /knosys

Prioritized fuzzy logic based information processing in relational databases

Srdjan Škrbic, Miloš Rackovic, Aleksandar Takaci ⇑University of Novi Sad, Faculty of Science, Department of Mathematics and Informatics, Trg Dositeja Obradovica 4, Novi Sad, Serbia

a r t i c l e i n f o

Article history:Available online 8 February 2012

Keywords:FuzzyRelationalDatabaseApplicationDevelopment

0950-7051/$ - see front matter � 2012 Elsevier B.V. Adoi:10.1016/j.knosys.2012.01.017

⇑ Corresponding author.E-mail address: sasatakaci@gmail.com (A. Takaci).

a b s t r a c t

Many years of research related to fuzzy logic and fuzzy set theory extensions to relational databases havenot lead to stable implementations, standardized languages or fuzzy relational database applicationdevelopment tools and methods. The main goal of this paper is the modelling and the implementationof a set of tools that allow usage of fuzzy logic enriched with priorities in relational database applications.In order to achieve that goal, at first, the relational data model is extended with the elements of fuzzy settheory. After that, a fuzzy extension of the SQL query language, called the PFSQL, is defined. An interpreterfor that language is integrated inside an implementation of the fuzzy JDBC driver. An implementation ofthe CASE tool for modelling of fuzzy relational database schemas rounds up a set of tools for the imple-mentation of Java fuzzy database applications. In this sense, this paper presents a step towards a meth-odology for the fuzzy relational database application development.

� 2012 Elsevier B.V. All rights reserved.

1. Introduction

Most of the real world information contains imprecise andincomplete values. The relational data model does not facilitatesupport for this kind of information. Attribute values are, by defini-tion, absolute. Fuzzy sets and fuzzy logic have been successfullyused in many similar applications, where management of impre-cise and incomplete data was necessary. That is why the idea toincorporate fuzzy set theory and fuzzy logic to relational databasesseams feasible and useful.

The main goal of the five-year long research conducted atthe University of Novi Sad was the implementation of a systemcapable of using priority fuzzy logic with databases. Moreover, wehave defined and implemented a complete fuzzy relational data-base application development solution. The system can be dividedinto four main parts:

� fuzzy query language PFSQL (Prioritized Fuzzy Structured QueryLanguage),� new fuzzy relational data model based on fuzzy extensions of

the relational model,� CASE (Computer Aided Software Engineering) tool for fuzzy

relational database modelling and� interpreter for the PFSQL query language weaved inside a fuzzy

extension of the JDBC (Java DataBase Connectivity) driver thatallows PFSQL querying from Java programs.

ll rights reserved.

In an effort to create such a system, we encountered two mainproblems. The first one is a question of a method for storing fuzzyvalues using a relational database management system. Thesecond, much more complex, is related to the design of the SQL lan-guage extensions that allow usage of prioritized fuzzy logic. Imple-mentation of an appropriate interpreter that uses a fuzzy databaseis an integral part of the second problem. In this paper, we offersolutions to these problems and compare these solutions to the pre-vious ones.

Giving solutions to these fundamental problems, we round themup by implementing the CASE tool that simplifies fuzzy databasemodelling and the fuzzy JDBC driver that allows easy querying. Inthis way, we obtain a system for the fuzzy relational database appli-cation development, to the best of our knowledge, the first of itskind.

The implementation of the priority fuzzy logic language inter-preter is heavily dependent on the mathematical background. It isfirst necessary to formally explain how the actual calculations aredone. The needed mathematical model is defined as a generaliza-tion of the known result – the Prioritized Fuzzy Constraint Satisfac-tion Problem. In this way, we obtain the concept of the GeneralisedPrioritized Fuzzy Constraint Satisfaction Problem (GPFCSP) that wedescribe in this paper as the needed mathematical background.

In the next section we give an overview of the existing resultsand solutions related to the use of fuzzy logic with databases.The third section contains the definition and other details relatedto the GPFCSP system. The next section gives the details relatedto the PFSQL language design, the fuzzy relational data model re-lated to it and describes the main ideas in the PFSQL interpreterand fuzzy JDBC driver implementation. The fifth section describeshow we applied the described system and gives some examples

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 63

of its usage. At the end, we compare our approach to the most suc-cessful competitors – the FSQL (Fuzzy Structured Query Language)language and the FIRST-2 fuzzy relational data model, and drawsome conclusions.

2. Related work

The first model that introduces similarity relations in the rela-tional model is the Buckles–Petry model [1]. This paper gives astructure for representing inexact information in the form of a rela-tional database. The structure differs from ordinary relational dat-abases in two important aspects: components of tuples need not besingle values and a similarity relation is required for each domainset of the database. Zvieli and Chen [2] offered a first approach toincorporate fuzzy logic in the ER (Entity–Relationship) model.Their model allows fuzzy attributes in entities and relationships.

Fuzzy functional dependencies and fuzzy normal forms, as wellas algorithms for dependency preserving and lossless join decom-positions of fuzzy relations in specific fuzzy extensions of the rela-tional model are investigated in [3,4].

Umano and Fukami proposed the FREEDOM-O, a fuzzy databasesystem which is an extension of the relational data model [5]. Thissystem supports a fuzzy data model, and querying. It is the firstimplementation of a fuzzy database system. After that result, otherresearchers have proposed similar fuzzy extensions to the rela-tional model such as in [6–9].

Another serious attempt to implement a fuzzy database systemis given in [10,11]. The authors propose fuzzy extensions of theclassical SQL and implement a system that allows using fuzzy con-ditions in the place of Boolean ones.

The GEFRED (Generalised Model of Fuzzy Relational Databases)model [12] is a probabilistic model that refers to generalised fuzzydomains and admits the possibility distribution in domains. This isa fuzzy relational database model that has the representationalcapabilities for a wide range of fuzzy information. In addition, itdescribes a flexible way to handle this information. The GEFREDmodel experienced subsequent expansions, such as [13–15].

Chen and Kerre [16] introduced the fuzzy extension of severalmajor EER (Extended Entity–Relationship) concepts. Fuzzy logicwas applied to some of the basic EER concepts connected to thenotion of subclass and super class. Chaudhry, Moyne and Runden-steiner [17] proposed a method for designing fuzzy relational dat-abases following the extension of the ER model of Zvieli and Chen.They also proposed a design methodology for the FRDBs (FuzzyRelational Databases) that contains extensions for representingthe imprecision of data in the ER model, and a set of steps forthe derivation of a FRDB from this extended ER model.

Galindo, Urrutia and Piattini [18] describe a way to use thefuzzy EER model to model the database and represent the modeledfuzzy knowledge using a relational database in detail. This workgives insight into some new semantic aspects and extends theEER model with the fuzzy capabilities. The model is called theFuzzyEER model. Also, a way to translate the FuzzyEER model tothe FIRST-2, a database schema that allows representation of fuzzyattributes in relational databases is given. The FIRST-2 schemaintroduces a concept of the Fuzzy Meta-knowledge Base (FMB).In addition, in this work, authors introduce and describe the spec-ification and the implementation of the FSQL – an SQL languagewith fuzzy capabilities in great detail.

The current state of the art in this area includes mature fuzzyEER model extensions that describe a wide range of modelling con-cepts for full flavoured fuzzy database modelling. These conceptualmodels are supported by the robust models for the fuzzy data rep-resentation in relational databases, such as the FIRST-2. The possi-bilities to translate the conceptual models to the relational-based

ones are also studied in detail. In addition, the FSQL is the firstimplementation of the fuzzy database query language that incor-porates the majority of fuzzy logic concepts. Fuzzy logic has alsobeen often applied to enrich various search and data miningalgorithms [19,20].

In [21] the authors studied the possibilities to extend the rela-tional model with the fuzzy logic capabilities. The subject waselaborated in [22,23], where a detailed model of fuzzy relationaldatabases was given. One of the main features of the model is thatit allows any fuzzy subset of the domain to be the attribute valuewhich was not the case in previous FRDB models.

Moreover, using the concept of GPFCSP from [24,25], theauthors found a way to introduce priority queries into fuzzy rela-tional databases, which resulted in the PFSQL query language[26]. The PFSQL allows conditions in WHERE clause of a query tohave a different priority i.e. importance degree. It is one of the firstlanguages with such capabilities. The GPFCSP gives the theoreticalbackground for the implementation of priority queries [26]. Theauthors have also succeeded in formalising the PFSQL queries byobtaining their interpretation in an existing fuzzy logic. They foundthat the ŁP 1

2 logic provides enough elements [27,28].In difference to the earlier research attempts, the basic goal of

our research is to develop an integrated set of tools that allowsthe fuzzy relational database application implementation. The mainpurpose of this paper is to round up all results obtained in this five-year long research and to describe the final solution as a whole.

3. Theoretical background

3.1. PFCSP

A prioritized fuzzy constraint satisfaction problem (PFCSP) is atype of the fuzzy constraint satisfaction problem (FCSP) in whichthe notion of priority is introduced. The PFCSPs are first introducedby Dubois et al. [29]. An axiomatic framework was given in [24]and applied in the agent-based automated negotiation [30]. Themost important factors in that implementation are the Schur-concave t-norms. They are introduced in such a way that the valuewith the biggest priority has the largest impact on the result givenby a Schur-concave t-norm. For more information on the Schur-concave t-norms and t-norms in general see [31].

Takaci [32] gives an alternative axiomatic framework for thePFCSP, similar to the one given in [24], but with a stricter notionof priority. We recall that definition here.

Definition 3.1. When given (X,D,Cf,q), where

1. X = {xij i = 1,2, . . .,n} is a set of variables,2. D = {dij i = 1,2, . . . ,n} is a finite set of domains. Each domain di is

a finite set containing the possible values for the correspondingvariable xi in X,

3. Cf is a set of fuzzy constraints, that is,

Cf ¼ fRfi jlRf

i: di1 � � � � � diki

! ½0;1�; i ¼ 1; . . . ;m;1

6 ki 6 ng; ð1Þ

4. q:Cf ? [0,1)

and a simultaneous valuation vX(x1, . . . ,xn), xi 2 di of all variables inX, shortly denoted vX and an operator � : [0,1]n ? [0,1], g : [0,1)� [0,1] ? [0,1], constraints Rf

i 2 Cf for i = 1, . . . ,n and a satisfactiondegree aq(vX) which is calculated in the following way:

aqðvXÞ ¼ �ni¼1 g q Rf

i

� �;lRf

iðvXÞ

� �� �; ð2Þ

this system is a PFCSP if the following axioms are satisfied:

64 S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73

1. If for the fuzzy constraint Rfmax, we have

qmax ¼ q Rfmax

� �¼ max q Rf

i

� �jRf

i 2 Cf ; i ¼ 1; . . . ;nn o

; ð3Þ

then

lðRfmaxÞ¼ 0) aqðvXÞ ¼ 0: ð4Þ

2. If "Rf 2 Cf, q(Rf) = q0 – 0, then

aðvXÞ ¼ �ni¼1lRf

iðvXÞ: ð5Þ

3. For Rfi ;R

fj 2 Cf , assume q Rf

i

� �P q Rf

j

� �; d > 0 and there are two

different valuations vX and v 0X such that:� if 8Rf – Rf

i and 8Rf – Rfj , then lRf ðvXÞ ¼ lRf v 0X

� �,

� if Rf ¼ Rfi , then lRf ðvXÞ ¼ lRf v 0X

� �þ d,

� if Rf ¼ Rfj , then lRf ðvX 0Þ ¼ lRf ðvXÞ þ d,

then aðvXÞP aðv 0XÞ holds.4. For two different valuations vX and v 0X such that "Rf 2 Cf, if

lRf ðvXÞP lRf v 0X� �

; ð6Þ

then aðvXÞP a v 0X� �

holds.5. If there exists a compound label such that 8Rf 2 Cf ;lRf ðvXÞ ¼ 1

then aq(vX) = 1.

It is important to notice that the PFCSP is a generalization of theknown concept of CSP (Constraint Satisfaction Problem). Con-straints in the CSP are functions mapping the Cartesian productof the variable domains to the {0,1} set. In this case, we use theunit interval ([0,1]) instead of the {0,1} set. In this way, the con-straints are transformed to the membership functions of fuzzy sets.

The function q represents the priority of each constraint. Great-er value of q(Rf) means that the constraint Rf has a larger priority.The function g aggregates the priority of each constraint with thevalue of that constraint. These aggregated values of each constraintare then aggregated by the operator �, which results in the satis-faction degree of that valuation.

The first axiom states that a zero value of the local satisfactiondegree of the constraint with the maximum priority implies a zerovalue of the local satisfaction degree. The second axiom states that,in the case of equal priorities, the PFCSP becomes a FCSP. The thirdaxiom captures the notion of the priority. If one constraint has alarger priority then the increase of the value on that constraintshould result in a bigger increase of the global satisfaction degreethan when the value with the smaller priority has the same in-crease. The fourth axiom is the monotonicity property, and finallythe fifth is the upper boundary condition. A more detailed explana-tion of the axioms given in this definition can be found in [32]. Thenext theorem gives actual PFCSP that satisfies this definition.

Theorem 3.1. The following system is a PFCSP:

aqðvXÞ ¼ �ni¼1 }M

qðRfi Þ

qmax;lRf

iðvXÞ

! !; ð7Þ

where Rfi 2 Cf for i = 1, . . . , n, � is the Lukasiewicz t-norm given by:

TLðx1; . . . ; xnÞ ¼ maxf0;Xn

i¼1

xi � nþ 1g ð8Þ

and }Mðx; yÞ ¼ SPð1� x; yÞ, where SP is the product norm given by:

SPðx; yÞ ¼ xþ y� xy: ð9ÞThe proof is given in [32].

As mentioned above, the PFCSP is a concept known for years. Atthis point we introduce the idea of similarity between the PFCSPsystems and the SQL SELECT clause. The basic structure of theSELECT clause consists of SELECT, FROM and WHERE constructs.

The variables that follow after the SELECT keyword can be viewedas PFCSP variables. The table names, that follow after the FROMkeyword, can be viewed as their domains. The WHERE clause con-tains a sequence of constraints connected with logical operators.

Similarly, the PFCSP also contains a set of constraints. The mem-bership degree of each constraint indicates the local degree towhich the constraint is satisfied. In order to obtain the globalsatisfaction degree, local degrees are aggregated using a certaint-norm.

In difference to the standard SQL WHERE clause, constraints inthe PFCSP are fuzzy and they even have a priority assigned. It isbecoming clear that it is possible to extend the SELECT clause byallowing fuzzy variables and fuzzy constraints with priorities inthe WHERE clause. The PFCSP could be used as a mathematicalbackground that defines how to calculate the fuzzy membershipdegrees of the result set tuples. But it has one limitation – it onlyallows the usage of t-norm, i.e. conjunction in connecting con-straints. The fuzzy where clause in which it is allowed only touse a conjunction, and not a negation or a disjunction is not accept-able. That is why the concept of the PFCSP had to be generalisedfirst.

3.2. GPFCSP

The PFCSP concept is generalised by allowing the possibilities tocombine the t-norm, t-conorm and negation operators to connectthe prioritized fuzzy constraints. The definition is very similar tothe definition of the PFCSP. We extend the previous definition byadding the possibility to use a disjunction or a negation. In the pro-cess, we conserve the desired behaviour of priority.

Definition 3.2. Let X, D, Cf, q, g and vX be defined as in Definition 3.1.The generalised PFCSP is defined as a tuple ðX;D;Cf ;q; g; ^;_; – gÞwhich satisfies the following.

An elementary formula in the GPFCSP is a pair (x,q(Ci)), whereCi 2 Cf, x 2 Dom(Ci) represents the satisfaction degree of a con-straint Ci and pi = q(Ci) represents its priority.

A formula in the GPFCSP is defined in the following way:

1. An elementary formula is a formula.2. If f1 and f2 are formulas then also ^(f1, f2), _ (f1, f2) and :(f1) are

formulas.

For each valuation vX, a satisfaction degree aF(vX) of a formula Fis calculated depending on the interpretation of connectives.

A system is a GPFCSP if.

1. Let F = ^i2{1,. . .,n}fi be a formula in the GPFCSP where fi,i 2 {1, . . . ,n} are elementary formulas and let Cf be a set of con-strains that appear in the formula. If for the fuzzy constraintRf

max we have

qmax ¼ q Rfmax

� �¼maxfqðRf ÞjRf 2 Cf g; ð10Þ

then for each formula F we have:

lRfmaxðvXÞ ¼ 0) aFðvXÞ ¼ 0: ð11Þ

2. If "Rf 2 Cf, q(Rf) = q0 2 [0,1], then for each formula F the follow-ing holds:

aFðvXÞ ¼ FLðvXÞ; ð12Þ

where FL is the interpretation of the logical formula F in fuzzy logicLð^;_;:Þ.3. For Rf

i ;Rfj 2 Cf , assume q Rf

i

� �P q Rf

j

� �; d > 0 and assume that

there are two different valuations vX and v 0X such that:� if 8Rf – Rf

i and 8Rf – Rfj , then lRf ðvXÞ ¼ lRf v 0X

� �,

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 65

� if Rf ¼ Rfi , then lRf ðvXÞ ¼ lRf v 0X

� �þ d,

� if Rf ¼ Rfj , then lRf v 0X

� �¼ lRf ðvXÞ þ d.

Then, for formulas:

F ¼n

k¼1

ðxk;qðRkÞÞ; xk 2 DomðRkÞ ð13Þ

and

F ¼_nk¼1

ðxk;qðRkÞÞ; xk 2 DomðRkÞ; ð14Þ

the following holds:

aFðvXÞP aF v 0X� �

: ð15Þ

4. Assume that two different valuations vX and v 0X such that"Rf 2 Cf satisfy

lRf ðvXÞP lRf v 0X� �

: ð16Þ

If formula F has no negation connective, then the following holds:

aFðvXÞP aF v 0X� �

: ð17Þ

5. Let there be a valuation such that 8Rf 2 Cf ;lRf ðvXÞ ¼ 1:If F is aformula F ¼

Vni¼1fi or F ¼

Wni¼1fi, where fi, i 2 {1, . . . ,n} are ele-

mentary formulas then

aFðvXÞ ¼ 1: ð18Þ

The fact that the TL � SP combination can be used to obtain a

GPFCSP as it was used to obtain a PFCSP system earlier, will beexpressed as another very important theorem.

Theorem 3.2. The following system ðX;D; Cf ;q; g;^;_;:;}Þ, where^ = TL, _ =SL,: = 1 � x and finally }ðxi; ciÞ ¼ SPðxi;1� piÞ is a GPFCSP.The global satisfaction degree of a valuation vX for a formula F isobtained in the following way:

aFðvXÞ ¼ Ff}ðvxi;qðRf Þqmax

ÞjRf 2 Cf g; ð19Þ

where Cf is the set of constraints of formula F, qmax = max{q(Rf),Rf 2 Cf}and F is the interpretation of formula F in the GPFCSP.

The proof can be found in [25]. It is a consequence of theTheorem 3.1 and the facts that 1 � x is the standard negation, TL

is a t-norm and SL is a t-conorm dual to the TL.The global satisfaction degree calculation for a given valuation

will be illustrated on an example.

3.3. Example

Let us observe a set of students taking the faculty entranceexamination. Our task is to rank them using three criteria – the highschool GPA (Grade Point Average), the test score and their age. Letus construct the variables and their domains in the following way:

1. X1 represents the high school GPA, d1 = [2,5],2. X2 represents the age, d2 = [0,130],3. X3 represents the test score, d3 = [0,60].

Fig. 1. The membership fun

Let us also define the following constraints:

1. Rf1 ¼‘‘excellent high school GPA’’,

2. Rf2 ¼‘‘about 20 years old’’,

3. Rf3 ¼‘‘good test results’’.

The constraints are fuzzy subsets of the corresponding domains(Fig. 1). Let us model the first constraint as a right-shoulder that as-cends from 4 to 5. The second constraint is modeled as a trianglefuzzy number that has a peak in 20, with the left offset of 1 andthe right offset of 6. Finally, the third constraint is a right-shoulderthat ascends from 40 to 60.

Let the criterion on how to pick a candidate (formula F) be: ‘‘stu-

dent has to have an excellent high school GPA Rf1

� �or has to be about

20 years of age Rf2

� �and has to have a good test results Rf

3

� �’’. In

addition, we define the priorities like this: q Rf1

� �¼ 0:4; q Rf

2

� �¼

0:1 and q Rf3

� �¼ 0:6. The valuation vX given in the Table 1 defines

three candidates.First, we calculate the constraint satisfaction degree for every

constraint and every student. These degrees are obtained directlyas values of the corresponding membership functions in the givenpoints. The results are given in the Table 2.

Now we can calculate the global constraint satisfaction degreefor every student in the following way:

a ¼ TL SL� SP lRf1ðvÞ;1� q Rf

1

� �� �; SP lRf

2ðvÞ;1� q Rf

2

� �� �� �;

��SP lRf

3ðvÞ;1� q Rf

3

� �� ��: ð20Þ

If we use the values for the first student, we obtain the following:

a ¼ TLðSLðSPð0:5;0:6Þ; SPð0:83;0:9ÞÞ; SPð0:5;0:4ÞÞ: ð21Þ

Finally, we obtain the satisfaction degree for the first student:

a ¼ ðTLðSLð0:8;0:983Þ;0:7Þ ¼ TLð1;0:7Þ ¼ 0:7: ð22Þ

The global constraint satisfaction degrees for the other students arecalculated in the same way and are given in the Table 3. These re-sults are a measure of how much the students satisfy our criteria.Obviously, Sarah is the best candidate.

Clearly, the GPFCSP concept can be used as a mathematicalbackground that defines how to calculate the fuzzy membershipdegrees of the result set tuples because, like the standard SQL, it al-lows the usage of t-norms (conjunction), t-conorms (disjunction)and negation. It should be clear by now that the given examplecan easily be connected to the query from the Listing 1 given insome pseudocode priority fuzzy SQL language.

4. The fuzzy relational database application developmentsystem

In this section we first discuss details related to the PFSQL lan-guage design. We introduce it formally and illustrate its possibili-ties on a set of examples. Next, we describe our fuzzy relational

ctions of Rf1;R

f2 and Rf

3.

Table 1Valuation vX.

Name GPA Age Test

Peter 4.5 21 50Sarah 4.8 19 55Vanessa 4.7 20 52

Table 2The constraint satisfaction degrees for every constraint and every student.

Name GPA Age Test

Peter 0.5 0.83 0.5Sarah 0.8 0 0.75Vanessa 0.7 1 0.6

Table 3The constraint satisfaction degrees for all students.

Name a

Peter 0.7Sarah 0.85Vanessa 0.76

Listing 1. A pseudocode priority fuzzy SQL query.

Listing 2. An example of a PFSQL query that returns names and surnames ofstudents whose GPA is greater than the given triangular fuzzy number.

Listing 3. An example of a PFSQL query with a linguistic label.

66 S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73

data model. At the end, we explain details related to the CASE tooland the implementation of the PFSQL interpreter integrated insidethe fuzzy JDBC driver.

4.1. The PFSQL language

In order to allow the use of fuzzy values in SQL queries, weextended the standard SQL with several new elements. In additionto fuzzy capabilities, we add the possibility to specify the prioritiesfor fuzzy statements. We named the query language constructed inthis manner the priority fuzzy SQL – PFSQL. This appears to be thefirst language that has such capabilities.

The question is what elements of the standard SQL should andcan be extended. It is necessary to allow the comparison betweendifferent types of fuzzy values. In addition, variables can have bothcrisp and fuzzy values, so comparison between fuzzy and crisp val-ues has to be included. In other words, the PFSQL has to be able tocalculate expressions like height = triangle(180,11,9), regardless ofwhat value of height is in the database – fuzzy or crisp. The expres-sion triangle(a,b,c) denotes a triangular fuzzy number with the peakat a, with the left offset b, and the right offset c. Next, we demandthe possibility to set the conditions like height P triangle(180,11,9).

The ordering and addition operations on the set of fuzzy num-bers give grounds to introduce the aggregate functions like MIN,MAX and SUM in the PFSQL. Moreover, it is possible to define a fuz-zy GROUP BY clause in combination with the aggregate functionson fuzzy values.

The standard SQL includes possibilities to combine the condi-tions using logical operators. This possibility also has to be a partof the fuzzy extensions, thus combining the fuzzy conditions is alsoa feature of our implementation. The values are calculated usingthe t-norms, t-conorms, and the strict negation. The queries arehandled using priority fuzzy logic which is based on the GPFCSPsystems.

The nested queries are yet another problem that we encoun-tered in our effort to extend the SQL with the fuzzy capabilities.We can divide the nested queries in two categories – the ones thatdo not depend on the rest of the query and the ones that do. Theindependent SQL queries are not problematic, they can be calcu-lated separately, and the resulting values can be used in theremainder of the query as constants. The dependent SQL querieswith the dependence expressions that do not use the fuzzy valuesor operators are also easy to handle – they can be evaluated by aclassical SQL interpreter. However, if a nested query is dependentand dependence conditions contain the fuzzy values or operators,then it remains unclear how to evaluate such a query and whatdoes this dependence even mean.

Having stated the facts and considerations we had in mind, wegive the complete EBNF syntax of the PFSQL language in theAppendix A.

Although it is not possible to present all the features of thelanguage just by giving its EBNF syntax, this grammar gives anoverview of the possibilities and extensions built into the PFSQL.To illustrate the possibilities further, we give four PFSQL queryexamples. The queries are executed against the database contain-ing the student entrance examination data that was mentionedin the Section 3, and described in detail later in this section. Thefirst query (Listing 2) returns the names and surnames of the stu-dents whose high school GPA is greater than the given triangularfuzzy number.

The # symbol is chosen to mark the fuzzy constants. If wedefined a linguistic label ‘‘average GPA’’ that has a value triangle(4,1,0.4), the previous query could be simplified (Listing 3).

The queries can be enriched with the additional constraints. Thenext query (Listing 4) returns the names and surnames of thestudents that have the GPA greater than average with the priority0.4, and are 20 years old with the priority 0.1. The query also con-tains the threshold clause that limits the results and removes thetuples with the fuzzy satisfaction degree smaller than 0.2.

As we already mentioned, the aggregate functions MAX, MINand COUNT can take a fuzzy value as an argument. The query atthe Listing 5 illustrates the usage of the aggregate function MIN.It returns the minimal GPA.

If we assume that the variable s.highSchoolGPA is fuzzy, execu-tion of this query becomes complex because it includes the order-ing of fuzzy values. As a result, for example, we could get thisvalue: triangle (4.2,0.7,0.4).

4.2. The fuzzy relational data model

It is clear now that the PFSQL implementation has to rely upon ameta data about the fuzzy attributes that reside inside the database.For these purposes, a fuzzy relational data model has been defined.Our model stores the crisp values in the same way as the relational

Listing 5. An example of a PFSQL query with an aggregate function.

Fig. 2. An example of a fuzzy data model.

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 67

model does, while, for fuzzy values, we define the fuzzy meta datamodel. In addition, here we provide an insight into the process oftransformation of an example of the classical relational model withthe fuzzy attributes to the corresponding fuzzy relational datamodel.

If we wish to store a fuzzy value, we need to find a way to storethe data related to its characteristic function. Theoretically, in thisway, we could store any fuzzy value. But, in practice, only a hand-ful of characteristic functions are in use. Let us name them thefuzzy data types from this aspect. That is why we cover only a lim-ited number of fuzzy data types and obtain an efficient and a rela-tively simple data model.

An example relational model shown in Fig. 2 contains the tablesStudent and StudyProgram as well as the intersection table Scorethat we use to model this many-to-many relationship. the tableStudent contains data about the students taking an entrance exam-ination. It contains the two fuzzy attributes: the highSchoolGPAand the age. The table StudyProgram contains data related to thestudy programs and contains no fuzzy values. The intersectiontable – Score, contains data about the score of a particular studenton a particular study program in a particular examination term (wesuppose that there can be more than one entrance examinationterm). Its attribute score is also fuzzy.

The corresponding fuzzy relational data model is shown inFig. 3. The tables Student, StudyProgram and Score are shown atthe top of the figure. They are the same as they were before exceptfor the data type of fuzzy columns. In this schema, they are of typeINTEGER. Moreover, they became the foreign keys that originatefrom the attribute valueID belonging to the FuzzyValue table. In or-der to represent the fuzzy values in the database, we extend thismodel with some additional tables that make the fuzzy meta datamodel.

The table IsFuzzy simply stores the information whether anattribute is fuzzy or not. All attribute names in the database arestored here, and beside the table and the attribute name (attributestableName and attributeName), the information whether the attri-bute is fuzzy (value of the attribute isFuzzy is TRUE) or not (valueof the attribute isFuzzy is FALSE) is present.

The table FuzzyValue represents a connection between the fuz-zy data model and the fuzzy data meta model. Every fuzzy columnin every table is a foreign key that references the attribute valueID– the primary key of the table FuzzyValue. Thus, we have onerecord in the table FuzzyValue for every record with the fuzzy va-lue in the database. The attribute code is a foreign key from thetable FuzzyType. This table stores the name of every possible typeof fuzzy value allowed in the model. These types are as follows:interval – the fuzzy value is an interval, triangle – the fuzzy valueis a triangular fuzzy number, trapezoid – the fuzzy value is a trap-ezoidal fuzzy number, fuzzyShoulder – the fuzzy value is a fuzzyshoulder, linguisticLabel – the fuzzy value is a linguistic label, crisp– the fuzzy value is actually a crisp value.

For every value in this list, there is a separate table in the metamodel that stores the data for all fuzzy values of the specific fuzzytype. All of these tables have the attribute valueID, a foreign keyfrom the table FuzzyValue. In this way, the value for the specificfuzzy attribute is stored in one of these tables depending on itstype.

The attribute forValueID in the table FuzzyValue is a foreign keythat represents a recursive relationship and references the primary

Listing 4. An example of a PFSQL query with ad

key of the FuzzyValue table. This attribute is used to represent thelinguistic labels. It has a value different than null if the type of theattribute that it represents is a linguisticLabel. The linguistic labelsonly represent names for the previously defined fuzzy values. Inthis fashion, if an attribute is a linguistic label, then its name isstored in the table LinguisticLabel. In this case, the attribute for-ValueID has the value of valueID of a fuzzy value that this linguisticlabel represents. We conclude that, in order to represent a linguis-tic label, two records in the table FuzzyValue are needed.

For example, let us suppose that the student Jovan Jankovic has ahigh school GPA of ‘‘approximately 4.85’’. In accordance to this, inthe Student table there is a corresponding record containingsome basic information and values for the student’s GPA – high-SchoolGPA = 1. This value is a foreign key referring to the valueIDattribute of the FuzzyValue table from the fuzzy meta model thatcontains actual data. For example, in case of the highSchoolGPAattribute, the FuzzyValue table contains a record with valueID = 1and with the code attribute value of 2 that signifies a triangularfuzzy number. The table containing the fuzzy type codes is theFuzzyType table. Finally, the table TriangularFN contains the actualvalue for the student’s high school GPA – a triangular fuzzy numberwith the peak in 4.85 and with the left offset of 0.65 and the rightoffset of 0.07.

The rest of the values, for the other fuzzy types, are stored in thedatabase in a similar way. Additional information and details re-lated to this topic can be found in [23,26].

The presented fuzzy meta model has been put through thenormalization algorithm that guarantees that the resulting modelconforms to the 3rd normal form. Of course, the fulfilment of thetheoretical conditions for the 3rd normal form depends on theground database model that we are creating too. In any case, thisfeature guarantees that if a database model is at least in the 3rdnormal form, then the addition of the presented fuzzy meta modelwill result in a complete model at least in the 3rd normal form. Inthis way, the presented fuzzy meta model significantly improves

ditional constraints and a threshold clause.

Fig. 3. An example of a fuzzy relational data model.

68 S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73

its theoretical and practical performance. The main reason forinsisting on the 3rd normal form in this model is the efficiency ofthe complete software system relying on a fuzzy relational data-base that conforms to our model.

4.3. The CASE tool

The requirements set in the process of modelling of the CASEtool include the functions for simplified building of a fuzzy rela-tional data model, as well as the functions for its transformationto the SQL script. Our intention was to implement a CASE toolcapable for the visual modelling and easy administration of allcomponents of a fuzzy relational data model – tables, attributes,fuzzy data types and relationships. The application is implementedusing Java programming language and the Swing platform for theGUI.

The CASE tool’s GUI works in the similar way as in all moderntools of this type that allow the modelling of the classical relationalmodels. In the model building process all the automation related tothe migration of keys through the relationships is included. Thisfeature includes the cascade deletion process, migration of keysduring the relationship creation process and the circular referencedetection and prevention. In addition, the CASE tool is required toallow easy SQL script generation for the specific database manage-ment system. In this sense, the capabilities to specify the datatypes used by the DBMS and rules for mapping of the types usedin the model (together with the fuzzy data types) to these typeshad to be included.

The details on how this CASE tool is implemented may be foundin [23].

4.4. The PFSQL interpreter and the fuzzy JDBC driver

The most difficult problem in building of the system that we aredescribing is related to the implementation of an interpreter forthe presented PFSQL query language. If we consider a classicalSQL query, it is clear how to assign a truth value to every elemen-

tary condition in the WHERE clause. With the fuzzy attributes, thesituation becomes more complex. At first, we assign a truth valuefrom the unit interval to every elementary condition. The onlyway to do this is to implement a set of algorithms that calculatethe truth values for every possible combination of values in a queryand values in the database. For instance, if a query contains a con-dition that compares a fuzzy quantity value with a triangular fuzzynumber in the database, we must have an algorithm that calculatesthe compatibility degree of the two fuzzy sets. After the truthvalues from the unit interval are assigned, they are aggregatedusing fuzzy logic. We use a t-norm in case of the operator AND,and its dual t-conorm in case of the operator OR. For the negation,we use the strict negation: N(x) = 1 � x. In case of the priority state-ments, we use the GPFCSP system rules to calculate the result.

We will now describe the processes that allow the PFSQL que-ries to be executed. The basic idea is to first transform a PFSQLquery into an SQL query. Namely, conditions with fuzzy attributesare removed from the WHERE clause and moved up in the SELECTclause. In this way, the conditions containing fuzzy constructs areeliminated, so that the database will return all the tuples – onesthat fulfill fuzzy conditions as well as the ones that do not. As aresult of this transformation, we get a classical SQL query. Then,when this query is executed against the database obtained resultsare interpreted using the fuzzy mechanisms. These mechanismsassign a value (membership degree) from the unit interval to everytuple in the result set. If a threshold is given, all the tuples in theresult set that have the satisfaction degree below the thresholdare removed.

The implementation of these processes contains many subtlepoints and solutions to technical problems. They are all listedand described in detail in [26].

The need to ease the PFSQL usage from Java programs and stillkeep the database independence is resolved with the implementa-tion of the fuzzy JDBC driver. This driver acts as a wrapper for thePFSQL processing mechanisms and for the JDBC API implementedby the driver for a specific RDBMS. The JDBC driver for the databaseused simply becomes a parameter that the fuzzy JDBC driver uses

Fig. 4. The layout of the PFSQL interpreter architecture.

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 69

to access the database. The architecture of the system built in thisway is shown in Fig. 4.

A Java program uses the interfaces offered by the fuzzy JDBCdriver as a front end component. These interfaces include the pos-sibilities to initialize a driver class, create a database connection,create and execute PFSQL statements, and read result sets.

5. Testing

The described implementation is tested on the fuzzified data-base subschema of the student affairs information system of theFaculty of Science in Novi Sad. This subschema is related to thefaculty entrance examination management. It consists of twentyrelational tables with more than 5000 records in most of them.We add to that nine tables that make the fuzzy meta data model(Fig. 3), explained in detail in the Section 4.2.

First we describe how the sample database was made. We cop-ied the entrance examination subschema with real data from theFaculty’s information system to the test database. For the purposeof testing, we used the MaxDB database management system. Afterthat, we selected a number of table attributes suitable for fuzzifica-tion. We added the fuzzy meta model to our database, and con-nected all the selected attributes to the fuzzy meta model usingapproach described in the Section 4.2. Finally, we implemented asmall ad hoc application that fuzzifies data related to all selectedattributes by randomly putting some fuzzy values instead of thereal values. The inserted values are random, but they are selectedcarefully for every attribute so that they are meaningful. Forinstance, the high school GPA takes values from 2 to 5 in the realdatabase. The inserted values also respect this constraint. Anexample of the inserted fuzzy value would be the fuzzy interval[3.6,4.2], or the triangular fuzzy number with the peak in 4.2, withthe left offset of 0.8 and with the right offset of 0.35.

5.1. The example database subschema

The database subschema is shown in Fig. 5. This figure showsonly the main thirteen tables of the model. For the sake of simplic-ity, we omitted the utility tables, as well as the tables that belongto the fuzzy meta model.

The central table in this subschema is the Student table thatcontains the most important data related to an entrance examina-tion candidate. This data is appended with the detailed informationcontained in the Application table. The utility table Language con-tains the data on foreign languages that a candidate learned as partof his previous education.

The table Application profile contains information related to thestudy profiles that candidates may choose. These profiles do nothave to be equal with those they will choose after the successfulentrance examination. For instance, a candidate may choose toapply to the Mathematics study profile, but after the examination,he may choose to enroll to the Mathematics teacher or the Financialmathematics study profile. We use the tables Profile and Contains-Profile to model these facts. The table Priority contains information

on all application profiles a candidate has applied to, sorted by theirpriority.

Every application profile is related to its quota – the maximumnumber of students that can be enrolled to that profile. A quotamay be related to more than one application profile. For everyapplication profile, we define a group of subjects included in theentrance examination for that profile (table Group). The tablesSubject and BelongsToGroup contain information about subjectsin every specific group.

The candidate’s score is contained in the table Score. It containsscores for every group of subjects, that constitute an entranceexamination for the specific application profile a candidate haschosen. RankList stores information on candidate rank lists forevery application profile.

5.2. Fuzzification

Fuzzification of described model includes adding the fuzzy metamodel, selection of the attributes that will be fuzzified and theirconnection to the fuzzy meta model. In essence, the final exampledatabase contains tables shown in Fig. 5, the utility tables from themodel that are removed from the figure for the sake of simplicity,and the fuzzy meta model. The attributes that we selected for fuzz-ification are the following:

� GPA1, GPA2, GPA3 and GPA4 from the Application table, repre-senting the candidate’s GPA’s for all four years of high school,� highSchoolGPA from the Student table, representing the candi-

date’s overall GPA,� score from the Score table, representing the candidate’s

entrance examination score for a given group of subjects,� score, entranceExamScore and GPAScore from the Ranklist

table, representing the candidate’s overall score, the entranceexamination score and the score related to the high school GPA,� budget and selfFinance from the Quota table, representing avail-

able space for a give application profile and� budgetThreshold, selfFinanceThreshold and entranceExam-

Threshold, from the ApplicationProfile table, representing theminimum score for budget and self finance studying and theminimum score needed to pass the entrance examination.

As stated in the Section 4.2, these attributes are transformed tothe foreign keys from the valueID attribute of the FuzzyValue table,that relate them to the fuzzy meta model. Therefore, their actual(possibly fuzzy) values are contained and described in the fuzzymeta model. The Data from the real faculty’s information systemdatabase is removed and new random fuzzy values are generatedfor testing purposes. For example, the Table 4 contains a fewrecords from the Student table. We do not show the citizenID col-umn because we do not want to expose any private information.This column contains 13 digit values.

The values for the column highSchoolGPA are not actual GPAvalues, they are the foreign keys referencing the valueID attributefrom the FuzzyValue table. These values connect our database sub-schema to the fuzzy meta model. For instance, the fuzzy metamodel contains the trapezoidal fuzzy number with the left maxi-mum in 4.55, the right maximum in 4.82 and with the left offsetof 1.02 and the right offset of 0.07, as the value for the second can-didate from the example table, Stevan Vasiljevic.

5.3. Test query results

In this section we use the described example fuzzy database toset three queries used as the examples for the PFSQL syntax in theSection 4.1. We add to that another, more complex query example.

Fig. 5. The example faculty entrance examination database subschema.

70 S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73

For every query we give an illustrative fragment of the obtained re-sult set.

The first query (Listing 6) lists the first and last names ofstudents whose GPA is greater than the given triangular fuzzynumber. The Table 5 shows only a small fragment of the result

set. Clearly, the result set contains an additional column, themembership degree, that takes values from the unit interval andrepresents a fuzzy measure of how much does a tuple belongs tothe result set. The same observation holds for the following twoexamples.

Table 4Example values from the Student table.

appNumber firstName lastName middleName highSchoolGPA termCode

00746 Marko Dobric Veljko 5299 1300747 Stevan Vasiljevic Slobodan 5300 1300748 Milica Atlagic Zdravko 5301 1300749 Jelena Polinger Miša 5302 1300751 Danijela Knezevic Budimir 5304 13

Listing 6. An example of a PFSQL query.

Table 5The results of the first example query.

firstName lastName Membership degree

Jovan Jankovic 0.2458568574212542Jelena Stanojevic 1.0Petar Krstanovic 0.7582541526358542Milica Marinkovic 0.6854785544878444

Listing 7. An example of a PFSQL query.

Table 6The results of the second example query.

First name Last name Membership degree

Jovan Jankovic 0.3854256235214523Jelena Stanojevic 0.6Petar Krstanovic 1Milica Marinkovic 0.5232563247851253

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 71

The previous query can be enriched with additional constraints.The query from the Listing 7 returns names and surnames ofstudents that have the GPA greater than average with the priorityof 0.4, and are born before 1991, with the priority of 0.1. The queryalso contains the threshold clause that limits the results andremoves the tuples with the fuzzy satisfaction degree smaller than0.2. This query is more complex than the corresponding query fromthe Section 4.1, because the attribute that represents date of birthdoes not belong to the Student table. It belongs to the Applicationtable, and therefore, it was necessary to join these two tables.The Table 6 shows a fragment of the result set that contains thesame tuples shown in the Table 5. In this way, we can observe

Listing 8. An example

the changes made to the membership degree caused by the addi-tional constraints.

The Listing 8 shows the most complex query chosen for thetesting purposes. It returns the first and last names of the studentsthat:

� have the high school GPA greater than the given triangularfuzzy number with the priority of 0.9,� whose first name is Milan, with the default priority of 1 and� that have the entrance examination score equals to the given

interval with the priority of 0.6.

Additionally, the threshold of 0.6 for the membership degrees isspecified.

The Table 7 lists a fragment of the result set that the systemreturned.

The last example illustrates the use of the aggregate functionswith fuzzy arguments. The well known aggregate functions MAX,MIN and COUNT can take fuzzy value as an argument, as definedin the PFSQL syntax. The query at the Listing 9 returns the minimalhigh school GPA for all candidates. The high school GPA containsfuzzy values, so the result that the system returned was also fuzzy– a fuzzy interval:

#ið2:109256895095825;3:480854190734863Þ#: ð23Þ

5.4. Performance

Detailed performance analysis of the presented system is out ofthe scope of this paper. Nevertheless, we present some basic obser-vations related to the query execution performance that can serveto get an impression of overall system behaviour.

The test database presented in this section contains informationon approximately 5000 entrance examination candidates. So, mostof the tables presented in Fig. 5 contain approximately 5000records. As a consequence, the central table in the fuzzy metamodel, FuzzyValue, contains exactly 59608 records. For the testingpurposes, we used the MaxDB database management system, ver-sion 7.6. The testing machine was a PC containing the Intel Core i7processor with the 12 GB of RAM running the 64 bit Ubuntu serveroperating system.

Using described environment, the first three presented queries(Listings 6–8) had an execution time below 0.5 s, which resultedin an instantaneous answer. However, the fourth query(Listing 9) includes the complex calculations related to comparisonof approximately 5000 fuzzy values of different types. All these cal-culations are done outside the database, and here we observed adrop in performance. The time needed to process this query was9.78 s.

6. Comparison to the other approaches

If we compare our fuzzy relational data model to the mostadvanced fuzzy relational data model available today – the FIRST-2 [18], we conclude that there are several similarities between

of a PFSQL query.

Table 7The results of the third example query.

First name Last name Membership degree

Milan Amadzic 1.0Milan Brkic 0.9156248444431065Milan Korac 0.9302539889969355Milan Rosic 0.9469450772437487Milan Vujinovic 0.7428571671855702

Listing 9. An example of a PFSQL query.

72 S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73

them. Although the methods for the fuzzy value representation arecompletely different, functionally, our model is a subset of theFIRST-2 model. Our intention was to define the simplest possiblemodel that supports most widely used fuzzy concepts, and storesvalues as effectively as possible without too much overhead.

The fuzzy attributes of the type 1 in the FIRST-2 model are crispvalues that our model also supports. The fuzzy types that our mod-el covers are a subset of those represented by the fuzzy attributestype 2 and 3. Null values, intervals and trapezoidal fuzzy numbersin the FIRST-2 are represented by the structures that have thesesame names. A subset of the set of triangular fuzzy numbers, isos-celes triangle, is represented by the approximate value with theexplicit margin in the FIRST-2 model. All other types of triangularfuzzy numbers, as well as fuzzy quantities can be represented bythe possibility distributions with 2 and with 4 values in theFIRST-2, although these distribution types are more general.

Listing 10. The EBNF syntax

Moreover, the FIRST-2 model describes a wider range of otherpossibilities for the fuzzy values and combines atomic valuesaccording to their respective structure. In this paper we de-scribed the advanced version of our model that treats the fuzzyvalues similarly. Although, functionally, our model is a subsetof the FIRST-2, it gives the theoretical contribution in modellingfrom the aspect of the relational model theory because itconforms to the 3rd normal form. The basic disadvantage ofthe FIRST-2 model is non-conformance even to the 1st normalform.

The fuzzy database query language FSQL is built on top of theFIRST-2 model using the Oracle DBMS and the PL/SQL storedprocedures [18]. Similarly, we used the fuzzy relational data modeldescribed in this paper to build an interpreter for the PFSQLlanguage. We have developed the PFSQL query language fromground up, extending the features of the SQL into the fuzzy do-main. The PFSQL language is an extension of the SQL language thatallows fuzzy logic concepts to be used in queries. Among otherfeatures described in [26,23] in detail, this query language allowsthe priority statements to be specified for the query conditions.For calculating the membership degree of the query tuples whenthe priority is assigned to the conditions, we use the GPFCSPsystems mentioned in the introduction.

Although the FSQL language has more features than the PFSQL, itdoes not allow the usage of priority statements. The PFSQL is thefirst query language that does. Moreover, the PFSQL is implementedusing Java, outside the database, which makes our implementationdatabase independent. On the other hand, in this way, most of thecalculations are done outside the database which yields a drop inperformance comparing to the systems that use the database andits stored procedures to do the calculations.

of the PFSQL language.

S. Škrbic et al. / Knowledge-Based Systems 38 (2013) 62–73 73

Following the stated ideas, we implemented the CASE tool de-scribed here in order to ease the fuzzy relational database schemadevelopment and its usage in the real world applications with thePFSQL using fuzzy JDBC from Java programs. To the best of ourknowledge, this is the first attempt to introduce a solution, anintegrated set of tools, that allows the fuzzy relational databaseapplication development. Indeed, the system described in thispaper is the only one publicly available open source system thatserves this purpose. A working version of our model, the CASE tooland the PFSQL interpreter are available for download from thefollowing web site http://www.is.pmf.uns.ac.rs/fuzzydb.

7. Conclusion

Fuzzy logic and fuzzy set theory have been proven to be thenatural approach to model uncertainty in the relational databases.The most important result of this paper is a set of tools that allowsusage of the priority fuzzy logic mechanisms in the database appli-cation development.

Detailed analysis of possibilities and related attempts to extendthe SQL language using fuzzy set theory concepts has lead to thePFSQL language. This language is the first to allow the queries withthe arbitrary logical expression containing the fuzzy set theoryconstructs and the priorities. The mathematical model needed tocalculate the results of such queries has been formulated in theform of the GPFCSP system that represents a generalisation ofthe already known construct – the PFCSP.

A new model for the fuzzy information storage has been definedas an extension of the relational model using elements of fuzzy settheory. This data model represents the basis for the PFSQL querylanguage interpreter. The CASE tool that enables easy databasedesign based on the introduced model has been constructed.

The idea to encapsulate the process of the query execution in-side a conservative fuzzy extension of the JDBC driver is alsonew. This result allows the database independence. The presentedset of tools supports the idea to specify the complete methodologyfor fuzzy relational database applications development.

The described implementation is tested on the fuzzified data-base segment of the student affairs information system of theFaculty of Science in Novi Sad. This segment is related to the en-trance examination management. It consists of about 30 relationaltables with more than 5000 records in most of them.

In order to offer a more complete solution for the fuzzy rela-tional database application development, it is necessary to enrichthe PFSQL language with more features of a regular SQL, such asthe insert, update and delete statements. In addition, the fuzzyJDBC driver has to be augmented with other interfaces and possi-bilities offered by the JDBC specification. The authors intend tostudy and solve these problems in the future.

Acknowledgement

The work is partially supported by Ministry of Education andScience of the Republic of Serbia, through Project OI174023: ‘‘Intel-ligent techniques and their integration into wide-spectrum decisionsupport’’ and Project OI174009: ‘‘Mathematical models of non-line-arity, uncertainty and decision making’’.

Appendix A. The PFSQL language EBNF grammar

Listing 10.

References

[1] B. Buckles, F. Petry, A fuzzy representation of data for relational databases,Fuzzy Sets and Systems 7 (3) (1982) 213–226.

[2] A. Zvieli, P. Chen, ER modelling and fuzzy databases, in: Proceedings of 2ndInternational Conferernce on Data Engineering, Los Angeles, CA, 1986, pp. 320–327.

[3] O. Bahar, A. Yazici, Normalization and lossless join decomposition ofsimilarity-based fuzzy relational databases, International Journal ofIntelligent Systems 19 (2004) 885–917.

[4] K.V.S.V.N. Raju, A.K. Majumdar, Fuzzy functional dependencies and losslessjoin decomposition of fuzzy relational database systems, ACM Transactions onDatabase Systems 13 (1988) 129–166.

[5] M. Umano, Freedom-0: a fuzzy database system, Fuzzy Information andDecision Processes Edition, North-Holland, Amsterdam, 1982.

[6] J. Kacprzyk, S. Zadrozny, A. Ziolkowski, FQUERY III+: a ‘‘human-consistent’’database querying system based on fuzzy logic with linguistic quantifiers,Information Systems 14 (6) (1989) 443–453.

[7] R. Vandenberghe, A.V. Schooten, R.D. Caluwe, E.E. Kerre, Some practical aspectsof fuzzy database techniques: an example, Information Systems 14 (6) (1989)465–472.

[8] M.H. Wong, K.S. Leung, A fuzzy database-query language, Information Systems15 (1990) 583–590.

[9] Cheng-Hsiung, Weng, Mining fuzzy specific rare itemsets for education data,Knowledge-Based Systems 24 (5) (2011) 697–708.

[10] P. Bosc, O. Pivert, K. Farquhar, Integrating fuzzy queries into an existingdatabase management system: an example, International Journal of IntelligentSystems 9 (5) (1994) 475–492.

[11] P. Bosc, O. Pivert, SQL f: a relational database language for fuzzy querying, IEEETransactions on Fuzzy Systems 3 (1) (1995) 1–17.

[12] J.M. Medina, O. Pons, M.A. Vila, Gefred: a generalised model of fuzzy relationaldatabases, Information Sciences – Informatics and Computer Science 76 (1–2)(1994) 87–109.

[13] J. Galindo, J. Medina, M. Aranda, Querying fuzzy relational databases throughfuzzy domain calculus, International Journal of Intelligent Systems 14 (4)(1999) 375–411.

[14] J. Galindo, J.M. Medina, M.C. Aranda-Garrido, Fuzzy division in fuzzy relationaldatabases: an approach, Fuzzy Sets and Systems 121 (2001). 471-471.

[15] J. Galindo, J. Medina, O. Pons, J. Cubero, A server for fuzzy sql queries, in: T.Andreasen, H. Christiansen, H. Larsen (Eds.), Flexible query answeringsystems, Lecture Notes in Computer Science, vol. 1495, Springer, Berlin/Heidelberg, 1998, pp. 164–174.

[16] E. Kerre, G. Chen, Fuzzy data modelling at a conceptual level: extending ER/EERconcepts, Knowledge Management in Fuzzy Databases Edition, Physica-Verlag,Heidelberg, 2000.

[17] N. Chaudhry, J. Moyne, E. Rundensteiner, A design methodology for databaseswith uncertain data, in: Proceedings of 7th International Working Conferenceon Scientific Statistical Database Management, Charlottesville, VA, 1994, pp.32–41.

[18] J. Galindo, A. Urrutia, M. Piattini, Fuzzy Databases: Modelling Design andImplementation, IDEA Group, Hershey, PA, 2006.

[19] Y. He, Q. Wang, D. Zhou, Extension of the expected value method for multipleattribute decision making with fuzzy data, Knowledge-Based Systems 22 (1)(2009) 63–66.

[20] Q. He, C. Wu, D. Chen, S. Zhao, Fuzzy rough set based attribute reduction forinformation systems with fuzzy decisions, Knowledge-Based Systems 24 (5)(2011) 689–696.

[21] A. Takaci, S. Škrbic, Priority, weight and threshold in fuzzy SQL systems, ActaPolytechnica Hungarica 5 (1) (2008) 59–68.

[22] A. Takaci, S. Škrbic, Data Model of FRDB with Different Data Types and PFSQL,Handbook of research on fuzzy information processing in databases Edition,vol. 1, USA: Information Science Reference, Hershey, PA, 2008, pp. 407–434.

[23] S. Škrbic, M. Rackovic, A. Takaci, Towards the methodology for development offuzzy relational database applications, Computer Science and InformationSystems 8 (1) (2011) 27–40.

[24] X. Luo, J.H. Lee, H. Leung, N.R. Jennings, Prioritised fuzzy constraint satisfactionproblems: axioms, instantiation and validation, Fuzzy Sets and Systems 136(2) (2003) 151–188.

[25] A. Takaci, S. Škrbic, A. Perovic, Generalised prioritised constraint satisfactionproblem, in: Proceedings of 7th Serbian–Hungarian Joint SymposiumIntelligent Systems and Informatics, Subotica, Serbia, 2009, pp. 145–148.

[26] S. Škrbic, M. Rackovic, A. Takaci, The PFSQL query execution process, Novi SadJournal of Mathematics 41 (2) (2011) 161–179.

[27] A. Perovic, A. Takaci, S. Škrbic, Towards the formalization of fuzzy relationaldatabase queries, Acta Polytechnica Hungarica 6 (1) (2009) 185–193.

[28] A. Perovic, A. Takaci, S. Škrbic, Formalizing PFSQL queries using ŁP 12 fuzzy

logic, Mathematical Structures in Computer Science, in press, <doi:10.1017/S0960129511000673>.

[29] D. Dubois, F. Héléne, H. Prade, Possibility theory in constraint satisfactionproblems: handling priority, preference and uncertainty, Applied Intelligence6 (4) (1996) 287–309.

[30] X. Luo, N.R. Jennings, N. Shadbolt, H.F. Leung, J.H. Lee, A fuzzy constraint basedmodel for bilateral, multi-issue negotiations in semi-competitiveenvironments, Artificial Intelligence 148 (1–2) (2003) 53–102.

[31] E. Klement, R. Mesiar, E. Pap, Triangular norms, Trends in Logic, vol. 8, KluwerAcademic Publishers, Dordrecht, 2000.

[32] A. Takaci, Schur-concave triangular norms: characterization and application inPFCSP, Fuzzy Sets and Systems 155 (1) (2005) 50–64.