Algebras for Moving Objects and Their Implementation. Ralf Hartmut Güting. Fernuniversität Hagen, Germany

Transcription

1 Algebras for Moving Objects and Their Implementation Ralf Hartmut Güting Fernuniversität Hagen, Germany

2 1 Introduction Moving Objects Databases Database support for the modeling and querying of time-dependent geometries & moving objects. Physical objects have position and extent which may change over time, e.g. countries, rivers, roads, pollution areas, land parcels,... taxis, air planes, oil tankers, criminals, polar bears, hurricanes, flood areas, oil spills users with location-aware portable wireless networked devices such as mobile phones, PDAs,... Spatio-temporal databases - roots in spatial and in temporal databases. New: support for continuously changing geometries = movement. Consider moving point objects and regions that may move and change their shape. Also time-dependent linear features (but less frequent and relevant). Current and near future movement / history of movement. 1

3 Introduction - Moving Objects Databases Applications Logistics, fleet management traffic analysis and management analysis of movements of people (customers) in mobile computing earth sciences environmental studies biology (e.g. animal behaviour, tracking) meteorology geographic information systems - any kind of temporal development of spatial data - land ownership history 2

4 Example 3

5 Introduction - Moving Objects Databases Goal: any kind of moving entity can be represented in a database powerful query languages available to formulate any kind of questions about such movements Two perspectives: location management spatio-temporal data Three approaches: Location management: Wolfson et al. Spatio-temporal data: spatio-temporal data types constraint approach 4

6 Spatio-Temporal Data Types Approach: Extend the strategy used in spatial databases to offer abstract data types with suitable operations. Offer spatio-temporal data types such as moving point (mpoint) and moving region (mregion) Values of such types are functions from time into the domains, e.g. - f: instant point (value of mpoint) - f: instant region (value of mregion) t y x 5

7 Spatio-Temporal Data Types flight (id: string, from: string, to: string, route: mpoint) weather (id: string, kind: string, area: mregion) The data types include suitable operations such as: intersection: mpoint mregion mpoint distance: mpoint mpoint mreal trajectory: mpoint line deftime: mpoint periods length: line real min: mreal real 6

8 Some Example Queries Query 1: Find all flights from Düsseldorf that are longer than 5000 kms. SELECT id FROM flights WHERE from = DUS AND length(trajectory(route)) > 5000 mpoint -> line trajectory line -> real length Query 2: Retrieve any pairs of air planes that during their flight came closer to each other than 500 meters! SELECT f.id, g.id FROM flights AS f, flights AS g WHERE f.id <> g.id AND min(distance(f.route, g.route)) < 0.5 mpoint x mpoint -> mreal distance mreal -> real min 7

9 Query 3: At what times was flight BA488 within the snow storm with id S16? SELECT deftime(intersection(f.route, w.area)) FROM flights AS f, weather AS w WHERE f.id = BA488 AND w.id = S16 mpoint x mregion -> mpoint intersection mpoint -> periods deftime 8

10 Outline 1 Introduction 2 An Algebra for Moving Objects in the 2D Plane 3 An Algebra for Objects Moving in Networks 4 Implementing an Algebra in the SECONDO Environment 5 SECONDO Demo (Time Permitting) 9

11 2 An Algebra for Moving Objects in the 2D Plane Design Goals: Design a system of data types & operations which is closed simple powerful Closed: under application of type constructors, in particular: For all base types of interest, we have corresponding time-dependent (temporal, moving ) types. For all temporal types, we have types to represent their domain and range projections. Simple: There are lots of types around, avoid proliferation of operations use generic operations as much as possible. Explore the space of possible operations systematically. Achieve consistency of operations on base and temporal types. Powerful: more or less a result of the previous two. 10

12 Data Types Spatial Types point points line region 11

13 instant int real bool string all temporal types for these moving(int) moving(real) moving(bool) moving(string) all projections to range range(int) range(real) range(bool) range(string) point points line region moving(point) moving(points) moving(line) moving(region) points line region periods all projections to domain 12

14 Type System as a Signature Type constructor Signature int, real, string, bool BASE point, points, line, region SPATIAL instant TIME range BASE TIME RANGE moving, intime BASE SPATIAL TEMPORAL Terms of the signature are types, for example int, region, range(instant), moving(point), intime(bool) 13

15 Operations: Overview Design Goals: e.g. as generic as possible achieve consistency between operations on non-temporal and temporal types point point real distance mpoint mpoint mreal mdistance Three steps: distance(atinstant(mp 1, t), atinstant(mp 2, t) = atinstant(mdistance(mp 1, mp 2 ), t) 1. Define operations on non-temporal types 2. Lift them all to temporal types 3. Add specific operations for temporal types 14

16 Operations on Non-Temporal Types Generic view: point and point set in some space 1D Spaces 2D Space Space point type point set type Integer int range(int) Real real range(real) Bool bool range(bool) String string range(string) Time instant periods π 2D point points, line, region σ π σ bool inside instantiates to int range(int) bool inside bool range(bool) bool instant periods bool point line bool etc. 15

17 Operations on Non-Temporal Types Class Predicates Operations isempty =, /=, intersects, inside <, <=, >=, >, before touches, attached, overlaps, on_border, in_interior Set Operations intersection, union, minus crossings, touch_points, common_border Aggregation min, max, avg, center, single Numeric no_components, size, perimeter, duration, length, area Distance and Direction distance, direction Base Type Specific and, or, not 16

18 Lifting Operations to Time-Dependent Operations α 1 α 2 α n β op Lifting yields operations moving(α 1 ) α 2 α n α 1 moving(α 2 ) α n moving(α 1 ) moving(α 2 ) α n moving(α 1 ) moving(α n ) moving(β) op moving(β) op moving(β) op moving(β) op For example: real real bool = mreal real mbool = real mreal mbool = mreal mreal mbool = region point point intersection mregion point mpoint intersection region mpoint mpoint intersection mregion mpoint mpoint intersection 17

19 Operations on Temporal Types Values of these types are partial functions f: A instant A α Projection to Domain / Range v t moving(α) periods deftime moving(α) range(α) rangevalues [1D] moving(point) points locations moving(points) points moving(point) line trajectory moving(points) line moving(line) line routes moving(line) region traversed moving(region) region

20 Operations on Temporal Types Values of these types are partial functions f: A instant A α Projection to Domain / Range v deftime moving(α) periods deftime moving(α) range(α) rangevalues [1D] moving(point) points locations moving(points) points moving(point) line trajectory moving(points) line moving(line) line routes moving(line) region traversed moving(region) region t

21 Operations on Temporal Types Values of these types are partial functions f: A instant A α Projection to Domain / Range v rangevalues moving(α) periods deftime moving(α) range(α) rangevalues [1D] moving(point) points locations moving(points) points moving(point) line trajectory moving(points) line moving(line) line routes moving(line) region traversed moving(region) region t

22 Interaction with Points and Point Sets in Domain and Range v moving(α) instant intime(α) atinstant t moving(α) periods moving(α) atperiods moving(α) intime(α) initial, final moving(α) instant bool present moving(α) periods bool moving(α) β moving(α) at [1D] moving(α) β moving(min(α, β)) at [2D] moving(α) moving(α) atmin, atmax [1D] moving(α) β bool passes

23 Interaction with Points and Point Sets in Domain and Range v final initial atinstant present atperiods present t moving(α) instant intime(α) atinstant moving(α) periods moving(α) atperiods moving(α) intime(α) initial, final moving(α) instant bool present moving(α) periods bool

24 Interaction with Points and Point Sets in Domain and Range v atmax at passes at atmin passes moving(α) β moving(α) at [1D] moving(α) β moving(min(α, β)) at [2D] moving(α) moving(α) atmin, atmax [1D] moving(α) β bool passes t

25 Rate of Change Concept of derivative: f () t = lim t 0 f( t+ t) f( t) t Applicable to which data types? Needed: difference, division by real number.. Operation Signature Semantics derivative mreal mreal µ where µ ( t) = lim ( µ ( t+ δ ) µ ( t)) / δ speed mpoint mreal mdirection mpoint mreal turn mpoint mreal velocity mpoint mpoint δ 0 µ where µ ( t) = lim f ( µ ( t+ δ ), µ ( t)) / δ δ 0 δ 0 distance µ where µ ( t) = lim f ( µ ( t+ δ ), µ ( t)) / δ µ where µ ( t) δ 0 direction = lim ( f ( µ ( t+ δ )) f ( µ ( t))) / δ mdirection δ 0 mdirection µ where µ ( t) = lim ( µ ( t+ δ ) µ ( t)) / δ

26 Discrete Model / Data Structures Representation of types moving(α): Represent the temporal development of the value of type a by decomposing the time dimension into a set of disjoint time intervals ( slices ) such that within each slice the development can be described by some simple function. Called the sliced representation. v t y t x moving(real) moving(point)

27 Real Units v Distance between two moving points: 2 at + bt + c D ureal = Interval(Instant) {( abcr,,, ) abc,, real, r bool} Semantics (value at instant t): + + if ι (( abcr,,, ), t ) = 2 at + bt + c if r 2 at bt c r t Perimeter of a moving region: bt + c Area of a moving region: 2 at + bt + c Not closed under derivative! 25

28 3 An Algebra for Objects Moving in Networks In many applications, moving entities move along networks cars, vehicles on roads, highways trains, underground, buses on public transport networks, even air planes people along roads, hiking trails, paths, pedestrian zones vessels along rivers, canals Such movement can be described by the previous model. Advantages of a specialized model? network should be modeled explicitly - easier formulation of queries - more efficient execution describe movements relative to network, not the embedding space - factor out geometry, descriptions of moving object much more compact - discovering relationships between moving objects and parts of the network much simpler and more efficient 26

29 Further requirements: information about network must be extensible (e.g. create relations to add info relative to a network) - add a relation for motels describe static and moving network positions and regions - gas station, construction area, car, traffic jam handle interactions between network, network space, space - network: roads, junctions - network space: vehicles, gas stations, traffic jams - space: forests, city areas, rivers,... - network - network space: On which highway is this car? - network space - space: At what times is the vehicle within the fog area? - network - space: Return the part of the network that lies within forest X. adequate model of network - concept of paths - simple and dual routes - transitions at junctions consistent with model for unconstrained movement; reuse concepts 27

30 Network Model First idea: directed graph. However, paths are the conceptual entities in real life: cities are organized by streets, not blocks. Street names, street addresses, for example. highways, not pieces of highway between junctions We will use a model based on routes (corresponding to paths) and junctions between routes. Further advantage: descriptions of movements much more compact than in a graph model. 28

31 Network Definitions Route: Route = {(id, l, c, kind, start) id int, l real, c line, kind {simple, dual}, start {smaller, larger} } Let R a set of routes, i.e., R Route. Route measure: RMeas(R) = {(rid, d) rid int, d real, (rid, l, c, k, s) R such that 0 d l} Junction: Junction(R) = {(rm 1, rm 2, cc) rm 1, rm 2 RMeas(R), rm 1 = (r 1, d 1 ), rm 2 = (r 2, d 2 ), r 1 r 2, cc int} 29

32 Connectivity codes: B B A (a) Au Ad Bu Bd Au Ad Bu Bd (c) A (b) Network: A pair N = (R, J) where R is a finite set of distinct routes and J is a finite set of junctions in R. Let Network denote the set of all such pairs. Route location: RLoc(R) = {(rid, d, side) (rid, d) RMeas(R), side Side, for (rid, l, c, kind, start) R: kind = simple side = none} 30

33 Network position (= route location): Let N = (R, J). Loc(N) = RLoc(R). Route interval: A triple (rid, d 1, d 2, side) where (rid, d 1, side) and (rid, d 2, side) are route locations and d 1 d 2. Network region: Finite set of quasi-disjoint route intervals in Network N. Denoted Reg(N) 31

34 Data Types Three static types: network: the network gpoint: a position in the network gline: a region (part) of the network Domains of data types: D network = Network Let N = {N 1,..., N k } be the set of networks present in the database. D gpoint = {(i, gp) 1 i k gp (Loc(N i ) { })} D gline = {(i, gl) 1 i k gl Reg(N i )} 32

35 Operations Operations to Interface with Relations and Standard Types - relational views of a network: converting a network to relations - constructing a network from relations - accessing gpoint and gline values - constructing gpoint and gline values Operations according to [GBE+00] - type system extended - concept of spaces extended Operations on non-temporal types - generic operations (stuff inherited from GBE) - added: interaction between network objects and space - added: interaction between network and space - added: interaction between network (routes) and network objects Operations on temporal types - lifting - generic operations (stuff inherited from GBE) Some more operations - network operations - auxiliary (time intervals, now, etc.) 33

36 Operations to Interface with Relations and Standard Types Relational views of a network: converting a network to relations network rel routes, junctions, sections Result schemas: (route: int, length: real, curve: line, dual: bool, startssmaller: bool) (route1: int, meas1: real, route2: int, meas2: real, cc: int, pos: point) (route: int, meas1: real, meas2: real, dual: bool, curve: line) Example: Assume a city road network Hagen and a road relation road(name: string, route: int, roadlevel: int) Query: Find all sections of Bahnhofstrasse longer than 500 meters! SELECT * FROM sections(hagen) AS s, road AS r WHERE r.name = Bahnhofstrasse AND s.route = r.route AND (s.meas2 - s.meas1) >

37 Operations According to [GBE+00] Type system extended: Results in types: moving(gpoint), moving(gline) intime(gpoint), intime(gline) BASE SPATIAL GRAPH TIME BASE SPATIAL GRAPH TEMPORAL int, real, string, bool point, points, line, region gpoint, gline instant BASE TIME RANGE range moving, intime 35

38 Operations According to [GBE+00] Concept of spaces extended: 1D Spaces discrete continuous point type point set types Integer int range(int) Boolean bool range(bool) String string range(string) Real real range(real) Time instant periods 2D Space 2D point points, line, region Graph gpoint gline 36

39 Operations According to [GBE+00] - Non-Temporal Operations (a) Many operations inherited from [GBE+00], for example: results in: π σ bool inside σ 1 σ 2 bool inside, intersects π π real distance gpoint gline bool inside gline gline bool intersects gpoint gpoint real distance (b) Define further operations to treat interaction between network, network objects and space, e.g. gpoint point in_space gline line in_space network point gpoint in_network network points gline in_network network line gline in_network network region gline in_network 37

40 Operations According to [GBE+00] - Temporal Operations (a) Lifting: applies to all the non-temporal operations defined before. For example: gpoint gline bool inside moving(gpoint) gline moving(bool) inside gpoint moving(gpoint) moving(bool) inside moving(gpoint) moving(gpoint) moving(bool) inside gpoint point in_space moving(gpoint) moving(point) in_space (b) Many generic operations for temporal types inherited from [GBE+00]. For example: moving(α) periods deftime moving(α) instant intime(α) atinstant moving(α) periods moving(α) atperiods moving(gpoint) periods deftime moving(gpoint) instant intime(gpoint) atinstant moving(gpoint) periods moving(gpoint) atperiods 38

41 Further Operations For example, some network specific operations: gpoint real gline circle, out_circle, in_circle gpoint gline component gpoint gpoint gline shortest_path gpoint gpoint instant moving(gpoint) trip 39

42 Experimental Evaluation Parcel Delivery Queries on historical information: 1. Where was postman Bob at 10 am of last Saturday? 2. Which places did Bob visit between 9:00 am and 11:00 am of last Saturday? 3. Find all post workers who visited Rathausstrasse in the afternoon (2:00 pm through 6:00 pm) of last Friday. 4. Find all post workers who stayed in Hagener Strasse for more than one hour yesterday. 5. Find all post workers who stayed within 1 km to each other for more than two hours last Saturday. 6. For the last week, who visited the Marktring area most often? 7. In the last week, which streets were visited most often? Queries on current information: 8. Who is currently closest to Boeler Strasse 122 and moving towards that direction? 9. Who is closest to Bob and the desired destinations of their current packages are within 2 kilometers? (suppose that Bob has a problem with his motorcycle and needs another postman to help him with his package) 10. Who is now moving eastwards in the Hagener Strasse? 11. Which street has more than ten postmen currently? 12. Find all postmen who have stayed in the same street for more than 1 hour up to now. 13. Who will pass Hagener Strasse before he/she can deliver his/her current package? 14. Find all postworkers currently in the Hagener Strasse and report their location. 40

43 Experimental Evaluation Vehicles in a Highway Network Queries on past and static information: 1. Order highways by their average distance between gas stations. 2. Which percentage of the German highway network does have a speed limit? 3. How many cars passed gas station X today? 4. How does traffic density at km 140 of highway 45 of the network change through the day? 5. Find vehicles that exceeded the speed limit by more than 20%; when and where did that occur? 6. Which fraction of vehicles passes from highway 45 to highway 1 at their junction? Queries on future information: 7. Which vehicles will reach gas station X within the next 30 minutes? 8. Keep me informed about the 5 closest motels along the highway. 9. Keep me informed about motels within 5 kms distance along the highway. 41

44 Experimental Evaluation Traffic Jams in a Highway Network 1. Which traffic jams exist now? 2. When and where did traffic jam X appear and disappear, respectively? 3. During which times did X grow and shrink, respectively? 4. At what time did it grow most? 5. What time did vehicle X spend within traffic jam Y? 6. At what speed did traffic jam X move? 7. Show the part of the highway network that was affected by traffic jams yesterday. 8. Did any two traffic jams merge into one? 42

45 Some Example Queries Parcel Delivery road(name: string, route: int) postman(name: string, trip: mgpoint) city_area(name: string, reg: region) 43

46 Some Example Queries Parcel Delivery road(name: string, route: int) postman(name: string, trip: mgpoint) city_area(name: string, reg: region) Which places did Bob visit between 9:00 am and 11:00 am of last Saturday? (i) as part of the network (result is a gline value) LET Saturday9to11 = period(hour(2003,8,9,9), hour(2003, 8, 9, 10)); SELECT trajectory(atperiods(trip, Saturday9to11)) FROM postman WHERE name = Bob int x int x int x int -> periods hour periods x periods -> periods period mgpoint x periods -> mgpoint atperiods mgpoint -> gline trajectory 44

47 Some Example Queries Parcel Delivery road(name: string, route: int) postman(name: string, trip: mgpoint) city_area(name: string, reg: region) Which places did Bob visit between 9:00 am and 11:00 am of last Saturday? (ii) as a set of road names LET Bob_roads = routes( ELEMENT( SELECT trajectory(atperiods(trip, Saturday9to11)) FROM postman WHERE name = Bob )); SELECT name FROM Bob_roads AS b, road AS r WHERE b.route = r.route gline -> rel routes 45

48 Some Example Queries Parcel Delivery road(name: string, route: int) postman(name: string, trip: mgpoint) city_area(name: string, reg: region) For the last week, who visited the Marktring area most often? LET LastWeek = period(day(2003, 8, 4), day(2003, 8, 9)); LET Marktring = ELEMENT( SELECT reg FROM city_area WHERE name = Marktring ); SELECT name, no_components( at(atperiods(trip inside Marktring, LastWeek), true)) AS no_times FROM postman ORDER BY no_times FIRST 1 mgpoint x region -> mbool inside mbool x periods -> mbool atperiods mbool x bool -> mbool at mbool -> int no_components 46

49 Some Example Queries Vehicles on Highway Networks highway(no: int, route: int) vehicle(licence: string, trip: mgpoint) speed_limit(limit: int, stretch: gline) How does traffic density at km 140 of highway 45 of the network change through the day? 47

50 How does traffic density at km 140 of highway 45 of the network change through the day? LET yesterday =...; LET highway45 = ELEMENT(SELECT route FROM highway WHERE no = 45); LET location = gpoint(germanhighways, highway45, 140.0, up); network x int x real x int-> gpoint gpoint LET passing_times = SELECT hour(inst(initial(at(atperiods(v.trip, yesterday), location)))) AS hour FROM vehicle AS v WHERE atperiods(v.trip, yesterday) passes location; mgpoint x periods -> mgpoint atperiods mgpoint x gpoint -> bool passes mgpoint x gpoint -> mgpoint at mgpoint -> igpoint initial (intime(gpoint) igpoint -> instant inst instant -> int hour SELECT hour, COUNT(*) AS no_vehicles FROM passing_times GROUP_BY hour 48

51 Some Example Queries Vehicles on Highway Networks highway(no: int, route: int) vehicle(licence: string, trip: mgpoint)... speed_limit(limit: int, stretch: gline) Find vehicles that exceeded the speed limit by more than 20%; when and where did that occur? 49

52 Find vehicles that exceeded the speed limit by more than 20%; when and where did that occur? SELECT v.licence, deftime(speed(at(v.trip, s.stretch)) when[. > s.limit * 1.2]) AS time trajectory(atperiods(v.trip, deftime(speed(at(v.trip, s.stretch)) when[.>s.limit * 1.2])) AS place FROM vehicle AS v, speed_limit AS s WHERE v.trip passes s.stretch AND max(rangevalues(speed(at(v.trip, s.stretch)))) > s.limit * 1.2 mgpoint x gline -> bool passes mgpoint x gline -> mgpoint at mgpoint -> mreal speed mreal -> rreal rangevalues range(real) rreal -> real max mreal x (real -> bool)-> mreal when 50

53 4 Implementing an Algebra in the SECONDO Environment General strategy: Implement an algebra as a data blade, cartridge, extender, etc. in suitable extensible DBMS environments. SECONDO: An environment for implementing DBMS with new kinds of data models, suitable for research prototyping and teaching. no fixed data model system frame can be filled with implementations of a wide range of data models, e.g. - relational - object-relational - graph/network-oriented - sequence-oriented - XML goes beyond extensibility just by attribute data types system frame contains data model independent parts of a DBMS data model dependent parts implemented in algebra modules a formalism to describe data models and query languages as well as representations and query processing: second-order signature 51

54 SECONDO Overview Three major components: SECONDO kernel: - implements specific data models - extensible by algebra modules - provides query processing over the implemented algebras - implemented on top of BerkeleyDB storage manager - written in C++ Optimizer: - core capability: conjunctive query optimization - currently supports a relational model with an SQL-like language - written in PROLOG GUI: - extensible interface for an extensible DBMS like SECONDO - extensible by viewers - sophisticated spatial / spatio-temporal viewer, extensible by data types - written in Java 52

55 SECONDO Overview Components work together: GUI Optimizer SECONDO Kernel GUI sends executable query (query plan) to the kernel, displays result GUI sends query to optimizer, receives plan, sends plan to kernel, displays result optimizer sends commands and executable queries to kernel to get information about DB objects, e.g. selectivities 53

56 The SECONDO Kernel - Concepts Second Order Signature A formalism to describe a descriptive algebra, defining a data model and a query language, an executable algebra, specifying a collection of data structures and operations capable of representing the data model and implementing the query language rules to enable a query optimizer to map descriptive algebra terms to executable algebra terms. 54

57 The SECONDO Kernel - Second Order Signature Basic idea: use two coupled signatures. The first describes a type system, the second an algebra over the types of the first signature. Signature has sorts and operations. First signature: sorts = kinds; operations = type constructors. DATA int, real, bool DATA SET set Terms of the first signature (= types of the type system) int, real, bool, set(int), set(real), set(bool) are sorts of the second. Define operations: data in DATA: data data bool <,,, >, =, 55

58 The SECONDO Kernel - Second Order Signature Can be used to describe a data model and query language (descriptive algebra): DATA (IDENT DATA) + TUPLE tuple TUPLE REL rel Example term (= type, schema): rel(tuple([(name, string), (age, int)])) int, real, bool, string Define operations over the data model (type system). For example A query: rel: rel(tuple) in REL: rel (tuple bool) rel select _ # [ _ ] people select[fun (p: person) attr(p, age) > 20] 56

59 The SECONDO Kernel - Second Order Signature Can also be used to describe data structures and query processing (executable algebra): Representation model: DATA int, real, bool, string (IDENT DATA) + TUPLE tuple TUPLE RELREP srel, relrep Query plan operations: A query plan: tuple in TUPLE: relrep(tuple) stream(tuple) feed _ # stream(tuple) (tuple bool) stream(tuple) filter _ # [ _ ] stream(tuple) srel(tuple) consume _ # people feed filter[fun(p: person) attr(p, age) > 20] consume 57

60 The SECONDO Kernel - Commands A database is a pair (T, O) where T is a finite set of named types and O a finite set of named objects. Seven basic commands to manipulate a database: type <identifier> = <type expression> delete type <identifier> create <identifier> : <type expression> update <identifier> := <value expression> let <identifier> = <value expression> delete <identifier> query <value expression> Further commands for creating, deleting databases inquire about algebras, type constructors, operations, as well as types and objects in a database importing, exporting objects and databases transaction management 58

61 The SECONDO Kernel Rough architecture: Command Manager Query Processor & Catalog Alg 1 Alg 2 Alg n Storage Manager & Tools 59

62 The SECONDO Kernel - Algebra Modules An algebra consists of a set of type constructors a set of operations The module contains: type constructor KindCheck operator TransformType Select Evaluate representation data structure Create/Delete Open/Close Save/Clone In/Out 60

63 The SECONDO Kernel - Algebra Modules Some currently available algebra modules: StandardAlgebra RelationAlgebra BTreeAlgebra RTreeAlgebra SpatialAlgebra int, real, string, bool rel, tuple btree rtree point, points, line, region DateTimeAlgebra instant, duration TemporalAlgebra NetworkAlgebra periods, rangeint,..., mint, mreal, mpoint, mgpoint, mgline network, gpoint, gline 61

64 The SECONDO Kernel Some example commands and queries: create x: int update x := 7 let inc = fun(n:int) n + 1 query secondo contains second Next example uses objects: Kreis kreis_gebiet magdeburg rel(tuple([kname: string,..., Gebiet: region])) rtree(tuple([kname: string,..., Gebiet: region])) region The following query finds neighbour counties of magdeburg: query kreis_gebiet Kreis windowintersects[bbox(magdeburg)] filter[.gebiet touches magdeburg] filter[not(.kname contains "Magdeburg")] project[kname] consume rel(tuple) x rtree(tuple) x rectangle-> stream(tuple) windowintersects region -> rectangle bbox region x region -> bool touches 62

65 The SECONDO Kernel - Example Query (E) Secondo => query kreis_gebiet Kreis windowintersects[bbox(magdeburg)] filter[.gebiet touches magdeburg] filter[not(.kname contains "Magdeburg")] project[kname] consume (E) Secondo -> (query (consume (project (filter (filter (windowintersects kreis_gebiet Kreis (bbox magdeburg)) (fun (tuple1 TUPLE) (touches (attr tuple1 Gebiet) magdeburg))) (fun (tuple2 TUPLE) (not (contains (attr tuple2 KName) "Magdeburg")))) (KName)))) 63

66 Analyze query... 11:27:11 -> elapsed time 0:00 minutes. Used CPU Time: 0.17 seconds. Execute... 11:27:11 -> elapsed time 0:00 minutes. Used CPU Time: 0.22 seconds. KName: LK Schönebeck KName: LK Bördekreis KName: LK Ohre-Kreis KName: LK Jerichower Land (E) Secondo => 64

67 The Optimizer Performs conjunctive query optimization: given a set of relations and a set of selection or join predicates, find a good plan. Uses a new algorithm for this. Based on shortest path search in a predicate order graph. 1/2 1/10 1/5 p q r r 10 q p r q q r p p 20 p q r 1000 Selectivities of predicates are determined in advance by evaluating selections and joins on small sample relations. Selectivities once determined are stored for future use. Optimizer implements an SQL-like language in a notation adapted to PROLOG. 65

68 The Optimizer - Sample Query 2?- sql select count(*) from [orte as o, plz as p1, plz as p2] where [o:ort = p1:ort, p2:plz = p1:plz + 7, (p2:plz mod 5) = 0, p1:plz > 30000, o:ort contains "o"]. selectivity : selectivity : e-005 selectivity : selectivity : 0.31 Destination node 31 reached at iteration 6 Height of search tree for boundary is 4 The best plan is: Orte feed {o} filter[(.ort_o contains "o")] loopjoin[plz_ort plz exactmatch[.ort_o] {p1} ] filter[(.plz_p1 > 30000)] loopjoin[plz_plz plz exactmatch[(.plz_p1 + 7)] {p2} ] filter[((.plz_p2 mod 5) = 0)] count Estimated Cost: Command succeeded, result: 273 Yes 3?- 66

69 The Graphical User Interface extensible interface for an extensible DBMS like SECONDO extensible by viewers sophisticated spatial / spatio-temporal viewer, extensible by data types 67

70 The Graphical User Interface - Example 68

71 69

72 70