# data[].attributes.body
https://www.w3schools.com/sql/default.asp

# data[].attributes.body
https://dev.mysql.com/doc/refman/5.7/en/glossary.html

# data[].attributes.body
A shared collection of logically related data, and a description of this data, designed to meet the information needs of an organization.

# data[].attributes.body
A software system that enables users to define, create, maintain, and control access to the database.

# data[].attributes.body
A conceptual data model for describing the data or information aspects of an organisation, which lends itself to ultimately being implemented in a database (such as a relational database).

# data[].attributes.body
A logical data model, where all data is represented in terms of tuples, grouped into relations. A database organized in terms of the relational model is a relational database.

# data[].attributes.body
The process of normalisation allows us to produce a set of suitable relations that support the data requirements of the use case and minimise redundancy.

# data[].attributes.attachment_link.title
Database Normalization In Under 10 Minutes

# data[].attributes.attachment_link.description
Hey everybody! In this video, we'll be discussing database normalization and the various normal forms it includes, from the First Normal Form up to the Fifth Normal Form, as well as the problems and benefits of normalization. Get your pen and papers ready! This is will be a very quick lesson.

# data[].attributes.body
A table with columns and rows. It has the following properties:

Has a name that is distinct from all other relation names in the relational schema;

Each cell of the relation contains exactly one atomic (single) value;

Each attribute has a distinct name;

The values of an attribute are all from the same domain;

Each tuple is distinct; there are no duplicate tuples;

The order of attributes has no significance; and

The order of tuples has no significance, theoretically.

# data[].attributes.body
A named column of a relation, which describes a property of the corresponding entity or a relationship type.

# data[].attributes.body
A row of a relation.

# data[].attributes.body
The set of allowable values for one or more attributes

# data[].attributes.body
A (high-level) procedural language: it can be used to tell the DBMS how to build a new relation from one or more relations in the database.

# data[].attributes.attachment_link.description
Help us caption and translate this video on Amara.org: http://www.amara.org/en/v/Blws/ Help us caption & translate this video! http://amara.org/v/Blws/

# data[].attributes.body
For the full(er) list of relational algebra operations please refer to the attached cheat sheet.

# data[].attributes.body
Operations used to return the tuples of a relation that meet a specific condition (called the predicate)

# data[].attributes.body
Operations used to return only specified columns in a relation

# data[].attributes.body
Term used to refer to a DBMS that uses the relational model.

# data[].attributes.body
Computer program that interacts with the database by issuing an appropriate request (typically an SQL statement) to the DBMS.

# data[].attributes.body
Used to define a collection of application programs that interact with the database along with the DBMS and database itself.

# data[].attributes.body
Uses three levels of abstraction: external, conceptual, and internal.

# data[].attributes.body
Consists of the users’ views of the database.

# data[].attributes.body
The community view of the database. It specifies the information content of the entire database, independent of storage con- siderations. The conceptual level represents all entities, their attributes, and their relationships, as well as the constraints on the data, and security and integrity information.

# data[].attributes.body
The computer’s view of the database. It specifies how data is represented, how records are sequenced, what indexes and pointers exist, and so on.

# data[].attributes.body
Description of the database structure.

# data[].attributes.body
Makes each level of a database schema immune to changes to lower levels.

# data[].attributes.body
The immunity of the external scemas to changes in the conceptual schema.

# data[].attributes.body
The immunity of the conceptual schema to changes in the internal schema.

# data[].attributes.body
Collection of concepts that can be used to describe a set of data, the operations to manipulate the data, and a set of integrity constraints for the data.

# data[].attributes.body
The process of constructing a detailed architecture for a database that is independent of implementation details, such as the target DBMS, application programs, programming languages, or any other physical considerations. The design of the conceptual schema is critical to the overall success of the system. It is worth spending the time and energy necessary to produce the best possible conceptual design.

# data[].attributes.body
A general-purpose, developmental, modeling language in the field of software engineering.

# data[].attributes.body
A group of objects with the same properties, which are identified by the enterprise as having an independent existence.

# data[].attributes.body
A uniquely identifiable object of an entity type.

# data[].attributes.body
Entity type that is not existence-dependent on some other entity type. Uniquely identifiable using the primary key attribute.

# data[].attributes.body
Entity type that is existence-dependent on some other entity type. Can only identify attributes of weak entity types through relationships with strong entity types.

# data[].attributes.body
A property of an entity or relationship type.

# data[].attributes.body
An attribute composed of a single component with an independent existence.

# data[].attributes.body
An attribute composed of multiple components, each with an independent existence.

# data[].attributes.body
An attribute that holds a single value for each occurrence of an entity type.

# data[].attributes.body
An attribute that holds multiple values for each occurrence of an entity type.

# data[].attributes.body
An attribute domain is the set of allowable values for one or more attributes.

# data[].attributes.body
An attribute that represents a value that is derivable from the value of a related attribute or set of attributes, not necessarily in the same entity.

# data[].attributes.body
a set of meaningful associations among entity types. A relationship occurrence is a uniquely identifiable association, which includes one occurrence from each participating entity type.

# data[].attributes.body
A relationship type where the same entity type participates more than once in different roles.

# data[].attributes.body
The number (or range) of possible occurrences of an entity type that may relate to a single occurrence of an associated entity type through a particular relationship (e.g. 1..n to n..n).

# data[].attributes.body
Describes the maximum number of possible relationship occurrences for an entity participating in a given relationship type (e.g. Many to Many).

# data[].attributes.body
The degree of a relation is the number of attributes it contains.

# data[].attributes.body
An attribute or set of attributes that uniquely identifies a tuple within a relation.

# data[].attributes.body
Minimal superkey such that no proper subset is a superkey within the relation.

# data[].attributes.body
The candidate key that is selected to identify tuples uniquely within the relation.

# data[].attributes.body
An attribute within one relation that matches the candidate key of some (possibly the same) relation.

# data[].attributes.body
Represents a value for an attribute that is unknown at the present time or is not applicable for this tuple.

# data[].attributes.body
Used to ensure accuracy and consistency of data in a relational database.

# data[].attributes.body
Ensures that no attribute of a primary key can be null.

# data[].attributes.body
Ensures that if a foreign key exists in a relation, either the foreign key value must match a candidate key value of some tuple in its home relation or the foreign key value must be wholly null.

# data[].attributes.body
A virtual or derived relation that is dynamically created from the under- lying base relation(s) when required.

# data[].attributes.body
The values of an attribute uniquely identify each tuple in a particular relation.

# data[].attributes.body
A key is irreducible if no proper subset of the key is unique.

# data[].attributes.body
The determinant of a dependency refers to the attribute, or group of attributes, on the left-hand side of the arrow.

# data[].attributes.body
A proper subset of a set of attributes is group of attributes that is contained in the original set of attributes, excludes at least one of the original attributes

# data[].attributes.body
An attribute (A), or set of attributes, is reliant on another (B), and if and only if each A value is associated with precisely one B value. It is written as A → B.

# data[].attributes.body
An attribute is fully functionally dependent on a set of attributes A if it is both functionally dependent on A, and not functionally dependent on any proper subset of A.

# data[].attributes.body
An attribute is partially dependent if it is a non-key attribute and is functionally dependent on a proper subset of candidate or primary key.

# data[].attributes.body
A transitive dependency is an indirect functional dependency, one in which A→C only by virtue of A→B and B→C.

# data[].attributes.body
A dependency between attributes (for example, A, B, and C) in a relation, such that for each value of A there is a set of values for B and a set of values for C. However, the set of values for B and C are independent of each other.

# data[].attributes.body
The state of being not or no longer needed or useful (e.g. data is represented in the database more than once).

Relations with data redundancy suffer from update anomalies, which can be classified as insertion, deletion, and modification anomalies.

# data[].attributes.body
A normal form is a defined structure for relational databases in which a relation may not be nested within another relation which have attributes with particular relationships.

# data[].attributes.body
A relation that contains one or more repeating groups (the un-normalised form).

# data[].attributes.body
Set of logically related attributes that occur multiple times in one tuple.

# data[].attributes.body
A relation in which the intersection of each row and column contains one and only one value.

# data[].attributes.body
A relation that is in 1NF and every non-primary-key attribute is fully functionally dependent on the primary key.

# data[].attributes.body
A relation that is in 1NF and 2NF in which no non-primary-key attribute is transitively dependent on the primary key.

# data[].attributes.body
A relation that is in 3NF and every determinant is a candidate key.

# data[].attributes.body
A relation that is in BCNF and does not contain nontrivial multi-valued dependencies.

# data[].attributes.body
Technique used in denormalisation where tuples of a relation are spread across a number of smaller relations.

# data[].attributes.body
Produces a relation that contains all tuples of R, or S, or both R and S, duplicate tuples being eliminated. R and S must be union-compatible.

# data[].attributes.body
Produces a relation that contains all the tuples in both R and S. R and S must be union-compatible.

# data[].attributes.body
Produces a relation that contains all the tuples in R that are not in S. R and S must be union-compatible.

# data[].attributes.body
Where a model represents a relationship between entity types, but  the pathway between certain entity occurrences is ambiguous.

# data[].attributes.attachment_link.title
Practical Entity-Relationship Modeling Pitfalls:  The Fan and Chasm Traps

# data[].attributes.attachment_link.description
Review of the fan trap and chasm trap in entity-relationship diagramming and how to assess whether a potentially redundant connection in an E-R diagram is in fact required or not

# data[].attributes.body
Where a model suggests the existence of a relationship between entity types, but the pathway does not exist between certain entity occurrences.

# data[].attributes.body
https://dev.mysql.com/doc/refman/5.7/en/

# data[].attributes.body
is the process of maximizing the differences between members of an entity by identifying their distinguishing characteristics.
Ch. 13.1.4 of the Textbook

# data[].attributes.attachment_link.title
Enhanced Entity-Relationship Model Part 2: Generalization vs. Specialization and EER Constraints

# data[].attributes.attachment_link.description
Further detail on the relationship between top-down (specialization) and bottom-up (generalization) EER modeling and our expectations regarding EER model constraints

# data[].attributes.body
is the process of minimizing the differences between entities by identifying their common characteristics.
Ch. 13.1.5 of the Textbook

# data[].attributes.body
is an entity type that includes one or more distinct subgroupings of  its occurrences, which must be represented in a data model.

# data[].attributes.body
is a distinct subgrouping of occurrences of an entity type, which must be represented in a data model.

# data[].attributes.body
An occurrence in a subclass inherits all the attributes of the superclass.

# data[].attributes.body
Represents a “has-a” or “is-part-of” relationship between entity types, where one represents the “whole” and the other the “part.”
Ch. 13.2 of the Textbook

# data[].attributes.body
Is a specific form of aggregation that represents an association between entities, where there is a strong ownership and coincidental lifetime between the “whole” and the “part.

# data[].attributes.body
Determines whether every member in the superclass must participate as a member of a subclass.
Ch. 13.1.6 of the Textbook

# data[].attributes.body
Describes the relationship between members of the subclasses and indicates whether it is possible for a member of a superclass to be a member of one, or more than one, subclass.
Ch. 13.1.6 of the Textbook

# data[].attributes.body
The degree of a relationship type is the number of participating entity types.

# data[].attributes.body
2 entity types participate in the relationship.

# data[].attributes.body
3 entity types participate in the relationship.

# data[].attributes.body
4 entity types participate in the relationship.

# data[].attributes.body
SQL stands for Structured Query Language. It is a non-procedural language designed for managing data held in a rDBMS. Whilst SQL is an ANSI standard, there are different versions of the language. SQL acts as both a Data Definition Langauge (DDL) and Data Manipulation Language (DML).

# data[].attributes.body
A query is a question asked of a database, where a result is returned in the form of a temporary table. All queries begin with the declarative SELECT clause.

# data[].attributes.body
Allows users to define a database (e.g. create table, foreign key, constraints, create index).

# data[].attributes.body
Allows users to insert, update, delete, view and retrieve data from the database. The part of a DML that involves data retrieval is called a query language.

# data[].attributes.body
Used to set up privileges and roles.

# data[].attributes.body
Used to explicitly state the database you would like to access.