Manipulating Spatial Data in Constraint. Abstract. Constraint databases have recently been proposed as a powerful

Transcription

1 Manipulating Spatial Data in Constraint Databases Alberto Belussi 1 Elisa Bertino 2 Barbara Catania 2 1 Dipartimento di Elettronica e Informazione Politecnico di Milano Piazza L. da Vinci Milano, Italy belussi@elet.polimi.it 2 Dipartimento di Scienze dell'informazione Universita degli Studi di Milano Via Comelico 39/ Milano, Italy fbertino,cataniag@dsi.unimi.it Abstract. Constraint databases have recently been proposed as a powerful framework to model and retrieve spatial data. In a constraint database, a spatial object is represented as a quantier free conjunction of (usually linear) constraints, called generalized tuple. The set of solutions of such quantier free formula represents the set of points belonging to the extension of the object. The relational algebra can be easily extended to deal with generalized relations. However, such algebra has some limitations when it is used for modeling spatial data. First of all, there is no explicit way to deal with the set of points representing a spatial object as a whole. Rather, only point-based computations can be performed using this algebra. Second, practical constraint database languages typically use linear constraints. This allows to use ecient algorithms but, at the same time, some interesting queries cannot be represented (for example, the distance between two objects cannot be computed). Finally, no update language for spatial constraint databases has been dened yet. The aim of this paper is to overcome some of the previous limitations. In particular, we extend the model and the algebra to directly deal with the set of points represented by a generalized tuple (a spatial object), retaining at the same time the ability of expressing all computations that can be expressed by other constraint database languages. Moreover, we discuss the introduction of external functions in the proposed algebra, in order to cover all the functionalities that cannot be expressed in the chosen logical theory. Finally, we propose an update language for spatial constraint databases, based on the same principles of the algebra. 1 Introduction In the last few years, the area of spatial databases has attracted the interest of dierent application contexts, such as geographical information systems (GIS), VLSI design, geometric modeling in mechanical or building design (CAD). Issues related to the development of models able to represent spatial data, suitable for all these dierent environments, have been addressed in [2, 14, 26, 27, 28]. However,

2 most of the proposed models are not general enough, often allowing only the representation of spatial domains of xed dimensions. Constraint databases have been recently proposed as a general framework for manipulating spatial data [16, 21, 22]. A constraint database uses constraints on a specic decidable logical theory both to model and retrieve data. At the data level, constraints are able to nitely represent possibly innite sets of relational tuples. For example, the constraint X 2 + Y 2 9 ^ X 0 represents the positive semicircle with center in (0; 0) and with radius equal to 3. In general, in the constraint model a conjunction of constraints is called generalized tuple, a nite set of generalized tuples is called generalized relation, whereas the set of (multidimensional) points representing the solutions of a generalized tuple is called extension of such generalized tuple. With respect to data modeling, the main advantage of constraints is that they serve as a unifying data type for the (conceptual) representation of heterogeneous data. In particular, the benet of this approach is emphasized when complex knowledge (for example, spatial or temporal data) has to be combined with some descriptive non-structured information (such as names or gures), or when several types of spatial objects with dierent dimensions (like points, lines, convex polygons and concave polygons) have to be represented [29]. At the query language level, constraints increase the expressive power of simple relational languages by allowing mathematical computations. The integration of constraints in existing query languages introduces several issues. Indeed, constraint query languages should preserve all the nice features of relational languages. For example, they should be closed and bottom-up evaluable [16]. From a spatial point of view, the main issue in dening constraint query languages is to determine which spatial queries can be expressed under a specic language, validating a given constraint language with respect to specic spatial requirements. Dierent algorithms are in general applied to manipulate dierent types of spatial data [24]. On the contrary, constraint databases allow to represent heterogeneous data by using constraints on a certain theory. On this data, homogeneous computations can be applied. Dierent theories can be used to model and query dierent types of data. In spatial applications, the mostly used theory is that of linear polynomial constraints [16]. This choice is motivated by the fact that several ecient algorithms have already been dened for such class of constraints [19]. However, the use of constraints to model spatial data does not come for free. Indeed, spatial data is often represented in vector format, specifying the vertices of the spatial object to be represented. The migration from vector format to linear polynomial constraints has complexity O(n log n), where n is the number of points used to represent a given spatial object, since the cost of this operation is bound by the cost of decomposing the spatial object into convex polygons [24]. As for the relational model, the correct formalism to obtain both a formal specication of the language and a suitable basis for implementation is represented by a constraint relational algebra. In particular, the relational algebra can

3 be extended to deal with constraint relations. The new algebra is called generalized relational algebra [15, 22]. However, if we consider this algebra from a spatial point of view, we can observe that it is not always the more appropriate language for manipulating spatial data. In particular: 1. The manipulation applied by constraint query languages to generalized relations is not always the more natural one for spatial databases. Constraint computations always see a constraint relation as a (possibly innite) set of points and do not see it as a nite set of spatial objects. Therefore, common spatial queries have a complex representation in constraint languages, and therefore also in the generalized relational algebra [15]. 2. The second shortcoming is related to the constraint language expressive power. Often, the chosen theory is not adequate to support all the functionalities needed by the specic application. For example, if we use the linear polynomial constraint theory, the distance between two points or the convex hull of n points cannot be computed [29], even if they can be modeled in the logical theory of (not necessarily linear) polynomial constraints. The simplest solution, i.e., the choice of a more powerful constraint theory, for example real polynomial constraints, is not always satisfactory, since all implementation advantages of linear constraints would be lost. 3. The third shortcoming is related to the lack of update operations for spatial constraint databases. The only approach to model updates in constraint databases we are aware of has been proposed by Revesz in [25], but it presents no concrete update primitives. Rather, it proposes a model-theoretic formalization of minimal changes, following the approaches proposed in [17]. Note that the denition of update languages is a relevant issue for spatial constraint databases, because spatial objects are often subject to transformations with respect to either their shape (for example, in rescaling or adding a new object component) or their position in the space (for example, in translation or rotation). In this paper we extend the generalized relational algebra to overcome the above limitations. The main contributions of the paper can be summarized as follows: 1. In order to directly model typical spatial queries, we assign a new semantics to generalized relations. Indeed, each generalized relation can be seen as a set of (possibly) innite sets, where each set represents the extension of a single generalized tuple (i.e., the extension of a single object), contained in the considered relation. Note that, under this meaning, generalized relations model a very simple kind of nesting [1]. Thus, the new semantics is called nested semantics. In this respect, the type of sets we are able to model by a single generalized tuple becomes important. Other logical connectives, and not only conjunction as proposed in [16], can be used. For example, to model concave sets inside a generalized tuple, disjunction must be used. Note that our approach does not aim at dening a new complex object model for constraint databases, as it has been done in [6, 7, 13]. Rather, it changes

4 the semantics assigned to generalized relations in order to dene a new algebra for constraint relational databases, more suitable from a spatial point of view. Thus, our main interest is in the denition of the language and not in the proposal of a new model. 2. We propose an algebra, based on the nested semantics, to manipulate generalized relations under two dierent points of view, either handling each generalized relation as a nite set of spatial objects or as a possibly innite set of points (i.e., relational tuples). Indeed, the algebra we propose contains two classes of operators: one class handling generalized relations as an in- nite set of points (tuple operators) and one class handling each generalized relation as a nite set of spatial objects (set operators). A preliminary version of this algebra has been presented in [3]. 3. We introduce external functions in the proposed algebra and give examples of external functions that are useful from a spatial point of view. The use of external functions avoids the choice of a \complex" logical theory, with high computational complexity. Rather, it allows to adopt a \simple" logic, for example the linear polynomial inequality constraint theory, and to express specic functionalities by means of external functions. Note that while several approaches have been proposed to model aggregate functions inside constraint query languages [9, 18], as far as we know, no approach has been proposed to deal with arbitrary external functions. 4. An update language is proposed, based on the same principles on which the algebra is based. In particular a set and a tuple version for insert and delete operators are proposed. Then, we investigate how an update operator can be inserted in a constraint database manipulation language. We rst present a general denition and we show under which hypothesis this operator collapses to delete and insert operators and under which other hypothesis it corresponds to some useful spatial operations, such as translation, rotation, etc. The paper is organized as follows. Section 2 introduces the model and the generalized relational algebra, whereas Section 3 discusses the limitation of this algebra and proposes a new model and a new algebra, more suitable for spatial manipulations. Section 4 deals with the denition of the update language. Finally, Section 5 presents some concluding remarks, pointing out the issues related to the design of architectures supporting the proposed model. 2 The generalized relational model The following denition formally introduces the constraint relational model, as dened in [16]. Denition 1 (Generalized relational model). [16] Let be a decidable logical theory on a domain D.

5 { A generalized tuple t over variables x 1 ; :::; x k in the logical theory is a nite quantier-free conjunction ' 1 ^ ::: ^ ' N, where each ' i, 1 i N, is a constraint in. The variables in each ' i are all free and among x 1 ; :::; x k. We denote with (t) the set fx 1 ; :::; x k g and with ext(t) the set of relational tuples belonging to D k which are represented by t. { A generalized relation r of arity k in is a nite set r = ft 1 ; :::; t M g where each t i, 1 i M, is a generalized tuple over variables x 1 ; :::; x k and in. We denote with (r) the set fx 1 ; :::; x k g and we call it the schema of r. { A generalized database is a nite set of generalized relations. The schema of a generalized database is a set of relation names R 1 ; :::; R n, each with the corresponding schema. 2 In the generalized relational model, a generalized relation is interpreted as the nite representation of a possibly innite set of relational tuples and this set represents its semantics. Denition2 (Relational semantics). Let r = ft 1 ; :::; t n g be a generalized relation. The relational semantics of r, denoted by rel(r), is ext(t 1 ) [ ::: [ ext(t n ). Generalized relations r 1 and r 2 are r-equivalent (denoted by r 1 r r 2 ) i rel(r 1 ) = rel(r 2 ). 2 In order to represent geometry using constraints in the generalized relational model, a possible approach is to use a relation with n variables representing points of an n-dimensional space. Generalized tuples of this relation thus represent sets of points (i.e., spatial objects) embedded in that space. Using dierent classical logical theories, dierent types of spatial objects can be dened within a large range of complexity. According to the denition of spatial data given in [14], linear polynomial constraints have the sucient expressive power to describe the geometric component of spatial data in geographical applications. Linear polynomial constraints have the form \p(x 1 ; :::; X n ) 0", where p is a linear polynomial with real coecients in variables X 1 ; :::; X n and 2 f=; 6=; ; <; ; >g. This class of constraints is of particular interest, because it has been investigated in various elds (linear programming, computational geometry) and therefore several techniques have been developed to deal with them [19]. In the following, we denote with L the theory of linear polynomial constraints. In order to show an example of spatial data for a real geographic database, we restrict our attention to the Euclidean Plane (E 2 ). The types of point-sets of E 2 which can be described using the formulas of L are shown in Table 1. The rst three types, POINT, SEGMENT and CONVEX, correspond to conjunctions of formulas of the theory L (thus, they correspond to generalized tuples). The fourth type, COMPOSITE spatial type, corresponds to a disjunction of conjunctions of L. As generalized tuples represent conjunctions of constraints, for the representation of composite objects in the generalized relational model, several generalized tuples must be used, each representing a convex object belonging to the convex decomposition of the composite object. An identier must be assigned

6 Graphical Analytical Representation in L representation representation P 1 POINT (p) rp SEGMENT (s) p = (x; y) ( P1 = (x q 1; y 1) P 2? s = P 2 = (x 2; y 1)??? r r : ax + by + c = 0 q CONVEX (c)? b r i b r n P n P i c = P 0 r 0 ( Pi = (x i; y i) r i : a ix + b ix + c i = 0 i = 0! n C p(p) = (X? x = 0) ^ (Y? y = 0) C s(s) = (x 1? X 0) ^ (X? x 2 0) ^(ax + by + c = 0) a C cx(c) = (sg(p 1; P 2)a 1X + b 1Y + c 1 0) ^ :::: ^ (sg(p n?1; P n)a nx + b ny + c n 0) b COMPOSITE (csp) q p 1 p A A A s 3 p Q p p Q p s 1 s 2 c 1 c 2 q p 2 csp = (p 1 [ ::: [ p n) [ (s 1 [ ::: [ s m) [ (c 1 [ ::: [ c l) C ct(csp) = (C p(p 1) _ ::: _ C p(p n)) _ (C s(s 1) _ ::: _ C s(s m)) _ (C cx(c 1) _ ::: _ C cx(s l)) a One or both of the rst two disjuncts of this formula can be removed if a semi straight line or a complete straight line has to be represented. b The introduction of the function sg() is necessary in order to take into account that the polygonal region represented by a simple polygon is always on the left side of the polygon itself. Thus, function sg(p 1; P 2) returns 1 or?1 according to the direction of the line dened by P 1 and P 2. Table 1. Representation of point-sets of the Euclidean Plane in L to each generalized tuple, in order to identify all generalized tuples representing points of the same composite object. The relational algebra can be extended to deal with generalized relations [15, 22]. The resulting algebra is called Generalized Relational Algebra (GRA()) 1. The operators of such algebra are shown in Table 2. The table presents for each 1 is a decidable logical theory. In order to guarantee the closure of GRA(), only theories admitting variable elimination and closed under complementation must be considered. A theory is closed under complementation i, if c is a constraint of the theory, then :c can also be represented in the theory [4].

7 Op. name Syntax e Restrictions Semantics r = (e)(r 1; :::; r n), n 2 f1; 2g selection P (R 1) (P ) (R 1) rel(r) = ft j t 2 rel(r 1); (e) = (R 1) t ^ P is satisableg renaming % [AjB ] (R 1) A 2 (R 1); B 62 (R 1) rel(r) = ft : t 0 2 rel(r 1); (e) = ((R 1) n fag) [ fbg t = t 0 [A j B]g union R 1 [ R 2 (e) = (R 1) = (R 2) rel(r) = rel(r 1) [ rel(r 2) projection [xi1 ;:::;x ip ](R 1) (R 1) = fx 1; :::; x mg rel(r) = f xi1 ;:::;x a ip (t) : (e) = fx i1 ; :::; x i pg t 2 rel(r 1)g (e) (R 1) natural join R 1 1 R 2 (e) = (R 1) [ (R 2) rel(r) = ft : t 1 2 rel(r 1); t 2 2 rel(r 2); t = t 1 1 b t 2g complement :R 1 (e) = (R 1) rel(r) = ft j t 62 rel(r 1)g a This is the relational projection operator. b This is the relational join operator. Table 2. GRA() operators operator of GRA() the schema restriction required by the argument relations and by the result relation. R 1 ; :::; R n are relation names, e represents the syntactic expression and is a function that takes an expression and returns the corresponding query function. The generalized relational algebra satises the following property, stating that GRA operators are a trivial extension of relational operators. Proposition 1 (Relational homomorphism) [15] Let be a decidable logical theory, admitting variable elimination and closed under complementation. Let OP be a GRA() operator and let OP rel be the corresponding relational algebra operator. Let r i, i = 1; :::; n be generalized relations on theory. Then, rel(op(r 1 ; :::; r n )) = OP rel (rel(r 1 ); :::; rel(r n )). 2 3 A nested generalized relational model for spatial data The generalized relational model is a simple and yet powerful model because of its ability of representing innite sets of tuples. However, as the classical relational model, it has a number of shortcomings when dealing with more complex data objects, as spatial data. Indeed, spatial objects have the following two characteristics: 1. the complex (geometric) component of spatial data can be represented as an innite set of points embedded in a reference space; 2. each object has a relevance not only as a set of values (points), but also as a single value (object).

8 From this consideration it follows that spatial data should be manipulated under two dierent points of view: { For some manipulations, it is useful to see a set of spatial objects as a set of points in the reference space. For example, suppose to retrieve all object components contained in a certain region or to compute the intersection of two spatial objects. In both cases, the computations manipulate points belonging to the extension of the considered objects. Not all the points belonging to the extension of a given object are necessarily returned by the query. Rather, such extension is modied by the computation. This type of manipulation is called point-based. { For other manipulations, it is useful to see each spatial object as a single value. For example, suppose to determine all spatial objects contained in a certain region or to compute all pairs of spatial objects that intersect. In both cases, the same computation must be applied to all the points belonging to the extension of a given object. In this case, the object itself, seen as a single value, must satisfy the query and not a part of it, as in the previous case. This type of manipulation is called object-based. All computations that can be represented by GRA() are point-based. Note that this does not mean that object-based computations cannot be represented by GRA(). However, typical object-based spatial manipulations have in GRA() a very complex representation, due to the fact that a point-based manipulation must be used to simulate them, as the following example shows. Example 1. Consider the query selecting all spatial objects that are contained in the region of the space identied by a rectangle rt 2 E 2. This is a typical objectbased manipulation. Assume that all spatial objects are represented inside a generalized relation R and that C cx (rt) = P (see Table 1). In order to represent such query in GRA(), the schema of the generalized relation R must include a variable ID, representing the generalized tuple identier. This identier is needed to \glue" together all the points belonging to the extension of a given spatial object. The previous query can be expressed in GRA( L ) as follows: ( [ID](R) n ( [ID](R n P (R)))) 1 R: The previous expression has the following meaning: { P (R) selects the points (X; Y ) of R contained in P, together with the identier of the object to which they belong. { R n P (R) selects the points (X; Y ) that are not contained in P, together with the identier of the object to which they belong. { [ID](R n P (R)) selects the identiers of the objects having at least one point not contained in P. Thus, all the retrieved identiers correspond to objects not contained in P. { [ID](R) n ( [ID](R n P (R))) selects the identiers of the objects contained in P. { ( [ID](R) n ( [ID](R n P (R)))) 1 R selects the objects contained in P. 3

9 The previous expression is not very simple to write and to understand, even if the query is one of the most common in spatial applications. The problem is that the query deals with the extension of generalized tuples taken as single objects, whereas, in general, the algebra operators deal with single relational tuples, belonging to the extension of generalized tuples. In order to be able to manipulate spatial objects as single values, we extend GRA() by providing two dierent classes of operators: { Set operators: They apply a certain object-based computation to generalized relations. Each generalized relation must be interpreted as a set of spatial objects. For this reason, we call them set operators. { Tuple operators: They apply a certain point-based computation to generalized relations. Each generalized relation must be seen as a possibly innite set of points (i.e., of tuples). For this reason, we call them tuple operators. The denition of set operators is possible only if the semantics assigned to generalized relations is changed, in order to see each generalized relation as a set of spatial objects. Moreover, tuple operators must be revised to deal with this new semantics. In the following, we rst present the new semantics and then we present the algebra. 3.1 The nested generalized relational model The relational semantics is not the only possible way to assign a meaning to generalized relations. Generalized relations can also be interpreted as nested relations [1]. A nested relation is a relation in which attributes may contain sets as values. If we interpret generalized relations as nested relations, each generalized tuple represents a possibly innite set of relational tuples, implicitly represented by its extension, and a generalized relation is not any longer an (innite) set of relational tuples (i.e., points of the embedding space) but is a nite set of sets, each representing a (possibly innite) set of relational tuples (i.e., each set represents a spatial object). This consideration leads to the denition of the following semantics. Denition3 (Nested semantics). Let r = ft 1 ; :::; t n g be a generalized relation. The nested semantics of r, denoted by nested(r), is the set 2 fext(t 1 ); :::; ext(t n )g n ffgg: Two generalized relations r 1 and r 2 are n-equivalent (denoted by r 1 n r 2 ) i nested(r 1 ) = nested(r 2 ). 2 From now on, we call nested generalized relational model the generalized relational model in which the nested semantics is adopted. 2 We assume to remove inconsistent generalized tuples, i.e., all generalized tuples t such that ext(t) = fg.

10 If a generalized relation is interpreted under the nested semantics, the set of logical connectives used inside generalized tuples becomes important, because it characterizes the types of (possibly) innite sets that can be represented. As we have seen, when using only conjunction inside generalized tuples, only convex sets of points can be represented. To overcome this limitation, we extend generalized tuples to deal with disjunction. Denition 4 (Disjunctive generalized tuples). Let be a decidable logical theory. A disjunctive generalized tuple (abbreviated as d-generalized tuple) over variables x 1 ; :::; x k in the logical theory is a nite and quantier-free disjunction of generalized tuples over variables x 1 ; :::; x k. 2 The concepts of generalized relation and generalized database do not change when replacing generalized tuples with disjunctive-generalized tuples. In the following, we always consider d-generalized tuples and for simplicity we simply refer to them as to generalized tuples. Notice that the use of disjunction allows the representation of all types of spatial data (see Table 1) inside a single generalized tuple. Example 2. Figure 1 shows a possible geographic domain. The space is decomposed in four districts. Districts may contain towns, railway sections, and stations. Districts, towns, and railway sections are concave objects, whereas stations are convex objects. A possible representation of such domains in the nested generalized relational model is the following: { Districts can be stored in a generalized relation D. Each d-generalized tuple represents a single district. { Towns can be stored in a generalized relation T. Each d-generalized tuple represents a single town. { Railway sections and stations can be stored in several ways. For example, each railway section, together with the stations located along the section, can be represented inside a single d-generalized tuple. We assume that railway sections and stations are represented in this way inside a generalized relation R. We assume that the schema of generalized relations D, T, and R contains two variables X and Y, representing points belonging to the object extension, and a variable ID, representing the generalized tuple identier. Notice that this identi- er is not inserted to \glue" together the extension of dierent generalized tuples, as in the generalized relational model. Rather, it has been introduced to better identify the considered spatial objects in query expressions The nested relational algebra The algebra we propose is called Nested Generalized Relational Algebra and, when dened for a decidable logical theory, admitting variable elimination

11 AA 1 2 I II 5 AA AA AA III 1 AA A A A A A AA A A A A pt AA AA A A AA A A AA A A AA AA AA AA AA AA IV A A AA 3 rt 3 DistrictAATowns Stations Railway Query point Query rectangle Fig. 1. The map shows the content of the generalized relations D (representing districts), R (representing railways and stations) and T (representing towns) and closed under complementation, it is denoted by NGRA(). The operators of NGRA(), assuming that generalized relations are interpreted under the nested semantics, are the following: { Tuple operators are exactly the operators introduced in Table 2. The only dierence is that now they deal with a nested semantics. Thus, we force generalized relations obtained as query results to have a certain nested representation. { Set operators are the following: 1. Set dierence: Given two generalized relations r 1 and r 2, this operator returns all generalized tuples contained in r 1 for which no equivalent generalized tuple exists in r 2. This is the usual dierence operation in nested relational databases [1]. 2. Set complement: Given a generalized relation r, this operator returns a generalized relation containing a generalized tuple t 0 for each generalized tuple t contained in r, such that t 0 r :t. 3. Set selection: This operator selects from a generalized relation all the generalized tuples satisfying a certain condition. The condition has the form (Q 1 ; Q 2 ; ), where 2 f; (16= ;)g and Q 1 and Q 2 are either queries,

12 Op. name Syntax e Restrictions Semantics r = (e)(r 1; :::; r n), n 2 f1; 2g Tuple operators selection P (R 1) (P ) (R 1) r = ft : t 1 2 r 1; t = t 1 ^ P g (e) = (R 1) renaming % (R1) [AjB] A 2 (e); B 62 (e) r = ft : t0 2 r 1; t = t 0 [A j B]g (e) = ((R 1) n fag) [fbg projection [xi1 ;:::;x ip ](R 1) (R 1) = fx 1; :::; x mg r = f xi1 ;:::;x a ip (t) : t 2 r 1g (e) = fx i1 ; :::; x i pg (e) (R 1) natural join R 1 1 R 2 (e) = (R 1) [ (R 2) r = ft : t 1 2 r 1; t 2 2 r 2; t = t 1 ^ t 2g complement :R (e) = (R) r = f:t 1 ^ ::: ^ :t n j ft 1; :::; t ng = rg Set operators union R 1 [ R 2 (R 1) = (R 2) = (e) r = ft : t 2 r 1 or t 2 r 2g set R 1 n s R 2 (R 1) = (R 2) = (e) r = ft : t 2 r 1; 69t 0 2 r 2 : dierence ext(t) = ext(t 0 )g set : s R 1 (e) = (R 1) r = f:t : t 2 r 1g complement set selection (Q s ;Q ;)(R1) (Q1) (Q2) r = ft : t 2 r1; 1 2 (e) = (R 1) rel(t 1) rel( (Q1 )(t 2))g (Q s ;Q ;16=;)(R1) (Q1) = (Q2) r = ft : t 2 r1; 1 2 (e) = (R 1) rel(t 1) \ rel(t 2) 6= ;g t 1 = Q 1(t); t 2 = Q 2(t) a This operator eliminates all variables not contained in fx i1 ; :::; x i pg, by applying a variable elimination algorithm [19]. Table 3. NGRA() operators whose unique argument is the tuple under analysis, seen as a singleton generalized relation and denoted by t, or constant functions returning a given generalized tuple P. In the last case, Q 1 (Q 2 ) is denoted by P. If Q i, i 2 f1; 2g, is the identity query, i.e., it takes a tuple and returns the same tuple, it is simply denoted by t. Queries Q i, i = 1; 2, are constructed by recursively applying the subset of NGRA() operators given by f P ; % A=B ; x1;:::;x n ; 1; :; \g, to the only argument t. The set selection operator with condition (Q 1 ; Q 2 ; ), applied to a generalized relation r, selects from r only the generalized tuples t for which there exists a relation between Q 1 (t) and Q 2 (t). In the following, given a NGRA() expression Q, (Q) denotes the schema of the result of applying Q to a set of generalized relations. In a similar way,

13 ((Q 1 ; Q 2 ; )) = (Q 1 ) [ (Q 2 ). The possible meanings of operators are the following: : In this case, we require that (Q 1 ) (Q 2 ). It selects all generalized tuples t in r such that rel(q 1 (t)) rel( (Q 1)(Q 2 (t))). 16= ;: In this case, we require that (Q 1 ) = (Q 2 ). It selects all generalized tuples t in r such that rel(q 1 (t)) \ rel(q 2 (t)) 6= ;. When a condition C is satised by a generalized tuple, we denote this fact with C(t). Table 3 presents set and tuple operators, according to the notation introduced in Section 2. Note that the union operator has been classied as a set operator, since it deals with the global extension of generalized tuples. The denition of additional operators derived from the proposed ones can be found in [4]. Among the possible derived operators we recall: set selections operators with conditions (Q 1 ; Q 2 ; ), with 2 f1= ;; ; =; 6=g; set selection operators using as condition a boolean combination of the conditions previously dened. The semantics of such operators directly follows from the semantics of the proposed set selection operator. It can be proved that NGRA() operators can be seen as some nestedrelational algebra computations [1], when extended to deal with constraints [4]. Proposition 2 (Nested homomorphism) [15] Let be a decidable logical theory, admitting variable elimination and closed under complementation. Let OP be a NGRA() operator. Let r i, i = 1; :::; n be generalized relations on theory. There exists a nested relational algebra expression Q such that nested(op(r 1 ; :::; r n )) = Q(nested(r 1 ); :::; nested(r n )). 2 In [4] it has been shown that NGRA() and GRA() are equivalent when specic generalized tuple identiers are inserted in input generalized relations. Indeed, this is the only way to manipulate sets in the generalized relational model. However, NGRA() allows to represent some typical spatial queries in a simpler and much compact form. This result is similar to the equivalence result obtained for relational and nested relational databases [23]. Moreover, NGRA() has the same complexity of GRA(), i.e., it is in NC. Example 3. Consider the query selecting all spatial objects that are contained in the region of the space identied by a rectangle rt 2 E 2. Assuming that all spatial objects are represented in a generalized relation R and that C cx (rt) = P (see Table 1), the previous query can be expressed in NGRA( L ) as s (R). (t;p;) Note that this expression is much more simpler than the one used to represent the same query in GRA( L ) (see Example 1). 3 In spatial applications, the most interesting queries involve topological and metric properties of spatial objects [11, 14, 27, 28]. Topological properties are based on the denition of boundary and interior. These are the two parts in which a spatial object can be decomposed, according to the geometric application of the algebraic topology. A proposal for modeling the concept of classical

14 Type Query NGRA expression Conditions Point interference queries POINT select all districts in D that contain a given point INTERFERENCE pt 2 E 2 (see Figure 1 to locate pt) s (t;p;) (D) P a C p(pt) b RANGE INTERSECTION Range queries select all districts in D that intersect the region of the space identied by the rectangle rt 2 E 2 (see Figure 1 to locate rt) s (t;p;(16=;)) (D) P C cx(rt) RANGE select all towns in T that are contained in the region of the space identied by the rectangle rt 2 E CONTAINMENT 2 s (t;p;) (T ) P C cx(rt) RANGE CLIP calculate all portions of districts obtained as intersection of each district in D with the rectangle rt 2 E 2 P (D) P C cx(rt) RANGE ERASE calculate all portions of towns obtained as dierence of towns in T with the rectangle rt 2 E 2 T n t P (T [ :T ) c P C cx(rt) a denotes syntactic equivalence. b See Table 1 for the denition of functions C p(), C cx(). c The symbol n t is a short form for the derived operator: T n t S = T 1 :S. Table 4. Examples of queries based on relationships with the embedding space boundary [30], and therefore of topological relationship in the context of linear constraints, has been presented in [29]. The combinatorial boundary [20], which has a more complex denition than the classical one, can still be represented using linear constraints. Therefore, all spatial selections that involve topological relationships [10, 12] can be expressed in GRA( L ), and, in a more natural way, in NGRA( L ).

15 Tables 4 and 5 present some examples of spatial queries 3, including topological queries, expressed in NGRA( L ). All the queries are assumed to be executed on the nested generalized database presented in Example 2. Each query in the tables is described by a textual description and by the mapping to NGRA( L ). By contrast, metric queries cannot be expressed in NGRA( L ) alone. Nest subsection shows how, by complementing NGRA( L ) with external functions, metric queries can be expressed. 3.3 External functions The introduction of external functions in database languages is an important topic. Functions increase the expressive power of database languages, relying on user dened procedures, without modifying the language denition. External functions can be considered as library functions, completing the knowledge of a certain application domain. If we consider constraint query algebras, the introduction of external functions must preserve the closure of the language. The following denition introduces a class of functions for constraint databases, that satisfy this property. In the following, DOM gentuple (; S) is the set of all the possible disjunctive generalized tuples dened on theory and having (S) as schema, where (S) denotes the set of variables in S and S is a tuple of variables (denoted by [X 1 ; : : : ; X n ]) 4. Denition 5 (Admissible functions). Let be a decidable logical theory. An admissible function f for is a function from DOM gentuple (; S) to DOM gentuple (; S 0 ), where S and S 0 may be dierent. S is called the input schema of f and it is denoted by is(f), whereas S 0 is called the output schema of f and it is denoted by os(f). 2 When using external functions, two new operators, called application dependent operators 5 can be added to NGRA(). The family of Apply Transformation operators allows to apply an admissible function to a generalized relation. Each operator of the family is specied by ATf Sr, where f is an admissible function and Sr is a tuple of variables. The result of the application of ATf Sr to a generalized relation r, whose schema contains (Sr), is a new relation obtained from the previous one by replacing each generalized tuple t by a new tuple t 0. The new tuple t 0 is obtained from t by modifying the set of values assigned to variables in Sr, according to the application of function f. The second operator (Application dependent set selection) is similar to the set selection of Table 3; the only dierence is that now queries specied in the selection condition C f may contain the operator AT f. 3 All spatial queries presented in Tables 4, 5 and 7 must be considered as classical queries (as dened in [8]). We do not consider any denition of genericity for spatial queries with respect to geometric or topological transformations [22]. 4 The denition of S as a tuple simplies the denition of application dependent operators (see Table 6). 5 The term application dependent operators comes from the fact that functions reect the application requirements.

16 Type ADJACENT QUERY NGRA expression Query Conditions Topological queries select all districts in D that are adjacent to the district with ID = 1 s c 1 ( s c 2 (D 1 D 0 )) P (ID = 1) D 0 % [IDjID 0;Xj X 0 ;Y j Y 0 ]( P (D)) c 1 (Q 1(t); Q 3(t); (1= ;)), c 2 (Q 2(t); Q 4(t); (16= ;)) Q 1(t) Q INT ( [X;Y ] (t)), Q 2(t) Q BND( [X;Y ] (t)) a Q 3(t) % [X0 jx ;Y 0 jy ] (Q 0 (t)) Q 0 (t) Q INT ( [X0 ;Y 0 ](t)) Q 4(t) % [X0 jx ;Y 0 jy ] (Q 00 (t)) Q 00 (t) Q BND( [X0 ;Y 0 ](t)) CONTAINED select all districts in D that contain the town identied by ID = 4 QUERY s c(d 1 T 0 ) P (ID = 4) T 0 % [IDjID 0;Xj X 0 ;Y j Y 0 ]( P (T )) c ( [X;Y ] (t); Q 0 (t); ) Q 0 (t) % [X0 jx ;Y 0 jy ] ( [X0 ;Y 0 ](t)) Spatial Joins SPATIAL generate all portions of railway sections that are intersection INTERSECTION between the district with ID = 1 and the railway network SPATIAL JOIN (intersection based) R 1 P (D) P (ID = 1) generate all pairs (district d, railway section r) such that r reaches d s c(d 1 % [XjX 0 ;Y j Y 0 ](R)) c (Q 1(t); Q 2(t); (16= ;)) Q 1(t) [X;Y ] (t), Q 2(t) % [X0 jx ;Y 0 jy ] ( [X0 ;Y 0 ](t)) a QBND and Q INT represent a short form to indicate the queries that retrieve respectively the boundary and the interior of a spatial object [29]. Table 5. Examples of queries based on relationships with other objects in the same space

17 Op. name Syntax e Restrictions Semantics r = (e)(r 1; : : : ; r n) n 2 f1; 2g apply ATf Sr (R 1) f 2 F r = f [(t)n(t )](t) ^ 0 t 0 : t 2 r 1; transformation is(f) = S; os(f) = S 0 t 0 = % [(S)j ] (f(t 00 )); (Sr) (Sr) (R 1) t 00 = % [(Sr)j ] ( (S) [(Sr)] (t))g a c((sr)) = c((s)) b set selection C s f (R 1) (e) = (R 1) r = ft : t 2 r 1; C f (t) g a Given two tuples of variables T and T 0, % [(T )j(t 0 ) ] (R) replace in R the i-th variable in T with the i-th variable in T 0. b c(s) returns the cardinality of the set s. Table 6. NGRA(; F) application dependent operators Application dependent operators are summarized in Table 6. Given a decidable logical theory, admitting quantier elimination and closed under complementation, and a set of admissible functions F, we denote with NGRA(; F) the set of expressions obtained by composing application dependent operators presented in Table 6 and NGRA() operators. It can be shown that NGRA(; F) is closed [4]. To show some examples of functions for spatial applications, we consider metric relationships. The metric relationships are based on the concept of distance referred to the reference space. The distance used in real applications is often the Euclidean one and a quadratic expression is needed to compute it. Thus, metric relationships can be represented in NGRA( L ; F) only if proper external functions are introduced. Here we propose the following two functions dened as operations on the domain of all generalized tuples on L (we suppose that the reference space is E 2 ): { Distance (Dis): Given a constraint c with four variables, representing two spatial objects, it generates a constraint Dis(c) obtained from c by adding a variable D which represents the minimum distance between the two spatial objects. The following formula denes Dis(c), supposing that c has variables (X; Y; X 0 ; Y 0 ), where X; Y refer to the rst spatial object and X 0 ; Y 0 refer to the second one (thus the input schema is [X; Y; X 0 ; Y 0 ], whereas the output schema is [X; Y; X 0 ; Y 0 ; D]): Dis(c) = c ^ (D = min( p (X 0? X) 2 + (Y 0? Y ) 2 : c(x; X 0 ; Y; Y 0 ))): { Buffer (Buf ): Given a constraint c, it generates the constraint Buf (c) which represents all points that have a distance from c less than or equal to (thus the input and output schemas coincide and correspond to [X; Y ]). It can be represented by the following formula: Buf (c) = 9X 0 ; Y 0 (c(x 0 ; Y 0 ) ^ (X 0? X) 2 + (Y 0? Y ) 2 2 ):

18 Type DISTANCE QUERY Query NGRA expression Conditions Metric queries select all railway sections in R that are within 50 Km from the town identied by ID = 4 c(r s 1 % [XjX 0 ;Y j Y 0 ](T 0 )) P (ID = 4) T 0 AT [X;Y ] Buf (P (T )) 50Km c ( [X;Y ](t); [X0 ;Y 0 ](t); 16= ;) SPATIAL JOIN (distance based) generate all pairs (town t, railway section r) such that the distance between r and t is less than 40 Km, together with the real distance between r and t AT [X;Y;X0 ;Y 0 ] Dis ( s c(t 1 R 0 )) c (Q 1(t); Q 2(t); 16= ;) R 0 % [IDjID 0;Xj X 0 ;Y j Y 0 ](R) Q 1(t) AT [X;Y ] Buf 40Km ( [X;Y ](t)) Q 2(t) % [X0 jx ;Y 0 jy ] ( [X0 ;Y 0 ](t)) Table 7. Examples of spatial queries using external functions Some relevant queries using external functions are reported in Table 7. 4 Update operators Following the relational approach, at least three update operators must be dened for constraint databases: insertion, deletion, and modication of generalized tuples. The distinction between point-based and object-based manipulation can be taken into account also in the denition of update operators. At this level, they have the following meaning: { A point-based update modies a set of spatial objects, seen as a possibly in- nite set of points. Thus, it may add, delete, or modify some points, possibly changing the extension of the already existing objects. { An object-based update modies a set of spatial objects by inserting, deleting, or modifying a spatial object, seen as a single value. Following the notation used in the denition of NGRA() operators, update operators applying a point-based manipulation are called tuple operators, whereas update operators applying an object-based manipulation are called set operators. Note that the previous distinction has a counterpart only in the denition of insertion and deletion. Indeed, due to the nested semantics assigned to a generalized relation, point-based and object-based modify operations coincide. However, we choose to classify it as a set operator, since it always modies a spatial object, represented by a generalized tuple.

19 Operator Syntax e Restrictions Semantics r 1 := (e)(r 1) Name tuple insert Ins t (R 1; C; u) (u) (R 1) r 1 := ft _ u j t 2 r 1 ^ C(t)g [ ft j t 2 r 1 ^ :C(t)g set insert Ins s (R 1; u) (u) (R 1) r 1 := r 1 [ fug set delete Del s (R 1; C) (C) (R 1) r 1 := ft j t 2 r 1 ^ :C(t)g tuple delete Del t (R 1; C; u) (u) (R 1) r 1 := ft^:u j t 2 r 1^C(t)g [ ft j t 2 r 1 ^ :C(t)g set update Upd s (R 1; C; Q) (Q) (R 1) r 1 := ft j t 2 r 1 ^ :C(t)g [ (C) (R 1) fq(t) j t 2 r 1 ^ C(t)g Table 8. Update operators In the following, we present insert, delete, and modify operators, pointing out the relationships existing among them. All the queries we consider in the denition of these operators are assumed to be expressed in NGRA(; F), for some decidable theory, admitting variable elimination and closed under complementation, and set of admissible functions F. 4.1 Insert operators Specic application requirements lead to the denition of tuple and set insert operators. In particular: { The denition of a set insert operator is motivated by the fact that a typical requirement is the insertion of a new spatial object in a generalized relation. The set insert satises this requirement by taking a generalized relation r and a generalized tuple t as input, and adding t to r, thus increasing the cardinality of r. Since r is a set, the set insert is a no-operation if t is already contained in r. This operation can be reduced to an equivalence test between generalized tuples. As generalized tuples are usually represented by using canonical forms [15], this test usually reduces to check whether two canonical forms are identical. { Because a generalized relation contains sets of relational tuples, the user may be interested in inserting a relational tuple or a set of relational tuples into the existing sets of relational tuples. Note that this requirement is dierent from the previous one, since in this case we extend the extension of the already existing spatial objects, but we do not insert any new spatial object. Given a generalized relation r, a boolean condition C (see the denition of set selection at page 11) and a generalized tuple t, the tuple insert operator selects all generalized tuples of r that satisfy C and adds to them the relational tuples contained in ext(t). Notice that the tuple insert does not change the cardinality of the target generalized relation. In Table 8, the syntax and the semantics of insert operations are presented following the style used in Tables 2 and 3. For update operations, is a function

20 AA 1 2 I II 5 AA AA AA III 1 AA A A A A A AA A A A A AA AA A A AA A A AA A A AA AA AA AA AA AA IV A A AA 3 V 3 DistrictAATowns Stations Railway New Station New Railway Fig. 2. The map shows the content of the generalized relations D, R and T, together with the spatial objects to be inserted that takes an update expression and returns a function, representing the update semantics. Example 4. Consider the map represented in Figure 2. The dashed line and the empty square represent spatial objects that have to be added to the database. In particular, the new railway section identied by ID = 5 is added to the R generalized relation and the new station is added to the railway sections identied by ID 2 f1; 2; 4g, since it is an interchange node of the railway network. The rst insertion is performed using the set insert operator, because a new spatial object has to be created. The second one uses the tuple insert operator, since only a modication of the extent of existing spatial objects has to be performed. Table 9 shows the expressions of the two insertions Delete operation For the delete operations the discussion is similar to the one presented for the insert operations. We therefore introduce two operators: { The set delete operator, given a generalized relation r and a boolean condition C, deletes from r all generalized tuples that satisfy C.

21 Description NGRA update expression insertion of a new railway Ins s (R; hid = 5 ^ 105 X 137 a ^Y =? 9 32 section in R insertion of a new station Ins t (R; (t; (ID = 1 _ ID = 2 _ ID = 4); 16= ;); belonging to the railway sections h53 X 55 ^ 40 Y 42i) of R with ID 2 f1; 2; 4g deletion of the town with Del s (T; (t; (ID = 1); 16= ;)) ID = 1 contained in T deletion of a specic station Del t (R; (t; (ID = 2); 16= ;); from the railway section in R h65 X 67 ^ 83 Y 85i) with ID = 2 a a X b is an abbreviation for X a ^ X b. Table 9. Examples of insertions and deletions using NGRA( L) update operators { The tuple delete operator, given a generalized relation r, a boolean condition C, and a generalized tuple t, selects all the generalized tuples of r that satisfy C and removes from their extension the relational tuples contained in ext(t). In Table 8, the syntax and semantics of delete operations are presented. As an example, Table 9 shows the expressions to delete respectively the town with ID = 1 and the station of the railway section with ID = Modify operators Traditional database systems provide a modify operation to deal with updates that are function of the old values of the tuples. In constraint database systems this case is really frequent since operations of this kind, like rescaling, translation or rotation, are often applied to spatial objects. Therefore the introduction of a modify operator (also called update operator) in a spatial oriented data model is a necessary action. In a traditional DML (for example, SQL), the modify operation usually allows to compute the new value, to be assigned to the updated tuple, by a database query. Following the same approach we propose a set update operator with the following semantics. Given a generalized relation r, a boolean condition C, and a query Q(t), the set update operator selects all tuples t of r that satisfy C and substitutes each t with Q(t). The query Q(t) acts on a single generalized tuple, denoted by t, at a time, as in the denition of the set selection operator. The generalized tuple t is considered as a generalized relation containing only one generalized tuple. This implies that all set operators of NGRA() are useless, since eventually they can only delete t. Note that, also the union operator cannot be used inside Q(t), because it will necessary generate a relation with at least two generalized tuples. However, since an operator that generates the dis-