Current proposals for designing information systems lack the mechanisms to define statistical functions at the conceptual level. Therefore, queries containing these kind of functions are defined once the rest of the system has already been implemented, which requires much effort and expertise. In this sense, the goal of this paper is to show the benefits of extending the Object Constraint Language (OCL) with a predefined set of statistical functions.
Queries containing statistical functions are highly important for users to satisfy
their information needs in a comprehensive manner [
The main restriction for defining queries at the conceptual level is the rather
limited support offered by current conceptual modeling languages. Surprisingly,
essential statistical functions are not predefined in these languages: OCL [
It is then clear that a better support for statistical functions is necessary to
easily express complex queries as part of the definition of a conceptual schema,
thus avoiding the error-prone and time-consuming task of defining them once
the system is implemented. To this aim, we propose to extend the standard
OCL library with a new set of statistical functions that designers can use when
defining queries at the conceptual level. These new functions have been tested
on sample data by using one of the well-known case studies from Kimball’s
book [
The case study has been implemented in the USE tool [
Conceptual modeling languages require the use of a general-purpose (textual)
sublanguage to express all kinds of queries, constraints and derivation rules since
most of them cannot be expressed using only the graphical constructs provided
by the conceptual modeling language [
OCL is a rich language that offers predefined mechanisms for retrieving the values of the attributes of an object, for navigating through a set of related objects, for iterating through collection of objects (e.g., by means of the forAll, exist and select iterators) and so forth. As part of the language, a standard library including a predefined set of types and a list of predefined operations that can be applied on those types is also provided. The types can be primitive (Integer, Real, Boolean and String ) or collection types (Set, Bag, OrderedSet and Sequence). Some examples of operations provided for those types are: and, or, not (Boolean), +, −, ∗, >, < (Real and Integer), union, size, includes, count and sum (Set).
All these constructs can be used in the definition of OCL constraints, derivation rules, queries and pre/post-conditions. In particular, definition of queries follows the template: context Class::Q(p1:T1, . . . , pn:Tn): Tresult body: Query-ocl-expression
where the query Q returns the result of evaluating the Query−ocl−expression by using the arguments passed as parameters in its invocation on an object of the context type Class. Apart from the parameters p1 . . . pn, in query-ocl-expression designers may use the implicit parameter self (of type Class) representing the object on which the operation has been invoked.
As an example, the previous query total miles earned by a frequent flyer in his/her trips from Colorado in a given fare can be defined as follows: context Customer::sumMiles(FareClass fc) body: self.frequentFlyerLegs−>select(f | f.fareClass=fc and
f.origin.city.name=’Colorado’)−>sum()
Unfortunately, many other interesting queries cannot be similarly defined
since the operators required to define such queries are not part of the standard
library. Next, we present our extension to the OCL standard library to include
new statistical operators. The set of statistical functions included in our study are
those among the most used in data analysis4. These functions can be classified
in three different groups, following [
Distributive functions can be defined by structural recursion, i.e. the input collection can be partitioned into subcollections that can be individually aggregated and combined. One example is the max function, which returns the element in a non-empty collection of objects of type T with the highest value. T must support the >= operation. If several elements share the highest value, one of them is randomly selected. context Collection::max():T pre: self −>notEmpty() post: result = self −>any(e | self −>forAll(e2 | e >= e2)) 2.3
Algebraic functions are expressed as finite algebraic expressions over distributive functions, e.g., average is computed by using count and sum functions. The average function returns the arithmetic average value of the elements in the non-empty collection. The type of the elements in the collection must support the + and / operations. Holistic functions are all other functions that are not distributive nor algebraic. For example, the mode function, which returns the most frequent value in a collection. 4 Due to space constraints, we only mention some examples in this paper, but all the defined statistical functions are available in http://www.lucentia.es/research/ ocllib.html context Collection::mode(): T pre: self −>notEmpty() post: result = self −>any(e | self −>forAll(e2 |
self−>count(e) >= self−>count(e2)) 2.5
These statistical operations can be used exactly in the same way as any other OCL function. As an example, we show the use of the avg function to compute the average number of miles earned by a customer in each flight leg. context Customer::avgMilesPerFlightLeg():Real body: self−>frequentFlyerLegs.Miles−>avg()
In the foreground of Fig. 1 we show one of the queries we have used to test our functions in the USE tool (in this case the query is used to check our avg function) together with the resulting collection of data returned by the query. Interested readers can download5 the scripts and data of our running example together with the definition of our library of statistical functions. 3
Support for defining complex queries is very limited in conceptual modeling languages and would hinder designers to directly implement these kind of queries, preventing them from easily satisfying the user requirements. Specifically, queries containing statistical functions cannot be easily defined in OCL since they are not part of the standard library and thus, they must be manually defined by the designer which is an error-prone and time-consuming activity (due to the complexity of some statistical functions).
To solve this problem we argue in this paper that the OCL Standard Library should be extended by predefining a list of new statistical functions that can be used by designers in the definition of their OCL expressions.
Our short term future work is to grow the number of predefined functions in our library and align them with current Model-Driven Development (MDD) and Model-Driven Architecture (MDA) approaches, where the implementation of the system is supposed to be (semi)automatically generated from its highlevel models. The definition of all queries at the conceptual level permits a more complete code-generation phase, including the automatic translation of these queries from their initial platform-independent definition to the final (platformdependent) implementation. 5 http://www.lucentia.es/research/ocllib.html
Work supported by the projects: TIN2008-00444, ESPIA (TIN2007-67078) from the Spanish Ministry of Education and Science (MEC), QUASIMODO (PAC080157-0668) from the Castilla-La Mancha Ministry of Education and Science (Spain), and DEMETER (GVPRE/2008/063) from the Valencia Government (Spain). Jose-Norberto Maz´on and Jesu´s Pardillo are funded by MEC under FPU grants AP2005-1360 and AP2006-00332, respectively. Jordi Cabot is funded by the 2007 BP-A 00128 grant (Catalan Government).