24BSONDesign

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

The presentation on BSON Design shows a a process of logical design for BSON data model. A process

of logical design transforms a conceptual schema into the logical schemas of BSON documents. It the same

kind of transformation as a logical design fro a relational model where a conceptual schem was transformed

into the relational schemas.

In the first step we show how a class of objects can be transformed into a logical schema of BSON document.

A key "_id" is associated with the values obtained from a concatenation of all values associated with

with the values of a composite key (attribute 1 , ... , attribute k) of a CLASS A in a conceptual schema.

All attribute (attribute 1, ... , attribute n) describing CLASS A are single valued attributes and each one

of them is represented by a key with a respective name: "attribute 1" , ... , "attribute n"

A case where a class in a conceptual schema is described by optional and multivalued attributes is

presented in the next few slides.

Class

Conceptual schema
Logical schema

The present slide shows a result of transformation of class of objects in a conceptual schema into

a specification of JSON schema. A method createCollection is used to create a collection "class a"

with a validator of type $jsonSchema. The validator determines a "bsonType" of values included in

the collection as "object" (document in BSON terminology).

At the topmost level an object is described by the properties: "_id" and "CLASS A". Both properties

are required and no additional properties can be used.

A value associated with a key "_id" is a string obtained from concatenation of the values associated with

the keys "attribute 1", ... , "attribute k".

A value associated with a key "CLASS A" is an "object" (document in BSON terminology). Such object is described

the properties "attribute 1", ... "attribute n". All properties are required and no additional properties

can be used.

Note that a property "CLASS A" and nesting of the properties "attribute 1", ... , "attribute n" is required

to support self-describing property of the documents in a collection "class a"

Class

JSON Schema


db.createCollection("class_a",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"string"},
                 "CLASS A":{"bsonType":"object",
                            "properties":{"attribute 1":{"bsonType": ... },
                                          ...            ...         ...  ,
                                          "attribute k":{"bsonType": ... },
                                          "attribute m":{"bsonType": ... },
                                          ...            ...         ...  ,
                                          "attribute n":{"bsonType": ... } },
                            "required":["attribute 1",...,"attribute k","attribute m",...,"attribute n"],
                            "additionalProperties":false }
                },
   "required":["_id","CLASS A"],
   "additionalProperties":false
  } } } );

Class

Example

Conceptual schema


db.createCollection("student",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"int"},
                 "STUDENT":{"bsonType":"object",
                            "properties":{"snumber":{"bsonType":"int" },
                                          "first name":{"bsonType":"string" },
                                          "last name":{"bsonType":"string" } },
                            "required":["snumber","first name","last name"],
                            "additionalProperties":false }
                },
   "required":["_id","STUDENT"],
   "additionalProperties":false
  } } } );

Class

Example


db.student.insert({"_id":NumberInt("1234567"),
                   "STUDENT":{"snumber":NumberInt("1234567"),
                              "first name":"Harry",
                              "last name":"Potter"}	    
                  } );

BSON Design

Optional attribute

Conceptual schema
Logical schema

Optional attribute

JSON Schema


db.createCollection("class_a",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"string"},
                 "CLASS A":{"bsonType":"object",
                            "properties":{"attribute 1":{"bsonType": ... },
                                          ...            ...         ...  ,
                                          "attribute k":{"bsonType": ... },
                                          "attribute m":{"bsonType": ... },
                                          ...            ...         ...  ,
                                          "attribute n":{"bsonType": ... },
                                          "attribute p":{"bsonType": ... } },
                            "required":["attribute 1",...,"attribute k","attribute m",...,"attribute n"],
                            "additionalProperties":false }
                },
   "required":["_id","CLASS A"],
   "additionalProperties":false
  } } } );

Optional attribute

Example

Conceptual schema


db.createCollection("student",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"int"},
                 "STUDENT":{"bsonType":"object",
                            "properties":{"snumber":{"bsonType":"int" },
                                          "first name":{"bsonType":"string" },
                                          "last name":{"bsonType":"string" },
                                          "date of birth":{"bsonType":"date"} },
                            "required":["snumber","first name","last name"],
                            "additionalProperties":false }
                },
   "required":["_id","STUDENT"],
   "additionalProperties":false
  } } } );

Optional attribute

Example


db.student.insert({"_id":NumberInt("1234567"),
                   "STUDENT":{"snumber":NumberInt("1234567"),
                              "first name":"Harry",
                              "last name":"Potter",
                              "date of birth":Date("1999-07-07")},
                  } );

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Multivalued attribute

Conceptual schema
Equivalent conceptual schemas

Multivalued attribute

Sample conceptual schema
Equivalent conceptual schema

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Qualification

Conceptual schema
Equivalent conceptual schema

Qualification

Sample conceptual schema
Equivalent conceptual schema

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

We start from transformation of one-to-one associations. A conceptual schema consists of two classes and one-to-one association "CLASS A Related to CLASS B".

A logical schema can be created in two different ways. Either "CLASS B" is nested within "CLASS A" or "CLASS A" is nested within "CLASS B". We present only one case when "CLASS B " is nested within "CLASS A". A property "_id" of "CLASS A" is created in the same way as for a single class (see earlier). A value associated with "_id" is a value of an identifier of "CLASS A" and it created by concatenation of all values of a composite identifier of "CLASS A". A logical schema consists of logical schemas of the classes "CLASS B" and "CLASS A" linked with one-to-one association. Both classes and an association are enclosed with a blob indicated one JSON document.

One-to-one association

Conceptual schema
Logical schema

One-to-one association

Conceptual schema
Logical schema

JSON schema is created for the first case where "CLASS B" is nested within "CLASS A". At the topmost level JSON schema has two properties "_id" and "CLASS A". The values associated with "_id" are the values of identifiers of "CLASS A". The values associated with a property "CLASS A" are JSON objects describe by the attributes of "CLASS A" and a property representing one-to-one association "Related-to". The values associated with a property "Related-to" are JSON objects representing an instance of object in "CLASS B" associated with an instance of object in "CLAS A". Objects in "CLASS B" are represented in the same way as instances of objects already discussed. A property "CLASS B" provides information about a name of class of objects and it is associated with a value of type object. Such object is described by the properties taken from the attributes describing "CLASS B".

All additional properties are forbidden and all properties are required because there are no optional attributes in a conceptual schema.

Note, that the properties like "CLASS A", "CLASS B", and "Related to" are used to represent all information available in a conceptual schema. It make the present design a self-describing design.

One-to-one association

JSON Schema

db.createCollection("class_a",
                    { "validator":{$jsonSchema:
{"bsonType":"object"
 "properties":{"_id":{"bsonType":"string"},
               "CLASS A":{"bsonType":"object",
                          "properties":{"attribute 1":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute k":{"bsonType": ... },
                                        "attribute m":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute n":{"bsonType": ... },
                                        "Related-to": {"bsonType":"object",
                                                       "properties":{"CLASS B":{"bsonType":"object",
                                                                                "properties":{"attribute 1":{"bsonType": ... },
                                                                                              ...            ...         ...  ,
                                                                                              "attribute m":{"bsonType": ... },
                                                                                              "attribute n":{"bsonType": ... },
                                                                                              ...                        ...  ,
                                                                                              "attribute p":{"bsonType": ... } },
                                                                                "required":["attribute 1",...,"attribute m","attribute n",...,"attribute p"],
                                                                                "additionalProperties":false } },
                                                       "required":["CLASS B"],
                                                       "additionalProperties":false } },
                          "required":["attribute 1",...,"attribute k","attribute m",...,"attribute n","Related-to"],
                          "additionalProperties":false} },
 "required":["_id","CLASS A"],
 "additionalProperties":false
} } } );

One-to-one association

Example

Conceptual schema


db.createCollection("student",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"int"},
                 "STUDENT":{"bsonType":"object",
                            "properties":{"snumber":{"bsonType":"int"},
                                          "first name":{"bsonType":"string"},
                                          "last name":{"bsonType":"string"},
                                          "Owns":{"bsonType":"object",
                                                  "properties":{"CAR":{"bsonType":"object",
                                                                       "properties":{"rego":{"bsonType":"string"},
                                                                                     "make":{"bsonType":"string"},
                                                                                     "model":{"bsonType":"string"} },
                                                                       "required":["rego","make","model"],
                                                                       "additionalProperties":false} },
                                                  "required":["CAR"],
                                                  "additionalProperties":false} },
                             "required":["snumber","first name","last name","Owns"],
                             "additionalProperties":false} },
   "required":["_id","STUDENT"],
   "additionalProperties":false
  } } } );

One-to-one association

Example


db.student.insert({"_id":NumberInt("1234567"),
                   "STUDENT":{"snumber":NumberInt("1234567"),
                              "first name":"Harry",
                              "last name":"Potter",
                              "Owns":{"CAR":{"rego":"AL08UK",
                                             "make":"Rolls Royce",
                                             "model":"Silver Shadow"}
                                     }
                             }
                  } );

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Now, we consider a transformation of one-to-many association into a nested logical schema. If the objects in "CLASS-A" are related to many objects in "CLASS B" and each object in "CLASS B" is related to one object in "CLASS A" then information of the objects in "CLASS B" must be nested within information about the objects in "CLASS A".

Like before, we create a key "_id" associated with the values that uniquely identify the objects in "CLASS A" (documents in a new collection). Then an oval that encircles one -to-many association "CLASS A Related to CLASS" indicates that that the documents representing objects in "CLASS B" must be included within the documents that represent the objects in "CLASS A".

A skeleton of the respective JSON schema is given in the next slide.

One-to-many association

Conceptual schema
Logical schema

The present slide contains a template JSON schema consistent with a logical design given in the previosu slide, i.e "CLASS B"

included in "CLASS A" that represents one-to-many association "CLASS A" Related to "CLASS B".

A key "CLASS A" as associated with an object described by the properties of "CLASS A" in a conceptual schema: "attribute 1", ... "attribute n".

Note that a key "Related-to" is associated with "bsonType" "array". It is because of "many" multiplicity on the right-hand side of association one-to-many is implemented as an array of "objects". A type of the elements in an array associated with a key "items". If an element of an array is an object then we provide the descriptions of the properties of such objects. Then a key "properties" is associated with an object described by a key "CLASS B".

Like in the earlier cases all "additionalProperties" are associated with a value false. It means that no properties can be added to a design.

One-to-many association

JSON Schema

db.createCollection("class_a",
                    { "validator":{$jsonSchema:
{"bsonType":"object"
 "properties":{"_id":{"bsonType":"string"},
               "CLASS A":{"bsonType":"object",
                          "properties":{"attribute 1":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute k":{"bsonType": ... },
                                        "attribute m":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute n":{"bsonType": ... },
                                        "Related-to": {"bsonType":"array",
                                                       "items":{"bsonType":"object",
                                                                "properties":{"CLASS B":{"bsonType":"object",
                                                                                         "properties":{"attribute 1":{"bsonType": ... },
                                                                                                       ...            ...         ...  ,
                                                                                                       "attribute m":{"bsonType": ... },
                                                                                                       "attribute n":{"bsonType": ... },
                                                                                                       ...                        ...  ,
                                                                                                       "attribute p":{"bsonType": ... } },
                                                                           "required":["attribute 1",...,"attribute m","attribute n",...,"attribute p"],
                                                                                         "additionalProperties":false } },
                                                                "required":["CLASS B"],
                                                                "additionalProperties":false } },
                          "required":["attribute 1",...,"attribute k","attribute m",...,"attribute n","Related-to"],
                          "additionalProperties":false} },
 "required":["_id","CLASS A"],
 "additionalProperties":false } } } );

One-to-many association

Example

Conceptual schema

db.createCollection("lecturer",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"int"},
                 "LECTURER":{"bsonType":"object",
                             "properties":{"staff number":{"bsonType":"int"},
                                           "first name":{"bsonType":"string"},
                                           "last name":{"bsonType":"string"},
                                           "Owns":{"bsonType":"array",
                                                   "items":{"bsonType":"object",
                                                            "properties":{"CAR":{"bsonType":"object",
                                                                                 "properties":{"rego":{"bsonType":"string"},
                                                                                               "make":{"bsonType":"string"},
                                                                                               "model":{"bsonType":"string"} },
                                                                                 "required":["rego","make","model"],
                                                                                 "additionalProperties":false} },
                                                            "required":["CAR"],
                                                            "additionalProperties":false} } },
                              "required":["staff number","first name","last name","Owns"],
                              "additionalProperties":false} },
   "required":["_id","LECTURER"],
   "additionalProperties":false
  } } } );

One-to-many association

Example


db.lecturer.insert({"_id":NumberInt("007"),
                   "LECTURER":{"staff number":NumberInt("007"),
                              "first name":"James",
                              "last name":"Bond",
                              "Owns":[{"CAR":{"rego":"AL08UK",
                                              "make":"Rolls Royce",
                                              "model":"Silver Shadow"} },
                                      {"CAR":{"rego":"PKR856",
                                              "make":"Mercedes",
                                              "model";"SE800"} } ]
                             }
                  } );

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Many-to-many association

Conceptual schema
Equivalent conceptual schema

The present slide show two diagrams of logical schemas of JSON documents. It is possible to either nest a class "CLASS AB in a class "CLASS A" (top diagram) or to nest a class "CLASS AB" in a class "CLASS B" (bottom diagram).

It is impossible to nest a class "CLASS B" in a class "CLASS AB" when "CLASS AB" is already

nested in a class "CLASS A" because some documents in a class "CLASS B" nested within one document from "CLASS AB" are nested within different documents of"CLASS A". Therefore, if "CLASS AB" is nested within "CLASS A" then the documents in "CLASS AB" must contain the references (identifiers) of separately stored documents in a class "CLASS B". Such reference (link) implements one- side of Many-to-one association between "CLASS AB" and "CLASS B".

If "CLASS AB" is nested within "CLASS B" then the documents in "CLASS AB" must have a reference (link) of separately stored documents in a class "CLASS A" (a conceptual schema at the bottom of the slide).

Many-to-many association

Logical schema
Equivalent logical schema

Many-to-many association

JSON Schema


db.createCollection("class_a",
                    { "validator":{$jsonSchema:
{"bsonType":"object"
 "properties":{"_id":{"bsonType":"string"},
               "CLASS A":{"bsonType":"object",
                          "properties":{"attribute 1":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute k":{"bsonType": ... },
                                        "attribute m":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute n":{"bsonType": ... },
                                        "Related-to": {"bsonType":"array",
                                                       "items":{"bsonType":"object",
                                                                "properties":{"CLASS AB":{"bsonType":"object",
                                                                                          "properties":{"attribute-b 1":{"bsonType": ... },
                                                                                                        ...            ...         ...  ,
                                                                                                        "attribute-b m":{"bsonType": ... },
                                                                                                        "Ref B"        :{"bsonType": ... } },
                                                                           "required":["attribute-b 1",...,"attribute-b m","Ref B"],
                                                                                         "additionalProperties":false } },
                                                                "required":["CLASS AB"],
                                                                "additionalProperties":false } },
                          "required":["attribute 1",...,"attribute k","attribute m",...,"attribute n","Related-to"],
                          "additionalProperties":false} },
 "required":["_id","CLASS A"],
 "additionalProperties":false } } } );

Many-to-many association

JSON Schema


db.createCollection("class_b",
                    { "validator":{$jsonSchema:
{"bsonType":"object"
 "properties":{"_id":{"bsonType":"string"},
               "CLASS B":{"bsonType":"object",
                          "properties":{"attribute 1":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute m":{"bsonType": ... },
                                        "attribute n":{"bsonType": ... },
                                        ...            ...         ...  ,
                                        "attribute p":{"bsonType": ... } },
                          "required":["attribute 1",...,"attribute m","attribute n",...,"attribute p"],
                          "additionalProperties":false} },
 "required":["_id","CLASS B"],
 "additionalProperties":false } } } );

In the present slide many-to-many association "LECTURER Uses CAR" is transformed into one-to-many association "LECTURER Performs USAGE" and one-to-many association "CAR Participates-in USAGE".

In the next state a class "USAGE" can be nested either within a class "LECTURER" or a class "CAR". If a class "USAGE" is nested within a class "LECTURER" then an association "CAR Participates-in USAGE" must be implemented as a reference from a class "USAGE" to a class "CAR". Such reference is a key "rego" associated with registration number of a car used as a value associated with "_id" in a document that implements an object of class "CAR". If a class "USAGE" is nested in a class "CAR" then an association

"LECTURER Performs USAGE" must be implemented as a reference from a class "USAGE" to a class "LECTURER". Such reference is a key "staff number" associated with a number of staff member used as a value associated with "_id" in a document that implements an object of class "LECTURER".

In this slide we assume that a class "USAGE" is nested within a class "LECTURER". A document implementing an object in a class LECTURE has its description the same as a collection of properties in a conceptual schema. Nesting is performed through a key "Performs" associated with an array of objects implementing individual objects in a class "USAGE". Each element of an array has a key "rego" referencing document identifier in implementation of a class "CAR". All other details are implemented in the same way as earlier in"one-to-many" association.

Many-to-many association

Example
Equivalent conceptual schema

Many-to-many association

Example


db.createCollection("lecturer",
                    { "validator":{$jsonSchema:
{"bsonType":"object"
 "properties":{"_id":{"bsonType":"string"},
               "LECTURER":{"bsonType":"object",
                           "properties":{"staff number":{"bsonType":"int" },
                                        "first name":{"bsonType":"string"},
                                        "last name":{"bsonType":"string" },
                                        "Performs": {"bsonType":"array",
                                                     "items":{"bsonType":"object",
                                                              "properties":{"USAGE":{"bsonType":"object",
                                                                                     "properties":{"rego":{"bsonType":"string"},
                                                                                                   "when used":{"bsonType":"date"} },
                                                                                     "required":["rego","when used"],
                                                                                     "additionalProperties":false } },
                                                                "required":["USAGE"],
                                                                "additionalProperties":false } },
                          "required":["staff number","first name","last name","Performs"],
                          "additionalProperties":false} },
 "required":["_id","LECTURER"],
 "additionalProperties":false } } } );

Class

Example


db.createCollection("car",
                    { "validator":{$jsonSchema:
  {"bsonType":"object",
   "properties":{"_id":{"bsonType":"string"},
                 "CAR":{"bsonType":"object",
                        "properties":{"rego":{"bsonType":"string" },
                                      "make":{"bsonType":"string" },
                                      "model":{"bsonType":"string" } },
                            "required":["rego","make","model"],
                            "additionalProperties":false }
                },
   "required":["_id","CAR"],
   "additionalProperties":false
  } } } );

One-to-many association

Example


db.lecturer.insert({"_id":NumberInt("007"),
                   "LECTURER":{"staff number":NumberInt("007"),
                              "first name":"James",
                              "last name":"Bond",
                              "Performs":[ {"USAGE":{"rego":"AL08UK",
                                                     "when used":Date("2017-07-08")} },
                                           {"USAGE":{"rego":"PKR856",
                                                     "when used":Date("2017-07-09")} },
                                           {"USAGE":{"rego":"AL08UK",
                                                     "when used":Date("2017-07-09")} } ]
                              }
} );


db.car.insert({"_id":"AL08UK",
                   "CAR":{"rego":"AL08UK","make":"Honda","model":"Legend"}
} );


db.car.insert({"_id":"PKR856",
                   "CAR":{"rego":"PKR856","make":"Rolls Royce","model":"Silver Shadow"}
} );

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Transformation of generalization hierarchy is performed in the same way as in logical design for the relational database model. We can apply three methods: superset, subset and association method. The present slide considers application of a superset method.

A superset method transforms entire generalization hierarchy into a single class of objects in the following way.

- all attributes from the classes of objects at the lowest level of generalization hierarchy are copied to an immediate higher level and become optional

attributes ([0..1] tag) there, e.g. the attributes project and thesis are copied from the classes UNDERGRADUATE-STUDENT and POSTGRADUATE-STUDENT to a class STUDENT,

- An attribute type-of-superclass is added to a superclass, e.g. and attribute type-of-students is added to a class STUDENT,

- all empty classes at the lowest level are removed,

- the steps above are repeated until only one class of objects is left,

- all associations at different levels of generalization hierarchy are move to the final single class at the top of the hierarchy.

Superset method is recommended when we have the majority of queries apply to all attributes includedat the different levels of generalization hierarchy.

Generalization - superset method

Generalization-superset

A superset method transforms entire generalization hierarchy into a single class of objects in the following way:
- All attributes from the classes of objects at the lowest level of generalization hierarchy are copied to an immediate higher level and become optional attributes ([0..1] tag) there, e.g. the attributes project and thesis are copied from the classes UNDERGRADUATE-STUDENT and POSTGRADUATE-STUDENT to a class STUDENT
- An attribute type-of-superclass is added to a superclass, e.g. and attribute type-of-students is added to a class STUDENT

Generalization - superset method

- All classes at the lowest level are removed
- The steps above are repeated until only one class of objects is left

A subset method transforms entire generalization hierarchy into a number of classes of objects located at the bottom levels of a generalization hierarchy. All attributes from the classes of objects at the higher levels of generalization hierarchy are moved to the classes of objects at the lowest levels of generalization hierarchy e.g. the attributes s# and first-name last-name, dob are moved from a class STUDENT to the classes POSTGRADUATE-STUDENT and UNDERGRADUATE-STUDENT.

The attribute can be moved because in a generalization hierarchy lower level classes inherit the [properties of the higher level classes.

The same applies to associations. All association attached to the classes at the higher levels of generalization hierartchy are moved down

to the lowest levels in the hierarchy.

Generalization - subset method

Generalization-subset

A subset method transforms entire generalization hierarchy into a number of classes of objects in the following way:
- All attributes from the classes of objects at the higher levels of generalization hierarchy are copied to the classes of objects at the lowest levels of generalization hierarchy e.g. the attributes s# and first-name last-name, dob are copied from a class STUDENT to the classes POSTGRADUATE-STUDENT and UNDERGRADUATE-STUDENT

Generalization - subset method

- All classes of objects except those at the lowest levels of generalization hierachy are removed, e.g. a class STUDENT is removed

An association method expresses a generalization in a different way from class-subclass method applied in the previous two cases.

An association method transforms entire generalization hierarchy into a number of classes of objects linked with one-to-one associations.

First, one of the identifiers from a superclass is copied to subclasses one level below a superclass. For example, an attribute s#

is copied from a class STUDENT to the classes UNDERGADUATE-STUDENT and POSTGRADUATE-STUDENT to create a class-subclass link.

Next the arrows representing generalization hierarchy are replaced with one-to-one association. It changes the semantics

of subclasses. Now, a subclass is no longer a subset of a superclass but it is a fragment of on object included in a super class

(see the next slide).

Generalization - association method

Generalization-partitioning

An association method transforms entire generalization hierarchy into a number of classes of objects in the following way:
- One of the identifiers from a superclass is copied to subclasses one level below a superclass, e.g. an attribute s# is copied from a class STUDENT to the classes UNDEGRADUATE-STUDENT and POSTGRADUATE-STUDENT

Generalization - association method

- A generalization level is removed from a diagram

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

In the present slide we consider a skeleton of a conceptual schema obtained after replacement of all man-to-many asociations with

one-to-many association, bridge class and many-to-one association. An objective of a logical design is to create the nested

structure that covers entire conceptual schema. Unfortunately, sometimes it is not possible. If a class "E" is linked through one-to-many

association to a class C" and a class "C" is linked through many-to-one association to a class "B". Then either a class "C" is nested

within a class "E" or within a class "B".

Hence it is possible to perform more than one logical design that converts a conceptual schema into a schema that can be expressed

as JSON schema.The first design locates a root of a hierarchy in a class "A" and nests a class "B" in a class "A". Then a class

"C" is nested in a class "B". Finally both classes "D" and "F" are nested within a class "C". One-to-many association between the classes

"E " and "C" must be implemented as a reference (a link) because "C" is already nested in "B" and it in the same moment it cannot

be nested in "E".

A hierarchical structure created fro the present conceptual schema is visualized with the red arrows representing the nesting of classes,

A blue arrow represent a nesting that is implemented as a reference. A skeleton of JSON schema is given at the lower part of the slide.

entire schema. It can be done in many different ways. In the next slide we pick a different root for the first hierarchical structure.

Implementation of network structures

ORM

	      
"A"
   ...
   "B"
      ...
      "C":{"REF":"e"},
           ...
           "D"...
	   "F"...		  
"E":{"_id":"e", ... }

In this example to nest a class "C" within a class "E" we pick a class "E" as a root of the first hierarchy. Then a class "D" can

be nested in a class "C", a class "C" can be nested in a class "E" and a class "F" can be nested in a class "C". The second hierarchy

nests a class "B" in a class "A". A class "C" cannot be nested in a class "B" because it is already nested in a class "E". It is why

a class "C" must have the references to a class "B". Such reference can be implemented as a key "REF" associated with unique

of "B" that uniquely identifies each document in "B". Of course such key cannot be "_id" because it is already used for identification

of the documents in a class "A". A key like "_idB" in a description of documents in "B" associated with a value unique fro each document

in "B" is completely sufficient.

A skeleton of JSON schema is given at the lower part of the slide.

Implementation of network structures

ORM

	      
"E"
    ...
    "C":{"REF":"b"}
         ...
         "D"
         "F"
"A"
   ...
   "B":{"ID":"b", ... }

A logical design given on the present slide uses the same identification of the root classes for each hierarchy as in the first example.

We identify two hierarchies. The first one is the same as in the first example: the classes "D" and "F" nested in a class "C", a class "C" nested in a class "B' and a class "B" nested in a class "A".

The second hierarchy nests a class "C" in a class "E". If a class "C" is already nested in a class "B" then its key:value pairs cannot be repeated within a class "E" due to the redundancies. A solution to such problem is to nest the references to the objects in a class "E" instead of entire objects. Such references (links) are implemented as an array of key:value pairs"REF:c" where "c" uniquely identifies

an object in a class "C". It is another implementation of one-to-many association in a situation when a class on "many" side of association is already nested in another class.

Implementation of "many" side os association as an array of references contributes to more programming problems while iterating

over the references (links) included in an array.

Implementation of network structures

ORM


"A"
   ...
   "B"
      ...
      "C":{"ID":"c"},
           ...
           "D"...
           "F"...
"E":[{"REF":"c"}, ...]

Implementation of network structures

ORM


"E"
    ...
    "C":{"ID":"c"}
         ...
         "D"
         "F"
"A"
   ...
   "B":[{"REF":"c"}, ... ]

BSON Design

Outline

Class
Optional attribute
Multivalued attribute
Qualification
One-to-one association
One-to-many association
Many-to-many association
Generalization
Implementation of network structures
Example

Example

Consider the following conceptual schema

Example

Replacement of "many-to-many" association with "one-to-many" and "many-to-one" associations provides the following conceptual schema

Example

Transformation into hierarchical structures and links provides the following a logical schema

Example

Another transformation into hierarchical structures and links provides the following a logical schema

BSON Design

Outline

Class

Class

Class

Class

BSON Design

Outline

Optional attribute

Optional attribute

Optional attribute

Optional attribute

BSON Design

Outline

Multivalued attribute

Multivalued attribute

BSON Design

Outline

Qualification

Qualification

BSON Design

Outline

One-to-one association

One-to-one association

One-to-one association

One-to-one association

One-to-one association

BSON Design

Outline

One-to-many association

One-to-many association

One-to-many association

One-to-many association

BSON Design

Outline

Many-to-many association

Many-to-many association

Many-to-many association

Many-to-many association

Many-to-many association

Many-to-many association

Class

One-to-many association

BSON Design

Outline

Generalization - superset method

Generalization - superset method

Generalization - subset method

Generalization - subset method

Generalization - association method

Generalization - association method

BSON Design

Outline

Implementation of network structures

Implementation of network structures

Implementation of network structures

Implementation of network structures

BSON Design

Outline

Example

Example

Example

Example

References