Monday, May 29, 2006

Related terms in Database Management Systems

Aggregate operator: A function that produces a single value from multiple rows of a table. SQL Anis supports the following operators: avg (average of values), count (number of occurrences), max (highest value), min (lowest value) and sum (sum of all values). The aggregate operators are applied on columns and usually the queries with such operators are made to produce a single row output.

Attribute: An attribute is a part of the description of the entity. The entity itself is described by one or more attributes; together, they describe all things of importance about the entity. Example: Typical attributes for a customer would be name, address, telephone, etc.

Binary relationship: Relationship between two entities.

Business Rule: Specific business-related information that is associated with database objects. The information can be business restrictions (allowable values), facts, or calculation rules for given business situations, e.g. VAT shall be added to all products. Business rules shall be applied in the completed database, either as triggers/stored procedures, or implemented in the application code.

Candidate key: An attribute or set of attributes that uniquely identifies individual occurrences of an entity type.

Cardinality: The number of tuples that an entity or an attribute may generate. The cardinality of entities indicates if a relationship is a One-To-One, One-To-Many or Many-To-Many relationship. The cardinality of attributes indicates if it is optional or mandatory and if it is single or multi-valued.

Composite attribute: An attribute composed of multiple components, each with an independent existence.

Concurrency: With respect to the management of multiple users concurrently interacting with the system, the system should offer the same level of service as current database systems provide. It should therefore insure harmonious coexistence among users working simultaneously on the database. The system should therefore support the standard notion of atomicity of a sequence of operations and of controlled sharing. Serializability of operations should at least be offered, although less strict alternatives may be offered.

Constraint: Rules applied to validate the data.

Data model: It is the representation of the data manipulated by a system, consisted of three parts: structural part (definition of how the database is to be constructed), manipulative part (definition of the types of the operations that are allowed on the data) and rules part (to ensure that the data is accurate). These three parts later on are related with DDL, DML and integrity respectively.

Database: A shared collection of logically related data, designed to meet the information needs of multiple users in an organization. The term database is often erroneously referred to as a synonym for a “database management system (DBMS)”. They are not equivalent. A database is a store of data that describe entities and the relationships between the entities. A database management system is the software mechanism for managing that data.

Database Management System: A DBMS is a collection of computer programs and software for organizing the information in a database. A DBMS supports the structuring of the database in a standard format and provides tools for data input, verification, storage, retrieval, query, and manipulation.

Degree of a relationship: The number of participating entities in a relationship.

Derived attribute: An attribute that gets a value that is calculated or derived from the database.

DDL or Data Definition Language: Set of SQL commands used to support structure definition of databases. It is used to create, alter and delete (drop) tables (logically and physically). These commands are responsible for specifying attributes, types, constraints etc.

DML or Data Manipulation Language: Set of SQL commands used to insert, update and extract data from databases. The queries for these operations can be used with additional clauses in order to order or group data.

Domain: A set of all possible values that an attribute can assume. An attribute "gender", for example, has only two possible values: male or female. We say that the domain for the "gender" attribute is: {male, female}.

Encapsulation: This is the scheme used for defining objects in object-oriented approach. Encapsulation hides detailed internal specification of an object, and publishes only its external interfaces. Thus, users of an object only need to adhere to these interfaces. By encapsulation, the internal data and methods of an object can be changed without changing the way of how to use the object.

Entity: "Something" in the real world that is of importance to a user and that needs to be represented in a database so that information about the entity can be recorded. An entity may have physical existence (such as a student or building) or it may have conceptual existence (such as a course).

Entity set: A collection of all entities of a particular entity type.

Entity type: A set of entities of the same type.

First Normal Form (INF): Where the domain of all attributes in a table must include only atomic (simple, indivisible) values, and the value of any attribute in a tuple (or row) must be a single-valued from the domain of that attribute.

Foreign Key: An attribute that is a primary key of another relation (table). A foreign key is how relationships are implemented in relational databases.

Full participation: Where all of one entity set participates in a relationship.

Functional dependency: A relationship between two attributes in a relation. Attribute Y is functionally dependent on attribute X if attribute X identifies attribute Y. For every unique value of X, the same value of Y will always be found.

Generalization: The process of minimizing the differences between entities by identifying their common features and removing the common features into a superclass entity.

Identifying owner: The strong entity upon which a weak entity is dependent.

Index: An index is a physical mechanism applied to one (or a combination of) column(s). The purpose of the index is for the database system to use the index as a look-up mechanism instead of reading the whole row. Indexes are a prime resource for optimalization (and thereby increasing speed) of searches in the database.

Join: A query, which uses data from more than one table. These tables must have at least one common attribute (also known as linking attribute).

Join Relationship: A join relationship is a collection of information from two or more tables. The join is performed by relating columns, which are foreign key columns in one table with equivalent columns, which are primary key columns in the other table.

Key: An attribute or data item that uniquely identifies a record instance or tuple in a relation.

Mandatory relationship: Same as full participation; where all of one entity set participates in a relationship.

Many-to-many: Where many tuples (rows) of one relation can be related to many tuples (rows) in another relation.

Many-to-one: Where many tuples (rows) of one relation can be related to one tuple (row) in another relation.

Mapping: The process of choosing a logical model and then moving to a physical database file system from a conceptual model (the ER diagram).

Meta Data: 'Data about Data'. This is the documentation stored in the database repository, and which holds information about your database objects. In Oracle, for example, the table USER_TABLES holds vital information about your tables.

Multi-valued attribute: An attribute that may have multiple values for a single entity.

Normal forms: Rules applied to the table's structure. The goal of these rules is to reduce data redundancy and to improve the performance of the database. If the tables are following at least the first three normal forms we say that the data model is normalized and it is considered a relational model.

One-to-many: A relationship where one tuple (or row) of one relation can be related to more than one tuple (row) in another relation.
One-to-one: A relationship where one tuple (or row) of one relation can be related to only one tuple (row) in another relation.

Optional participation: A constraint that specifies whether the existence of an entity depends on its being related to another entity via a relationship type.

Open Database Connectivity (ODBC): A general interface for communication with different vendor-specific Relational Database Systems.

Partial key: The unique key in a dependent entity.

Partial participation: Where part of one entity set participates in a relationship.

Participation constraints (also known as optionality): Determines whether all or some of an entity occurrence is related to another entity.

Primary key: A column (or combination of columns) whose value(s) uniquely identify a row in a table. This is one of the most vital concepts in Relational Theory, and crucial to both identification and performance. A table should never be created before it's primary key is decided.

Query: A "question" to be made to the database. It is a SQL command that returns a subset of data in the database.

Record: It is the same as one line of the table.

Recursive relationship: Relationships among entities in the same class.

Relation: A table containing single-value entries and no duplicate rows. The meaning of the columns is the same in every row, and the order of the rows and columns is immaterial. Often, a relation is defined as a populated table.

Relationship: Link between entities. It is usually represented by a set of tuples containing all the data related among "N" entities. A relationship may define constraints.

Relational integrity: Relational integrity refers to the integrity of the foreign key references in a database. All foreign keys should refer to valid primary keys in other tables.

Referential Integrity: Referential integrity deals with governing data consistency. We mostly think of it as keeping the relations between tables valid; that is, an order may not have a customer id that does not exist; a transaction can not be posted for an illegal (non-existent) account.

Second Normal Form: A relation that is in first normal form and in which each non-key attribute is fully, functionally dependent on the primary key.

Simple attribute: Attribute composed of a single value.

Specialization: The process of maximizing the differences between members of a superclass entity by identifying their distinguishing characteristics.

Strong entity: An entity that is not dependent on another entity for its existence.

Structural constraints: Indicate how many of one type of record is related to another and whether the record must have such a relationship. The cardinality ratio and participation constraints, taken together, form the structural constraints.

Stored Procedure: A stored procedure is SQL (and procedural code, in most cases), placed in the database itself. It masks the business logic from the programmer. In addition, stored procedures represent a powerful tool to let all programmers have a generic interface to different access mechanisms to each table in the database.

Subclass: An entity type that has a distinct role and is also a member of a superclass.

Superclass: An entity type that includes distinct subclasses required to be represented in a data model.

SQL, "sequel" or Structured Query Language: Standard language for dealing with relational database systems. Its statements are responsible for specify and modify database schemas (DDL) as well as to manipulate the contents of the database (DML).

Table: The standard way to represent data in a relational database system. The collection of real-world objects with common properties (entities) are placed in the same table each one represented by one record (line, row, tuple) and its properties are represented by the columns of the table.

Third Normal Form: A relation that is in second normal form and in which no non-key attribute is functionally dependent on another non-key attribute (i.e., there are no transitive dependencies in the relation).

Trigger: A trigger is a stored procedure assigned to a given table. It ‘fires’ whenever you do an operation on that table (BEFORE/AFTER INSERT/UPDATE/DELETE etc.) Triggers are powerful, performance-enhancing mechanisms in the database.

Tuple: The formal way to represent the elements in a relation. A tuple may represent elements in a entity or in a relationship. It is an ordered pair which represents the relation itself.

Unique identifier: Any combination of attributes and/or relationships that serves to uniquely identify an occurrence of an entity.

View: An imaginary table: A view may be constructed to give the user/programmer access to a limited resultset from one or more tables. It is often used for security reasons; restricting access through views. However; it may also be a signal of insufficient design.

Waterfall model: A series of steps that software undergoes, from concept exploration through final retirement.

Weak entity: An entity that is dependent on some other entity for its existence.