|
1
|
|
|
2
|
- Data Modeling Using the Entity-Relationship (ER) Model
|
|
3
|
- Overview of Database Design Process
- Example Database Application (COMPANY)
- ER Model Concepts
- Entities and Attributes
- Entity Types, Value Sets, and Key Attributes
- Relationships and Relationship Types
- Weak Entity Types
- Roles and Attributes in Relationship Types
- ER Diagrams - Notation
- ER Diagram for COMPANY Schema
- Alternative Notations – UML class diagrams, others
|
|
4
|
- Two main activities:
- Database design
- Applications design
- Focus in this chapter on database design
- To design the conceptual schema for a database application
- Applications design focuses on the programs and interfaces that access
the database
- Generally considered part of software engineering
|
|
5
|
|
|
6
|
- We need to create a database schema design based on the following
(simplified) requirements of the COMPANY Database:
- The company is organized into DEPARTMENTs. Each department has a name,
number and an employee who manages the department. We keep track of the
start date of the department manager. A department may have several
locations.
- Each department controls a number of PROJECTs. Each project has a
unique name, unique number and is located at a single location.
|
|
7
|
- We store each EMPLOYEE’s social security number, address, salary,
sex, and birthdate.
- Each employee works for one department but may work on several
projects.
- We keep track of the number of hours per week that an employee
currently works on each project.
- We also keep track of the direct supervisor of each employee.
- Each employee may have a number of DEPENDENTs.
- For each dependent, we keep track of their name, sex, birthdate, and
relationship to the employee.
|
|
8
|
- Entities and Attributes
- Entities are specific objects or things in the mini-world that are
represented in the database.
- For example the EMPLOYEE John Smith, the Research DEPARTMENT, the
ProductX PROJECT
- Attributes are properties used to describe an entity.
- For example an EMPLOYEE entity may have the attributes Name, SSN,
Address, Sex, BirthDate
- A specific entity will have a value for each of its attributes.
- For example a specific employee entity may have Name='John Smith',
SSN='123456789', Address ='731, Fondren, Houston, TX', Sex='M',
BirthDate='09-JAN-55‘
- Each attribute has a value set (or data type) associated with it
– e.g. integer, string, subrange, enumerated type, …
|
|
9
|
- Simple
- Each entity has a single atomic value for the attribute. For example,
SSN or Sex.
- Composite
- The attribute may be composed of several components. For example:
- Address(Apt#, House#, Street, City, State, ZipCode, Country), or
- Name(FirstName, MiddleName, LastName).
- Composition may form a hierarchy where some components are themselves
composite.
- Multi-valued
- An entity may have multiple values for that attribute. For example,
Color of a CAR or PreviousDegrees of a STUDENT.
- Denoted as {Color} or {PreviousDegrees}.
|
|
10
|
- In general, composite and multi-valued attributes may be nested
arbitrarily to any number of levels, although this is rare.
- For example, PreviousDegrees of a STUDENT is a composite multi-valued
attribute denoted by {PreviousDegrees (College, Year, Degree, Field)}
- Multiple PreviousDegrees values can exist
- Each has four subcomponent attributes:
- College, Year, Degree, Field
|
|
11
|
|
|
12
|
- Entities with the same basic attributes are grouped or typed into an
entity type.
- For example, the entity type EMPLOYEE and PROJECT.
- An attribute of an entity type for which each entity must have a unique
value is called a key attribute of the entity type.
- For example, SSN of EMPLOYEE.
|
|
13
|
- A key attribute may be composite.
- VehicleTagNumber is a key of the CAR entity type with components
(Number, State).
- An entity type may have more than one key.
- The CAR entity type may have two keys:
- VehicleIdentificationNumber (popularly called VIN)
- VehicleTagNumber (Number, State), aka license plate number.
- Each key is underlined
|
|
14
|
- In ER diagrams, an entity type is displayed in a rectangular box
- Attributes are displayed in ovals
- Each attribute is connected to its entity type
- Components of a composite attribute are connected to the oval
representing the composite attribute
- Each key attribute is underlined
- Multivalued attributes displayed in double ovals
- See CAR example on next slide
|
|
15
|
|
|
16
|
- Each entity type will have a collection of entities stored in the
database
- Previous slide shows three CAR entity instances in the entity set for
CAR
- Same name (CAR) used to refer to both the entity type and the entity set
- Entity set is the current state of the entities of that type that are
stored in the database
|
|
17
|
- Based on the requirements, we can identify four initial entity types in
the COMPANY database:
- DEPARTMENT
- PROJECT
- EMPLOYEE
- DEPENDENT
- Their initial design is shown on the following slide
- The initial attributes shown are derived from the requirements
description
|
|
18
|
|
|
19
|
- The initial design is typically not complete
- Some aspects in the requirements will be represented as relationships
- ER model has three main concepts:
- Entities (and their entity types and entity sets)
- Attributes (simple, composite, multivalued)
- Relationships (and their relationship types and relationship sets)
- We introduce relationship concepts next
|
|
20
|
- A relationship relates two or more distinct entities with a specific
meaning.
- For example, EMPLOYEE John Smith works on the ProductX PROJECT, or
EMPLOYEE Franklin Wong manages the Research DEPARTMENT.
- Relationships of the same type are grouped or typed into a relationship
type.
- For example, the WORKS_ON relationship type in which EMPLOYEEs and
PROJECTs participate, or the MANAGES relationship type in which
EMPLOYEEs and DEPARTMENTs participate.
- The degree of a relationship type is the number of participating entity
types.
- Both MANAGES and WORKS_ON are binary relationships.
|
|
21
|
|
|
22
|
|
|
23
|
- Relationship Type:
- Is the schema description of a relationship
- Identifies the relationship name and the participating entity types
- Also identifies certain relationship constraints
- Relationship Set:
- The current set of relationship instances represented in the database
- The current state of a relationship type
|
|
24
|
- Previous figures displayed the relationship sets
- Each instance in the set relates individual participating entities
– one from each participating entity type
- In ER diagrams, we represent the relationship type as follows:
- Diamond-shaped box is used to display a relationship type
- Connected to the participating entity types via straight lines
|
|
25
|
- By examining the requirements, six relationship types are identified
- All are binary relationships( degree 2)
- Listed below with their participating entity types:
- WORKS_FOR (between EMPLOYEE, DEPARTMENT)
- MANAGES (also between EMPLOYEE, DEPARTMENT)
- CONTROLS (between DEPARTMENT, PROJECT)
- WORKS_ON (between EMPLOYEE, PROJECT)
- SUPERVISION (between EMPLOYEE (as subordinate), EMPLOYEE (as
supervisor))
- DEPENDENTS_OF (between EMPLOYEE, DEPENDENT)
|
|
26
|
|
|
27
|
- In the refined design, some attributes from the initial entity types are
refined into relationships:
- Manager of DEPARTMENT -> MANAGES
- Works_on of EMPLOYEE -> WORKS_ON
- Department of EMPLOYEE -> WORKS_FOR
- etc
- In general, more than one relationship type can exist between the same
participating entity types
- MANAGES and WORKS_FOR are distinct relationship types between EMPLOYEE
and DEPARTMENT
- Different meanings and different relationship instances.
|
|
28
|
- An relationship type whose with the same participating entity type in distinct
roles
- Example: the SUPERVISION relationship
- EMPLOYEE participates twice in two distinct roles:
- supervisor (or boss) role
- supervisee (or subordinate) role
- Each relationship instance relates two distinct EMPLOYEE entities:
- One employee in supervisor role
- One employee in supervisee role
|
|
29
|
- An entity that does not have a key attribute
- A weak entity must participate in an identifying relationship type with
an owner or identifying entity type
- Entities are identified by the combination of:
- A partial key of the weak entity type
- The particular entity they are related to in the identifying entity
type
- Example:
- A DEPENDENT entity is identified by the dependent’s first name, and
the specific EMPLOYEE with whom the dependent is related
- Name of DEPENDENT is the partial key
- DEPENDENT is a weak entity type
- EMPLOYEE is its identifying entity type via the identifying
relationship type DEPENDENT_OF
|
|
30
|
- Constraints on Relationship Types
- (Also known as ratio constraints)
- Cardinality Ratio (specifies maximum participation)
- One-to-one (1:1)
- One-to-many (1:N) or Many-to-one (N:1)
- Many-to-many (M:N)
- Existence Dependency Constraint (specifies minimum participation) (also
called participation constraint)
- zero (optional participation, not existence-dependent)
- one or more (mandatory participation, existence-dependent)
|
|
31
|
|
|
32
|
|
|
33
|
- In a recursive relationship type.
- Both participations are same entity type in different roles.
- For example, SUPERVISION relationships between EMPLOYEE (in role of
supervisor or boss) and (another) EMPLOYEE (in role of subordinate or
worker).
- In following figure, first role participation labeled with 1 and second
role participation labeled with 2.
- In ER diagram, need to display role names to distinguish participations.
|
|
34
|
|
|
35
|
|
|
36
|
- A relationship type can have attributes:
- For example, HoursPerWeek of WORKS_ON
- Its value for each relationship instance describes the number of hours
per week that an EMPLOYEE works on a PROJECT.
- A value of HoursPerWeek depends on a particular (employee, project)
combination
- Most relationship attributes are used with M:N relationships
- In 1:N relationships, they can be transferred to the entity type on
the N-side of the relationship
|
|
37
|
|
|
38
|
- Cardinality ratio (of a binary relationship): 1:1, 1:N, N:1, or M:N
- Shown by placing appropriate numbers on the relationship edges.
- Participation constraint (on each participating entity type): total
(called existence dependency) or partial.
- Total shown by double line, partial by single line.
- NOTE: These are easy to specify for Binary Relationship Types.
|
|
39
|
- Specified on each participation of an entity type E in a relationship
type R
- Specifies that each entity e in E participates in at least min and at
most max relationship instances in R
- Default(no constraint): min=0, max=n (signifying no limit)
- Must have min£max, min³0, max ³1
- Derived from the knowledge of mini-world constraints
- Examples:
- A department has exactly one manager and an employee can manage at most
one department.
- Specify (0,1) for participation of EMPLOYEE in MANAGES
- Specify (1,1) for participation of DEPARTMENT in MANAGES
- An employee can work for exactly one department but a department can
have any number of employees.
- Specify (1,1) for participation of EMPLOYEE in WORKS_FOR
- Specify (0,n) for participation of DEPARTMENT in WORKS_FOR
|
|
40
|
|
|
41
|
|
|
42
|
- ER diagrams is one popular example for displaying database schemas
- Many other notations exist in the literature and in various database
design and modeling tools
- Appendix A illustrates some of the alternative notations that have been
used
- UML class diagrams is representative of another way of displaying ER
concepts that is used in several commercial design tools
|
|
43
|
|
|
44
|
- Represent classes (similar to entity types) as large rounded boxes with
three sections:
- Top section includes entity type (class) name
- Second section includes attributes
- Third section includes class operations (operations are not in basic ER
model)
- Relationships (called associations) represented as lines connecting the
classes
- Other UML terminology also differs from ER terminology
- Used in database design and object-oriented software design
- UML has many other types of diagrams for software design (see Chapter
12)
|
|
45
|
|
|
46
|
|
|
47
|
- Relationship types of degree 2 are called binary
- Relationship types of degree 3 are called ternary and of degree n are
called n-ary
- In general, an n-ary relationship is not equivalent to n binary
relationships
- Constraints are harder to specify for higher-degree relationships (n
> 2) than for binary relationships
|
|
48
|
- In general, 3 binary relationships can represent different information
than a single ternary relationship (see Figure 3.17a and b on next
slide)
- If needed, the binary and n-ary relationships can all be included in the
schema design (see Figure 3.17a and b, where all relationships convey
different meanings)
- In some cases, a ternary relationship can be represented as a weak
entity if the data model allows a weak entity type to have multiple
identifying relationships (and hence multiple owner entity types) (see
Figure 3.17c)
|
|
49
|
|
|
50
|
- If a particular binary relationship can be derived from a higher-degree
relationship at all times, then it is redundant
- For example, the TAUGHT_DURING binary relationship in Figure 3.18 (see
next slide) can be derived from the ternary relationship OFFERS (based
on the meaning of the relationships)
|
|
51
|
|
|
52
|
- The (min, max) constraints can be displayed on the edges –
however, they do not fully describe the constraints
- Displaying a 1, M, or N indicates additional constraints
- An M or N indicates no constraint
- A 1 indicates that an entity can participate in at most one
relationship instance that has a particular combination of the other
participating entities
- In general, both (min, max) and 1, M, or N are needed to describe fully
the constraints
|
|
53
|
- A number of popular tools that cover conceptual modeling and mapping
into relational schema design.
- Examples: ERWin, S- Designer (Enterprise Application Suite), ER-
Studio, etc.
- POSITIVES:
- Serves as documentation of application requirements, easy user
interface - mostly graphics editor support
- NEGATIVES:
- Most tools lack a proper distinct notation for relationships with
relationship attributes
- Mostly represent a relational design in a diagrammatic form rather than
a conceptual ER-based design
- (See Chapter 12 for details)
|
|
54
|
|
|
55
|
- The entity relationship model in its original form did not support the
specialization and generalization abstractions
- Next chapter illustrates how the ER model can be extended with
- Type-subtype and set-subset relationships
- Specialization/Generalization Hierarchies
- Notation to display them in EER diagrams
|
|
56
|
- ER Model Concepts: Entities, attributes, relationships
- Constraints in the ER model
- Using ER in step-by-step conceptual schema design for the COMPANY
database
- ER Diagrams - Notation
- Alternative Notations – UML class diagrams, others
|