RDF(S) extraction from fuzzy entity-relationship models

Abstract

RDF (Resource Description Framework) and RDF Schema (RDF(S)) are the normative languages to represent the Web information. Extracting RDF(S) from the existing data sources is becoming an important research issue. However, information imprecision and uncertainty exist in many real-world applications and hence fuzzy data modeling has been extensively investigated in various data models. In particular, fuzzy Entity-Relationship (ER) model has been widely applied to fuzzy data modeling in many application domains. Therefore, how to extract RDF(S) from the existing fuzzy ER models becomes an important issue to be solved. In this paper, we propose a formal approach for extracting RDF(S) from fuzzy ER models and implement a prototype tool. We first give the formal definitions of fuzzy ER models and RDF(S). After that, a formal approach for extracting RDF(S) from fuzzy ER models is proposed. Also, an extraction example is provided. Finally, based on the proposed approach, a prototype extraction tool is implemented, and the experiments show that the approach and the tool are feasible.

Keywords

Fuzzy ER models RDF RDF schema extraction

1 Introduction

The Semantic Web is an extension of the current Web, in which Web resources are given computer-understandable semantics [25]. RDF (Resource Description Framework) and RDF vocabulary description language RDF Schema (RDF(S)) are the W3C recommendation normative language to describe the Web resource information and their semantics [3, 21]. The formal acceptance of RDF(S) by W3C stimulates their utilization in many areas. But most information resources are not available in RDF(S)-format at present. Therefore, how to construct RDF(S) from the existing resources becomes an important issue to be solved in the context of the Semantic Web.

Currently, some approaches have been proposed to extract RDF(S) from some data resources. How to transform XML documents into RDF-format data was investigated in [2 , 18]. Moreover, the approaches for extracting RDF(S) from databases were proposed in [8 , 27]. In addition, the proposal for building RDF from semi-structured legal documents was presented in [6]. The rules of constructing RDF from spreadsheets were proposed in [14].

Among these approaches, constructing RDF(S) by acquiring information from data models has increasingly attracted considerable attention, because much domain information is still modeled by the data models (e.g., ER model). The entity-relationship (ER) model was incepted by P.P. Chen [17] and has played a crucial role in database design and information systems analysis. The ER model, using varying notations and with some semantic variations, is enjoying a remarkable, and increasing, popularity in both the research community, the computer science curriculum, and in industry. In step with the increasing diffusion of relational platforms, ER modeling is growing in popularity [4 , 24]. Therefore, in order to use the information of an ER model in a semantic context, it has to be mapped into RDF(S), the data format of the Semantic Web. In recent years, several proposals are presented to establish the relationships between data models and the data format RDF(S) of the Semantic Web [12 , 26]. A brief discussion of the relationships between RDF Schema and the data model UML (Unified Modeling Language) was made in [19, 26]. Moreover, how to convert RDF Schema into the data models ER and UML were briefly discussed in [12, 15], but their aims are in contrast to ours, and in this paper we aim at extracting RDF(S) from fuzzy datamodels.

In real-world applications, information is often vague or ambiguous. It is especially true in the data intensive areas, such as information systems and databases [7]. For modeling the fuzziness in real-world applications, the fuzzy set theory [13] was originally applied to some of the basic ER concepts in [1]. Accordingly, lots of efforts have been made to extend the ER model with fuzzy features [9 , 23] (see [30] for a survey). To the best of our knowledge, so far, there are no comprehensive reports on extraction of RDF(S) from fuzzy ER models.

Based on the observations above, this paper proposes a formal approach for extracting RDF(S) from fuzzy ER models and implements a prototype tool. The paper makes the following main contributions:

Proposing a formal approach (i.e., some extraction rules) for extracting RDF(S) from fuzzy ER models;

Providing an extraction example, and making a discussion about the approach;

Implementing a prototype tool, the extraction algorithm is given and some experiments are done. The results show that the approach and the tool are feasible.

The remainder of this paper is organized as follows. Section 2 recalls formal definitions of fuzzy ER models and RDF(S). Section 3 proposes an approach for extracting RDF(S) from fuzzy ER models, provides an example, and makes a discussion about the approach. Section 4 implements a prototype tool. Section 5 shows conclusions and futurework.

2 Formalizations of RDF(S) and fuzzy ER models

In this section, we recall formal definitions of RDF(S) and fuzzy ER models, which will help to well establish correspondences between them.

2.1 Formal definition of RDF(S)

Resource Description Framework (RDF) [21] is a framework for expressing the Web resource information. The basic idea of RDF is: anything is called “ resource ”, which can be a class, an attribute or an individual. A resource may have some “ properties ”, and these properties may have “ values ”. The relationships among the resources, the properties and the values can be described by “statements”, which always have the following triple structure: < subject predicate object >.

Further, the RDF Vocabulary Description Language—RDF Schema, uses the notion of “ class ” to specify categories that can be used to classify resources. The relation between an instance and its class is stated through the “ type ” property. With RDF Schema one can create hierarchies of classes and “ sub-classes ” and of properties and “ sub-properties ”. Type restrictions on the subjects and objects of particular triples can be defined through “ domain ” and “ range ” restrictions. RDF and RDF Schema are collectively called RDF(S). The detailed introductions about RDF(S) can be found in [21]. In the following, we recall a formal definition of RDF(S) [19].

Definition 1. (RDF(S)) A set of RDF(S) data $R$ can be represented as $R = (R_{S}, R_{T})$ , where:

$R_{S} = C \cup P \cup D \cup I$ is a set of identifiers partitioned into a set $C$ of class identifiers, a set $P$ of property identifiers, a set $D$ of datatype identifiers, and a set $I$ of individual identifiers;

$R_{T}$ is a set of triples defined over the set of identifiers $R_{S}$ .

2.2 Formal definition of fuzzy ER models

Zvieli and Chen [1] first applied the fuzzy set theory to some of the basic ER concepts, in which fuzzy entities, fuzzy relationships and fuzzy attributes were introduced to fuzziness in entity and relationship occurrences and in attribute values. In the following, we recall a fragment of the formal definition of fuzzy ER models. Here we first define a function as follows: for two finite sets X and Y, we call a function from a subset of X to Y an X-labeled tuple over Y. The labeled tuple T that maps x_i ∈ X to y_i ∈ Y (i ∈ {1, …, k}) is denoted by [x₁ : y₁, …, x_k : y_k], and we also write T [x_i] to denote y_i [17].

Definition 2. (Fuzzy ER models) A fuzzy ER model can be defined as a tuple ɛ = (L_S, ≤ _S, att_E, att_R, rel_S), where L_S is a set of symbols; ≤_S is a binary relation denoting the inheritance relations (i.e., ISA) between two fuzzy entities; att_S is a function that associates each fuzzy entity to its corresponding attributes; att_R is a function that associates each fuzzy relationship to its corresponding attributes; rel_S is a function that associates each fuzzy relationship to its participation fuzzy entities:

L_S = E_S ∪ A_S ∪ U_S ∪ R_S ∪ D_S is a finite alphabet, where E_S is a set of fuzzy entity symbols; A_S is a set of fuzzy attribute symbols; U_S is a set of role symbols; R_S is a set of fuzzy relationship symbols; and D_S is a set of domain symbols;

≤_S ⊆ E_S × E_S, which is a binary relation over E_S, denotes the inheritance relation (i.e., ISA) between two fuzzy entities;

att_E: E_S → T (A_S, D_S) is a function that maps each fuzzy entity symbol in E_S to an A_S-labeled tuple over D_S;

att_R: R_S → T (A_S, D_S) is a function that maps each fuzzy relationship symbol in R_S to an A_S-labeled tuple over D_S;

rel_S: R_S → T (U_S, E_S) is a function that maps each fuzzy relationship symbol in R_S to a U_S-labeled tuple over E_S. Without loss of generality, we assume that: Each role is specific to exactly one relationship; For each role U ∈ U_S, there is a fuzzy relationship R and a fuzzy entity E such that rel_S (R) = [… , U : E, …].

3 Extracting RDF(S) from fuzzy ER models

On the basis of the formalizations of RDF(S) and fuzzy ER models in Section 2, in this section, we propose a formal approach for extracting RDF(S) from fuzzy ER models. Also, we provide an example, and make a discussion about the approach.

3.1 Extraction approach

By comparing and analyzing the characteristics of fuzzy ER models and RDF(S), here we first briefly summarizes the correspondences between them for providing readers of an initial understanding of the process. In general, the fuzzy entities and attributes in a fuzzy ER model can be directly represented by the rdfs:Class and rdf:Property in RDF(S); the roles in a fuzzy ER model correspond to the rdf:Property in RDF(S), and thus the fuzzy relationships in a fuzzy ER model has to be transformed into rdfs:Class of RDF(S); the inheritance relation between two fuzzy entities in a fuzzy ER model can be represented by the rdfs:subClassOf in RDF(S); and several functions in a fuzzy ER model can be represented by the formal definition of RDF(S).

In the following we propose several rules of extracting RDF(S) from fuzzy ER models. Let ɛ = (L_S, ≤ _S, att_E, att_R, rel_S) be a fuzzy ER model, the corresponding RDF(S) $R = φ (ɛ) = (R_{S}, R_{T})$ can be extracted as the following rules:

Rule 1 (Extraction of fuzzy entities): For each fuzzy entity symbol E ∈ E_S ∈ L_S in the fuzzy ER model ɛ, creating a RDF(S) class:

$< rdfs : Class rdf : ID = “ φ (E) ” / > .$

Rule 2 (Extraction of attributes): For each attribute symbol A ∈ A_S ∈ L_S in the fuzzy ER model ɛ, creating a RDF(S) property:

$< rdf : Property rdf : ID = “ φ (A) ” / > .$

Comments: In a fuzzy ER model, an instance may belong to a fuzzy entity with a degree of [0, 1]. A special attribute u ∈ [0, 1] is introduced into a fuzzy entity to represent the membership degree of an instance to the fuzzy entity. In this case, the special attribute u is represented by a RDF(S) property φ (u) as shown in Rule 2.

Rule 3 (Extraction of datatypes): For each datatype symbol D ∈ D_S ∈ L_S in the fuzzy ER model ɛ, creating a RDF(S) datatype φ (D). It should be noted that RDF(S) uses the XML Schema datatypes [28]. For example, the datatypes string and float in a fuzzy ER model can be represented by RDF(S) datatypes xsd: string and xsd: float, respectively.

Rule 4 (Extraction of roles): For each role symbol U ∈ U_S ∈ L_S in the fuzzy ER model ɛ, creating a RDF(S) property:

$< rdf : Property rdf : ID = “ φ (U) ” / > .$

Rule 5 (Extraction of fuzzy relationships): For each fuzzy relationship symbol R ∈ R_S ∈ L_S in the fuzzy ER model ɛ, creating a RDF(S) class: $< rdfs : Class rdf : ID = “ φ (R) ” / > .$

Rule 6 (Extraction of attributes of fuzzy entities): For the function of attributes of fuzzy entities att_E: E_S → T (A_S, D_S), i.e., for each fuzzy entity E ∈ E_S with att_E (E) = [… , A : D, …] in the fuzzy ER model ɛ, where A ∈ A_S and D ∈ D_S, creating a RDF(S) triple statement, which is used to restrict the domain and range of the attribute A as shown in the following: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (E) ” / > \\ < rdf : Property rdf : ID = “ φ (A) ” > \\ < rdfs : domain rdf : resource = “ # φ (E) ” / > \\ < rdfs : range rdf : resource = “ φ (D) ” / > \\ < / rdf : Property > \end{matrix}$

The triple statement represents the domain of the RDF(S) attribute φ(A) is φ(E), and its range is φ(D).

For example, given a fuzzy entity YoungPerson ∈ E_S with attributes att_E(YoungPerson) = [Name: string, FUZZYAge: integer, u: real] in a fuzzy ER model, the following RDF(S) class, properties, and triple statements will be created as the above rules 1–3 and 6: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (YoungPerson) ” / > \\ < rdf : Property rdf : ID = “ φ (Name) ” > \\ < rdfs : domain rdf : resource = “ # φ (YoungPerson) ” / > \\ < rdfs : range rdf : resource = “ & xsd : string ” / > \\ < / rdf : Property > \\ < rdf : Property rdf : ID = “ φ (FUZZYAge) ” > \\ < rdfs : domain rdf : resource = “ # φ (Person) ” / > \\ < rdfs : range rdf : resource = “ & xsd : integer ” / > \\ < / rdf : Property > \\ < rdf : Property rdf : ID = “ φ (u) ” > \\ < rdfs : domain rdf : resource = “ # φ (YoungPerson) ” / > \\ < rdfs : range rdf : resource = “ & xsd : real ” / > \\ < / rdf : Property > \end{matrix}$

Rule 7 (Extraction of attributes of fuzzy relationships): For the function of attributes of fuzzy relationships att_R: R_S → T (A_S, D_S), i.e., for each fuzzy relationship R ∈ R_S with att_R (R) = [… , A : D, …] in the fuzzy ER model ɛ, where A ∈ A_S and D ∈ D_S, creating a RDF(S) triple statement, which is used to restrict the domain of the RDF(S) attribute φ (A) is φ (R), and its range is φ (D) as shown in the following RDF(S) triple statement: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (R) ” / > \\ < rdf : Property rdf : ID = “ φ (A) ” > \\ < rdfs : domain rdf : resource = “ # φ (R) ” / > \\ < rdfs : range rdf : resource = “ φ (D) ” / > \\ < / rdf : Property > \\ < rdf : Property rdf : ID = “ φ (β) ” > \\ < rdfs : domain rdf : resource = “ # φ (R) ” / > \\ < rdfs : range rdf : resource = “ & xsd : real ” / > \\ < / rdf : Property > \end{matrix}$

Comments: In a fuzzy ER model, a relationship among entities may be fuzzy. A special symbol β ∈ [0, 1] is introduced into a fuzzy relationship to denote the membership degree of the fuzzy relationship occurring in several entities. In this case, the special symbol β is considered as an attribute of the fuzzy relationship and thus is represented by a RDF(S) property φ (β) as shown in Rule 7.

Rule 8 (Extraction of functions of fuzzy relationships): For the function of fuzzy relationships R_S → T (U_S, E_S), i.e., for each fuzzy relationship R ∈ R_S with rel_S (R) = [… , U : E, …] in the fuzzy ER model ɛ, where U ∈ U_S and E ∈ E_S, creating a RDF(S) triple statement: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (R) ” / > \\ < rdfs : Class rdf : ID = “ φ (E) ” / > \\ < rdf : Property rdf : ID = “ φ (U) ” > \\ < rdfs : domain rdf : resource = “ # φ (R) ” / > \\ < rdfs : range rdf : resource = “ # φ (E) ” / > \\ < / rdf : Property > \end{matrix}$

For example, given a relationship rel_S(Teach)= [tea: Lecturer, tea_by: Course], the following RDF(S) classes, properties, and triple statements will be created as the above rules 1, 4, 5, and 8: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (Lecturer) ” / > \\ < rdfs : Class rdf : ID = “ φ (Course) ” / > \\ < rdfs : Class rdf : ID = “ φ (Teach) ” / > \\ < rdf : Property rdf : ID = “ φ (tea) ” > \\ < rdfs : domain rdf : resource = “ # φ (Teach) ” / > \\ < rdfs : range rdf : resource = “ # φ (Lecturer) ” / > \\ < / rdf : Property > \\ < rdf : Property rdf : ID = “ φ (tea_by) ” > \\ < rdfs : domain rdf : resource = “ # φ (Teach) ” / > \\ < rdfs : range rdf : resource = “ # φ (Course) ” / > \\ < / rdf : Property > \end{matrix}$

Rule 9 (Extraction of inheritance): For each inheritance relation (i.e., ISA) between two fuzzy entities E₁ ≤ _SE₂ in the fuzzy ER model ɛ, creating a RDF(S) triple statement as follows: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (E_{2}) ” > \\ < rdfs : Class rdf : ID = “ φ (E_{1}) ” > \\ < rdfs : subClassOf rdf : rescource = “ # φ (E_{2}) ” / > \\ < / rdfs : Class > \end{matrix}$

For example, given an ISA relation Postgraduate_Student ≤_SStudent, as the rules 1 and 9, the following RDF(S) classes and triple statement will be created: $\begin{matrix} < rdfs : Class rdf : ID = “ φ (Student) ” / > \\ < rdfs : Class rdf : ID = “ φ (Undergraduate_Student) ” > \\ < rdfs : subClassOf rdf : rescource = “ # φ (Student) ” / > \\ < / rdfs : Class > \end{matrix}$

Rule 10 (Extraction of instances): For each instance o belonging to a fuzzy entity E in the fuzzy ER model ɛ with a membership degree of u, creating a RDF(S) triple statement as follows: $\begin{matrix} < rdf : Description rdf : ID = “ φ (o) ” > \\ < rdf : type rdf : resource = “ # φ (E) ” / > \\ < φ (u) > u < / φ (u) > \\ < / rdf : Description > \end{matrix}$

In order to well explain the above rules from fuzzy ER models to RDF(S), the following section will further provide an example.

3.2 An extraction example

In the following we provide an extraction example to well explain the rules proposed in Section 3.1. Figure 1 shows a fuzzy ER model E₁ and a part of instance information with respect to the fuzzy ER model.

Fig.1

A fuzzy ER model ɛ₁ and a part of instance information.

By applying the rules in Section 3.1 to the fuzzy ER model ɛ₁ in Figs. 1, 2 shows the extracted RDF(S) from ɛ₁, where the URLs of the RDF(S) resources are omitted.

Fig.2

The RDF(S) $R = φ (ɛ_{1})$ extracted from the fuzzy ER model ɛ₁ and its instance information in Fig. 1.

3.3 A brief discussion

It is shown that the model of Fig. 1 in Section 3.2 basically includes the main elements of a common fuzzy ER model. Further, Fig. 2 shows that the fuzzy ER model can be transformed into RDF(S), and it can also be found from Fig. 2 that the extracted RDF(S) can represent the entities, properties, relationships, and constraints in a fuzzy ER model. All of these show that the approach for extracting RDF(S) from fuzzy ER models is feasible.

Moreover, it should be noted that since the limitation of the expression of RDF(S), some enhanced features of the basic fuzzy ER model (e.g., the generalization hierarchies or the cardinality constraints) cannot be directly represented as RDF(S) in the extraction process:

The only direct relationship between entities that can be expressed in the basic fuzzy ER Model is the ISA relation as discussed in our work. A common extension is the arbitrary boolean constructs on entities, so called generalization hierarchies (similarly for [22]), which allow one to express that the extension of a fuzzy entity should be the disjoint union of the extensions of other fuzzy entities. As we have known, RDF(S) cannot represent such disjoint constraint. Such enhanced features may be represented by the further extension language of RDF(S) (e.g., the ontology language OWL [10, 29]).

An optional cardinality constraint (m, n) can be enforced on a fuzzy relationship and is used to specify that each instance of the fuzzy entity can participate at least m times and at most n times to the fuzzy relationship. Since RDF(S) cannot represent the cardinality constraint, when extracting RDF(S) from fuzzy ER models, the cardinality constraint cannot be represented by RDF(S) directly. Such cardinality constraint can only be represented by the further extension language of RDF(S).

Until now, the approach proposed in the previous sections can extract RDF(S) from fuzzy ER models, and the main features of the basic fuzzy ER models and the instance information can be represented by RDF(S), the data format of the Semantic Web. Furthermore, in order to implement the automated extraction, in the following section we will develop a prototype tool.

4 Prototype extraction tool

In this section, as a proof-of-concept for the proposed approach in the previous sections, we developed a prototype tool called FER2RDF, which can extract RDF(S) from fuzzy ER models.

In the following we briefly introduce the design and implementation of the prototype tool FER2RDF. The core of FER2RDF is that it can first read in a fuzzy ER model of the XML-coded file, and then extract RDF(S) from the fuzzy ER model. The implementation of FER2RDF is based on Java 2 JDK 1.6 platform, and the Graphical User Interface (GUI) is exploited by using the java.awt and javax.swing packages. The overall architecture of FER2RDF is briefly shown in Fig. 3.

Fig.3

Module structure graph of FER2RDF.

It is shown from Fig. 3 that FER2RDF includes four main modules, i.e., input module, parse module, extraction module, and output module:

The input module first read in a fuzzy ER model (the XML-coded file of the model produced from the CASE tool);

The parse module further parses the input file and stores the parsed information as Java ArrayList classes. The features of the fuzzy ER model in the XML-coded file (such as fuzzy entities, attributes, fuzzy relationships, inheritance, and some constraints as mentioned in Definition 2) can be parsed;

The extraction module transforms the parsed results of the fuzzy ER model into RDF(S) according to the following algorithm Extract_FER2RDF as shown in Table 1, which is given based on the proposed approach in Section 3. The algorithm briefly describes the extraction process from fuzzy ER models to RDF(S), and does not contain the detailed extraction steps that have been shown in the proposed approach in Section 3. In brief, the algorithm performs two kinds of operations, i.e., the extraction from fuzzy ER symbols to RDF(S) resource identifies and the extraction from the fuzzy ER constraints (e.g., the inheritance relation and several functions as mentioned in Definition 2) to RDF(S) triples. The time complexity of the algorithm will be briefly analyzed in the following;

The output module finally produces the resulting RDF(S) which is saved as a text file and displayed on the tool screen.

Table 1

The algorithm Extract_FER2RDF

Algorithm Extract_FER2RDF
Input: A fuzzy ER model ɛ = (L_S, ≤ _S, att_E, att_R, rel_S).
Output: The RDF(S) $R = φ (ɛ) = (R_{S}, R_{T})$ extracted from the fuzzy ER model ɛ by the function φ mentioned in Section 3.
1. The extraction from fuzzy ER symbols L_S to RDF(S) resource identifiers R_S = φ (L_S):
–For each fuzzy ER entity symbol E ∈ E_S ∈ L_S, creating a RDF(S) class identifier φ (E);
–For each attribute symbol A ∈ A_S ∈ L_S (including the special attributes u and β), creating a RDF(S) property identifier φ (A);
–For each datatype domain symbol D ∈ D_S ∈ L_S, creating a RDF(S) datatype identifier φ (D);
–For each fuzzy ER relationship symbol R ∈ R_S ∈ L_S, creating a RDF(S) class identifier φ (R);
–For each role symbol U ∈ U_S ∈ L_S, creating a RDF(S) property identifier φ (U);
–For each instance o with respect to the fuzzy ER model, creating a RDF(S) individual identifier φ (o);
2. The extraction from fuzzy ER constraints to RDF(S) triples $R_{T} = φ (\leq_{S}, {att}_{E}, {att}_{R}, {rel}_{S})$ :
–For each function of attributes of fuzzy entities att_E, creating the corresponding RDF(S) triples as rule 6 in Section 3.1;
–For each function of attributes of fuzzy relationships att_R, creating the corresponding RDF(S) triples as rule 7 in Section 3.1;
–For each function of fuzzy relationships rel_S, creating the corresponding RDF(S) triples as rule 8 in Section 3.1;
–For each inheritance relation ≤_S, creating the corresponding RDF(S) triples as rule 9 in Section 3.1;
–For each instance information, creating the corresponding RDF(S) triples as rule 10 in Section 3.1.

Here we briefly analyze the time complexity of algorithm Extract_FER2RDF. Since the extraction from fuzzy ER symbols to RDF(S) resource identifiers (i.e., Step 1 of the algorithm) can be simultaneously made as sub-operations in creating RDF(S) triples (i.e., Step 2 of the algorithm), we can ignore the amount of work done in the first step and consider only the creation of triples in the second step. Also, we only consider the extraction operations and ignore the preprocessing operations (i.e., the parsing of the XML-coded file of the fuzzy ER model), that is, we exclude the amount of work done by an XML parser (e.g., the DOM API for Java in our implementation) that parses the fuzzy ER model (i.e., an XMI-coded file) and prepares the element data in computer memory for the usage in the extraction procedure of the algorithm. Moreover, here we also only consider the fuzzy ER model and ignore the instance information. In this case, the time complexity of the algorithm mainly depends on the structure of fuzzy ER model. Suppose the scale of fuzzy ER model is $N = N_{FE} + N_{FE} + N_{FR} + N_{FL} + N_{FD} + N_{FISA}$ , where $N_{FE}, N_{FA}, N_{FR}, N_{FL}, N_{FD}$ , and $N_{FISA}$ denotes the cardinality of the sets of fuzzy entities, attributes, relationships, roles, datatype domains, and ISA relations, respectively. Then, the creating times of the corresponding RDF(S) triples of the case att_E are $N_{FE} + N_{FA} + N_{FD}$ at most, the case att_R are $N_{FR} + N_{FA} + N_{FD}$ at most, the case rel_S are $N_{FR} + N_{FL} + N_{FE} - 1$ , and the case ≤_S are $N_{FE} + N_{FISA} - 1$ at most. Therefore, in worst case, the total running times $T = 3 N_{FE} + 2 N_{FA} + 2 N_{FD} + 2 N_{FR} + 2 N_{FL} + N_{FISA} - 2 < 3 N - 2$ , that is, the time complexity of the algorithm is only $O (N)$ at most.

We carried out extraction experiments of some fuzzy ER models using the tool, with a PC (CPU P4/3.0 GHz, RAM 3.0 GB and Windows XP system). Some of these fuzzy ER models are designed by the CASE tool by ourselves, and some are from the existing work. Case studies show that our approach proposed in Section 3 is feasible and the FER2RDF tool is efficient.

In the following we provide a running example of FER2RDF. Figure 4 shows the screen snapshot of the tool running one of case studies, which displays the extraction of RDF(S) from the fuzzy ER model ɛ₁ in Section 3.2. In Fig. 4, the XML-coded fuzzy ER model file, the parsed results, and the extracted RDF(S) are displayed in the left, middle and right areas, respectively. The extracted results show that the proposed approach is feasible.

Fig.4

Screen snapshot of the tool FER2RDF.

5 Conclusion and discussions

In this paper, we proposed an approach and implemented a prototype tool for extracting RDF(S) from fuzzy ER models. After recalling the formal definitions of RDF(S) and fuzzy ER models, we proposed a formal extraction approach from fuzzy ER models to RDF(S), and provided the detailed rules. Then, an extraction example was given, and the discussions about the approach were done briefly. Finally, based on the proposed approach, we implemented a prototype tool, and the experiments show that the approach and the tool are feasible. Our work in this paper may act as a gap-bridge between the existing fuzzy ER modeling applications and the Semantic Web.

As far as future work, we may further discuss the extraction of RDF(S) from the enhanced fuzzy ER models (e.g., fuzzy EER models and fuzzy UML models), and some more expressive modeling features will be considered. Moreover, we also intend to enhance the prototype tool and make more large-scale test.

Footnotes

Acknowledgments

The work is supported by the Natural Science Foundation of Liaoning Province (No.2015020048), Fundamental Research Funds for the Central Universities (N151704001) and National Natural Science Foundation of China (61672139).

References

Zvieli

and Chen

P.P.

, Entity-relationship modeling and fuzzy databases, Proceedings of the 1986 IEEE International Conference on Data Engineering, 1986, pp. 320–327.

Kumar

B.H.

and Babu

M.S.P.

, Study and Constructing RDF model for a well formatted Valid XML document, International Journal on Computer Science and Engineering5(7) (2013), 648–652.

, You

and Du

Y.H.

, LAV path planning by enhanced fireworks algorithm on prior knowledge, Applied Mathematics and Nonlinear Sciences1(1) (2016), 65–78.

Houy

, Fettke

and Loos

, Understanding understandability of conceptual models-what are we actually talking about, Proceedings of the 31st Int Conference on Conceptual Modeling (ER 2012), 2012, pp. 64–77.

Partridge

, Gonzalez-Perez

and Henderson-Sellers

, Are conceptual models concept models?Proceedings of the 32nd Int. Conference on Conceptual Modeling (ER 2013), 2013, pp. 96–105.

Amato

, Mazzeo

, Penta

and Picariello

, Building RDF ontologies from semi-structured legal documents, Proceedings of Int Conference on Complex, Intelligent and Software Intensive Systems (CISIS 2008), 2008, pp. 997–1002.

Petry

F.E.

, Fuzzy Databases: Principles and Applications, Kluwer Academic Publishers, Boston, 1996.

Michel

, Montagnat

and Faron Zucker

, A survey of RDB to RDF translation approaches and tools, Report (2013), 1–24.

Chen

G.Q.

and Kerre

E.E.

, Extending ER/EER concepts towards fuzzy conceptual data modeling, Proceedings of the 1998 IEEE International Conference on Fuzzy Systems, 1998, pp. 1320–1325.

10.

Horrocks

, Patel-Schneider

P.F.

and Van Harmelen

, From SHIQ and RDF to OWL: The making of a web ontology language, Web Semantics: Science, Services and Agents on the World Wide Web1(1) (2003), 7–26.

11.

Sequeda

J.F.

, Arenas

and Miranker

D.P.

, On directly mapping relational databases to RDF and OWL, Proceedings of the 21st World Wide Web Conference (WWW 2012), 2012, pp. 649–658.

12.

Kim

J.S.

, Yoo

C.S.

, Lee

M.K.

and Kim

Y.S.

, Object modeling of RDF schema for converting UML class diagram, Proceedings of Int. Conference on Computational Science and Its Applications (ICCSA 2005), 2005, pp. 31–41.

13.

Zadeh

L.A.

, Fuzzy sets, Information and Control8(3) (1965), 338–353.

14.

Han

, Finin

T.W.

, Parr

C.S.

, Sachs

and Joshi

, RDF123: From spreadsheets to RDF, Proceedings of the 7th Int Semantic Web Conference (ISWC 2008), 2008, pp. 451–466.

15.

L.L.

, Lee

S.W.

and Kim

, E-R Model based RDF data storage in RDB, Proceedings of the 3rd IEEE Int Conference on Computer Science and Information Technology, 2010, pp. 258–262.

16.

Krishna

, Retaining semantics in relational databases by mapping them to RDF, Proceedings of the 2006 IEEE/WIC/ACM International Conference on Web Intelligence and Intelligent Agent Technology, 2006, pp. 303–306.

17.

Chen

P.P.

, The entity-relationship model: Toward a unified view of data, ACM Transactions on Database Systems1(1) (1976), 9–36.

18.

Thuy

P.T.T.

, Lee

Y.K.

, Lee

and Jeong

B.S.

, Transforming valid XML documents into RDF via RDF schema, Proceedings of Int Conference on Next Generation Web Services Practices (NWESP 2007), 2007.

19.

Tong

, Zhang

and Cheng

J.W.

, Construction of RDF(S) from UML class diagrams, Journal of Computing & Information Technology22(4) (2014), 237–250.

20.

Bouaziz

, Chakhar

, Mousseau

, Ram

and Telmoudi

, Database design and querying within the fuzzy semantic model, Information Sciences177(21) (2007), 4598–4620.

21.

RDF 1.1 Primer, W3C Working Group, 2014, http://www.w3.org/TR/2014/NOTE-rdf11-primer-20140225/

22.

Do Nascimento Fidalgo

, Souza

E.M.D.

, España

, de Castro

J.B.

and Pastor

, EERMM: A metamodel for the enhanced entity-relationship model, Proceedings of the 31st Int Conference on Conceptual Modeling (ER 2012), 2012, pp. 515–524.

23.

Vandenberghe

R.M.

, An extended entity-relationship model for fuzzy databases based on fuzzy truth values, Proceedings of the 4th International Fuzzy Systems Association World Congress, 1991, pp. 280–283.

24.

Ceri

, Navathe

S.B.

and Batini

, Conceptual Database Design. An Entity-Relationship Approach, The Benjamin/Cummings Publishing Company, 1992.

25.

Berners-Lee

, Hendler

and Lassila

, The semantic web, The Scientific American284(5) (2001), 34–43.

26.

Chang

W.W.

, A Discussion of the Relationship Between RDF-Schema and UML. A W3C Note, NOTE-rdf-uml-19980804, http://www.w3.org/TR/NOTE-rdf-uml/

27.

Mallede

W.Y.

, Marir

and Vassilev

V.T.

, Algorithms for mapping RDB schema to RDF for facilitating access to deep web, Proceedings of the 1st Int Conference on Building and Exploring Web Based Environments (WEB 2013), 2013, pp. 32–41.

28.

XML Schema Part 2: Datatypes Second Edition, http://www.w3.org/TR/xmlschema-2/

29.

Gao

, Farahani

M.R.

and Gao

, Ontology optimization tactics via distance calculating, Applied Mathematics and Nonlinear Sciences1(1) (2016), 159–174.

30.

Z.M.

and Yan

, A literature overview of fuzzy database models, Journal of Information Science and Engineering24(1) (2008), 189–202.