Object Oriented Databases - Version Engineering by sdfsb346f

VIEWS: 25 PAGES: 20

Object Oriented Databases - Version Engineering

More Info
									Object Oriented Databases
       Version Engineering


          Tom Lansdale
           Isaac Liney
            Oli Ward

    University of the West of England
             Coldharbor Lane
                  Bristol


          March 2, 2009
Overview of the talk

        Introduction
                Version Modeling Overview
                Version Modeling Terms
                Design and Process Management Architecture
                Basic Requirements
        Modeling Primitives
                Philosophy
                Component Hierarchies
                Version Histories
                Configurations
                Equivalencies
        Operations: Overview
                Currency
                Dynamic Configurations
        Workspaces



Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases   March 2, 2009   2 / 20
Introduction


        Conventional Database Management Systems provide efficient storage and
        access to regularly structured data on disk.
        A typical account database for a bank features:
                Master records describing account information.
                Detailed records describing deposits and withdrawals.
        Not all Database Management Systems deal with regularly structured data.
        A CPU can be described as:
                Hundreds of millions of interconnected transistors.
                Millions of logic gates.
                Thousands of lines of hardware description language.
                Test data cases and documentation, all at the same time.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases      March 2, 2009   3 / 20
Version Modeling Overview


        Version Modeling Provides:
                Data structuring concepts for organizing individual versions into version
                histories.
                The composition of composite objects from versions of their components.
                Tracking of equivalent versions across representations.
        Version related operations:
                Inheritance: How new versions can obtain data from ancestors.
                Change Propagation: How the interconnected structure of the design responds
                to data changes.
                Workspace Models: Provide the mechanism though which versions are made
                visible to designers.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases           March 2, 2009   4 / 20
Version Modeling Terms in the CAD Environment



        Design System: The collection of software for creating a design and analyzing
        it for correctness.
        Design applications: CAD programs that are used to produce design data.
        Design Management: programs that organize design data and provide an
        interface for design applications.
        Design Database System: Deals with the storage and retrieval of design data.
        Design Management Software:
                Interprets how data in the database represents a design.
                Interprets design consistency not database consistency.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases      March 2, 2009   5 / 20
Version Modeling Terms Continued


        Work Spaces: Repositories of design objects that may be accessed by users
        and design applications.
        Design Objects: Aggregates of design primitives usually related to other
        design objects.
        Version: Semantically meaningful snapshot of a design object at a point in
        time.
                A descendant of existing versions (if not the first version) and can serve as an
                ancestor of additional versions.
                New versions are the result of the design process. A change is made and
                verified if deemed acceptable then a new version is released.
                Configuration: A Version of a composite object plus the version of each of its
                components.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases            March 2, 2009   6 / 20
Design and Process Management Architecture
                                                     Design
                                                   applications          User Interface/
                                                                           Browser




                                                    History         Workspace
                                                   Manager           Manager
                                      Process                                              Design
                                      Management   Workflow        Object Manager           Management
                                      System                                               System
                                                                    Physical
                                                   Event Log
                                                                    Database




               Figure: Design and Process Management Architecture taken from [1]


        Process Management System                                               Design Management System
                History Manager tracks data                                                Physical Database stores data
                access from design applications                                            on disk.
                these are recored in a Log                                                 Object Manager implements the
                managed by the physical                                                    interrelated network of design
                Database.                                                                  objects.
                The Workflow reacts to events                                               Workspace Manager provides
                by scheduling the next logical                                             shared work areas to hold design
                event.                                                                     objects.
Tom Lansdale, Isaac Liney, Oli Ward (UWE)            Object Oriented Databases                               March 2, 2009   7 / 20
Basic Requirements

        Requirements for logical data models to support design activities:
                Design primitives can be aggregated in to semantically meaningful design
                objects.
                Design objects can be hierarchically composed from more primitive design
                objects.
                The contents of a design object are the collection of design primitives that
                describe it. The interface Describes the way the object appears to other
                objects.
                Mechanisms to represent, construct and manipulate configurations in terms of
                interactions of their interfaces.
                Mechanisms to specify and manipulate multi-version design objects and
                configurations.
                Primitives to permit the selection of a particular version of a design object.
                Previously defined design objects can be reused to define new design objects.
                A history mechanism to record design decisions for future review.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases           March 2, 2009   8 / 20
Modeling Primitives - Philosophy


        Two Primitives of Version Server Data Model:
                Design Objects
                Relationships between design objects
        Has three special relationship types:
                ’Is-a-kind-of’
                ’Is-a-part-of’
                ’Is-derived-from’
        Objects stored in the model are flat and have no structure
        Structure can be provided by:
                Component Histories
                Version Histories
                Equivalencies




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases   March 2, 2009   9 / 20
Modeling Primitives - Component Hierarchies
(”Is-a-part-of”)
        Object can be primitive of composite

                                                                         Datapath.Layout




                                            ALU.Layout
                                                              Shifter.Layout           RFile.Layout




                                    Figure: Component Hierarchies (From [1])

        Objects can be organised into a hierarchy based on the composite objects
        that they make up e.g ”X is-a-part-of Y”

Tom Lansdale, Isaac Liney, Oli Ward (UWE)           Object Oriented Databases                         March 2, 2009   10 / 20
Modeling Primitives - Version Histories (”Is-a-kind-of”)
        Objects organised into a hierarchy based on their version.
        Hierarchy created using the version number given to an object along with its
        name and type.
                e.g. DesignObject = name[version#].type
        Version Histories
                Records ancestor/descendant relationship between versions
                                                                                ALU.Layout




                                                                                                                      ALU[0].Layout




                                                                   ALU[1].Layout




                                                                                     ALU[2].Layout




                                                                    ALU[4].Layout                                ALU[3].Layout




                                                     Alternative
                                                                                                     ALU[5].Layout




                                                     Derivative




                                            Figure: Version History (From [1])
                ALU.layout is structural object used to organise ALU[i].layout.
                        e.g. ALU[i].layout ’is-a-kind-of’ ALU.layout
Tom Lansdale, Isaac Liney, Oli Ward (UWE)            Object Oriented Databases                                                        March 2, 2009   11 / 20
Modeling Primitives - Configurations (”Is-derived-from”)
        When version histories and component hierarchies are combined...
        Hierarchy created using the version number given to an object along with its
        name and type.
        Configuration structure created based on a composite object, with its
        component versions mapped to an object

                                                                Datapath[3].Layout




                                             RFile[4].Layout

                                                                                           ALU[2].Layout




                                            Figure: Configurations (From [1])


Tom Lansdale, Isaac Liney, Oli Ward (UWE)                      Object Oriented Databases                   March 2, 2009   12 / 20
Modeling Primitives - Equivalencies (”Is-derived-from”)
        Multi-faceted
        Occur when a number of representations are needed to describe an object
        accurately (e.g. Views)

                                                                             ALU




                                               ALU[4].Layout
                                                                  ALU[4].Transistor   ALU[2].Function




                                            Figure: Equivalencies (From [1])

        Each view is ’equivalent’ as it describes the same object but based on
        different criteria
Tom Lansdale, Isaac Liney, Oli Ward (UWE)               Object Oriented Databases                       March 2, 2009   13 / 20
Operations: Overview


        It is assumed that all objects must be read or written.
        Version Modeling adds operations to allow:
                Identification of current version within a version history.
                Support for change propagation.
        Inheriting attributes from related design objects as is key to the OO
        philosophy.
        Two operations discussed:
                Currency
                        How can one track current objects?
                Dynamic Configurations
                        How does one create configurations to components which are only resolved
                        when the is-a-part-of relation is traversed?




Tom Lansdale, Isaac Liney, Oli Ward (UWE)     Object Oriented Databases             March 2, 2009   14 / 20
Currency




        The current version != most recent.
        Added operation:
                Explicitly position currency anywhere in version history.
        Parallel currencies have a place, but the advantage of using currency is
        squandered if there are too many current versions.
        Policy specifications are applied to represent the context of a particular
        project.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases       March 2, 2009   15 / 20
Currency: Example



       Main Derivation           ALU[0]



                                                                                 Diagram shows
                                                                                 derivatives of the
                         ALU[1]             ALU[2]   ALU[3]                      ALU object.
                                                                                 Current Version !=
                                                                                 most recent.
                                                                       Current
                              ALU[4]           ALU[5]                  Version


         Figure: Currency Example taken from [1]




Tom Lansdale, Isaac Liney, Oli Ward (UWE)            Object Oriented Databases                March 2, 2009   16 / 20
Dynamic Configurations


        Version Server Model’s mechanism used here as an example.
        Based on layers and context approach.
        Place portions of the version histories for multiple related objects into layers.
        Provide contexts which organise the layers.
        If two versions of different objects must be used together, they are placed in
        the same layer.
        The context defines the search order over the layers.
        In essence, this idea is similar to directory search paths in a filesystem.
        Weaknesses:
                It is possible to combine the layers in ways which do not make sense.
                There are no explicit constraints in which one would specify which versions of
                an object can interface with particular versions of another object.




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases           March 2, 2009   17 / 20
Dynamic Configurations: Example


                                                                               If search Order =
                                                                               L3/L2/L1/L0 (resolution =
    L0              ALU[0]                             RFile[0]                version 2 of each object are
                                                                               resolved).
    L1              ALU[1]                  RFile[1]                           If search Order =
                                                                               L0/L1/L2/L3 (resolution =
    L2              ALU[2]                                                     version 0 of each object are
                                                                               resolved).
    L3                                                                         BUT ALU[2] may not be
                                              RFile[2]
                                                                               compatible with RFile[1] but
                                                                               will be resolved (as in search
   Figure: Dynamic Configurations taken
                                                                               order with L2 dominating
   from [1]
                                                                               L1).




Tom Lansdale, Isaac Liney, Oli Ward (UWE)          Object Oriented Databases                      March 2, 2009   18 / 20
Workspaces
        Named repositories for design objects.
        All repositories are implemented in the same way, the only difference is who is
        allowed to access the contents of the workspace for reading or writing.
        They can be; archive, private or group.
        Archive:
                Should contain fully verified and finished design objects.
        Private:
                Belong to specific designers.
                Should contain incomplete work in progress which only they can read and
                write.
        Group:
                Any member of a given group can read and write data.
                Useful for when in-progress work needs some collaboration before being
                released.
        In summary, it is proposed that objects go through a life-cycle which should
        eventually result in a verified version of the object for release into an archive.

Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases         March 2, 2009   19 / 20
References




   1    Katz, R. H., Toward a Unified Framework for Version Modeling in in
        Engineering Databases.
   2    Begg, C., Connolly, T. Database Systems




Tom Lansdale, Isaac Liney, Oli Ward (UWE)   Object Oriented Databases   March 2, 2009   20 / 20

								
To top