| All-key relation: | A relation in which every column is part of the primary key. |
| Attribute: | Data that describe an entity; the formal term for a column in a relation. |
| Authorization matrix: | A database system table that contains information about which users have access to which parts of the database. The DBMS consults the authorization matrix before performing user data manipulation requests. |
| Base table: | Relations whose data are physically stored in a database. |
| Binary large object (BLOB): | A column data type specifying that the column will show the contents of a file (text and/or graphics) in its binary representation, without being searchable or readable in any way by the DBMS. |
| Black hat hackers: | Hackers who break into a computer system for profit or with a desire to do harm. |
| Buffer overflow attack: | An attempt to gain unauthorized control over a computer system by exploiting a programming error in an application or system program. |
| Candidate key: | A column or combination of columns that can be used as the primary key of a relation. |
| Cardinality (of a relationship): | The type of relationship (one-to-one, one-to-many, or many-to-many). |
| Catalog: | Another term for a data dictionary. |
| Circular inclusion constraint: | A constraint on a relation that specifies that if a row is added to a specific table, rows must be added to one or more other tables. |
| Client/server architecture: | System architecture where processing tasks are shared between server and client computers. |
| Clustering: | Physically storing foreign key rows close to the primary key rows they reference to improve database performance. |
| CODASYL database: | A database that adheres to the Committee on Data Systems Languages (CODASYL) database standard. |
| Column homogeneous: | A property of a relation stating that all the values in a given column are taken from the same domain. |
| Commit (a transaction): | End a transaction by making its changes permanent. |
| Committee on Data Systems Languages (CODASYL): | A committee of government and industry technologists that developed the COBOL programming language and a standard for a simple network database. |
| Complex network data model: | A navigational data model that permits direct many-to-many relationships as well as one-to-many and one-to-one relationships. |
| Composite entity: | An entity that exists to represent the relationship between two other entities. It may have relationship data as attributes. |
| Computer-aided software engineering (CASE) tool: | A software package that provides specialized tools for software and database modeling diagrams. |
| Concatenated identifier: | An entity identifier made up of a combination of values from multiple attributes. |
| Concurrency control: | Mechanisms to ensure that a database remains consistent and accurate during concurrent use. |
| Concurrent use: | Multiple users working with the same database at the same time. |
| Conforming parser: | Software that can read an XML document to determine whether the document is well formed. |
| Constraint: | A rule to which data in a database must adhere. |
| Context diagram: | The top-level diagram in a data flow diagram that shows the environmental context in which the information system exists. |
| Currency indicator: | A system value kept by a navigational database to indicate a transaction's current position in the database hierarchy. |
| Cyberterrorists: | Hackers who are motivated by a political, religious, or philosophical agenda. |
| Cylinder: | The same track on all surfaces in a stack of platters in a hard disk. |
| Database: | A collection of data and information about the relationships among those data. |
| Database administrator (DBA): | A person who has the responsibility for maintaining a database. |
| Database key: | In a CODASYL database, an internal pointer to the physical storage location of a record occurrence in a file. |
| Database management system (DBMS): | Software that manages the storage and retrieval of data stored in a database. |
| Data definition language: | A special-purpose computer language used to define the schema of a navigational database. |
| Data dictionary: | A repository that describes the data stored in a database along with definitions of data relationships. |
| Data dictionary driven: | A property of relational databases in which all access to stored data is preceded by access to the data dictionary to determine if the requested data elements exist and if the user has the access rights to perform the requested action. |
| Data flow: | The path taken by data as they are processed throughout an organization. |
| Data flow diagram (DFD): | A graphic method for documenting the flow of data within an organization. |
| Data mart: | A small data warehouse. |
| Data model: | The formal way of expressing relationships in a database. |
| Data store (in a DFD): | A place where data are stored. |
| Data warehouse: | A repository of transaction and nontransaction data used for querying, reporting, and corporate decision making. |
| Deadlock: | A problem that occurs as a result of exclusive/writing locking where two or more transactions become stalled waiting for the release of locks held by each other. |
| Deletion anomaly: | A problem with the design of a relation such that deleting data about one entity in a row causes a part of the primary key to become null, requiring the deletion of the entire row, which may contain data that must be retained. |
| Denial of service attack: | An attack on a computer system that attempts to prevent legitimate users from gaining access to network resources and, by extension, any database that uses that network. |
| Determinant: | An attribute on which other attributes are functionally dependent. |
| Dimensional modeling: | The most frequently used data model for data warehouses. |
| Dimension table: | A table in a data warehouse that contains descriptive information for grouping data stored in fact tables. |
| Dirty read: | A problem with uncontrolled concurrent use of a database where a transaction acts on data that have been modified by an update transaction that hasn't committed and is later rolled back. |
| Disaster recovery: | Activities that must take place to bring the database back into use after it has been damaged in some way. |
| Distributed database: | A database where portions of the database are stored on computers at physically distributed locations. The entire database is the sum of all the parts. |
| Distribution independence: | A constraint on a distributed database that specifies that the database should look and act like a centralized database to users. |
| Domain: | A specification of permissible values for an attribute. |
| Domain constraint: | A rule that requires that all values of an attribute come from a specified domain. |
| Entity: | Something about which we store data. |
| Entity identifier: | A value (or combination of values) that uniquely identifies each occurrence of an entity in a database. |
| Entity integrity: | A constraint on a relation that states that no part of the primary key can be null. |
| Entity-relationship diagram (ERD): | A graphic technique for representing entity relationships. |
| Entity-relationship (ER) model: | A technique for representing entity relationships that is independent of any specific data model and any specific software. |
| Equi-join: | A join based on matching identical values. |
| Evolutionary prototyping: | A form of prototyping in which successive prototypes of the software are modified based on user feedback, eventually converging on the production system. |
| Exclusive lock: | A lock that gives the transaction holding the lock the exclusive right to read and write a portion of the database. |
| Extensible markup language (XML): | A platform-independent markup language for specifying the structure of data in a text document used for both data storage and the transfer of data. |
| Extract-transform-load: | The process of taking data from operational databases (and optionally external sources), modifying the data to meet the requirements of a data warehouse, and loading the data into the warehouse. |
| Fact table: | A table used in dimensional modeling to contain summarizable facts. |
| Field: | In a file processing system, the smallest unit of meaningful data, such as a first name or street address. |
| File processing system: | A system that handles data by storing them in data files and then manipulating the files through application programs. |
| Firewall: | A piece of software that filters incoming and outgoing network traffic and stops messages that violate the rules that define allowable traffic. |
| Foreign key: | An attribute (or combination of attributes) in a relation that is the same as the primary key of another relation. A foreign key may be a non-key attribute in its own relation, or it may be part of a concatenated primary key. |
| Functional dependency: | A relationship between two attributes (or two combination of attributes) in a relation such that for every unique value of the second attribute, the table contains only one value of the first attribute. The first attribute, however, may be associated with multiple values of the second attribute. |
| Granularity (of a lock): | The size of the portion of a database to which a lock is applied. |
| Hashing: | A technique for providing fast access to data based on a key value by determining the physical storage location of those data. |
| Hierarchical data model: | A legacy data model where all relationships are one-to-many or one-to-one, and entities at the “many” end of a relationship can be related to only one entity at the “one” end of the relationship. |
| Horizontal portioning: | Splitting the rows of a table between multiple tables with the same structure to improve database performance. |
| Inconsistent analysis: | A problem that occurs from uncontrolled concurrent use of a database where a transaction produces incorrect output because another transaction was concurrently modifying data being retrieved. |
| Index: | A data structure in a database that provides a logical ordering of data based on key values. |
| Indexed sequential access method (ISAM): | A physical file storage technique that also provides indexes to data based on a key for fast access on that key. |
| Inner join: | An equi-join. |
| Insertion anomaly: | A problem with the design of a relation such that all data for a complete primary key are not available, preventing data from being stored in the relationship. |
| Instance (of an entity): | A group of attributes that describes a single real-world occurrence of an entity. |
| Instance (of a relation): | A relation that contains at least one row of data. |
| Interleaved execution: | The interweaving of the actions of two or more concurrent database transactions. |
| IPSec: | A type of security used by a virtual private network. |
| Join: | A relational algebra operation that combines two relations horizontally by matching values between the two tables. Most valid joins involve matching primary key values to foreign key values. |
| Join dependency: | The most general form of dependency between attributes in a relation such that a table can be put together correctly by joining two or more tables, all of which contain only attributes from the original table. |
| Legacy database: | A database using a pre-relational data model that is still in use. |
| Locking: | Restricting access to parts of a database to specific transactions to provide concurrency control. |
| Logging: | The process of keeping an audit trail of changes made by a transaction to be used to undo the transaction should it need to be rolled back. |
| Lost update: | A problem that occurs during uncontrolled concurrent use of a database where an update made by one transaction wipes out the effect of an update made by a concurrent transaction. |
| Malware: | Unwanted software—such as a virus, worm, or Trojan horse—that is inadvertently loaded onto a computer and causes disruption or distribution of computer functioning. |
| Mandatory relationship: | A relationship between two entities in a database such that an instance of the second entity cannot exist in the database unless it is related to an instance of the first entity. |
| Many-to-many relationship: | A relationship between two entities in a database such that each instance of the first entity can be related to many instances of the second and each instance of the second entity can be related to many instances of the first. |
| Metadata: | Data about data; the data stored in a data dictionary. |
| Modification anomaly: | A problem that occurs when duplicated data become inconsistent when not all occurrences of the same value are modified at the same time. |
| Multivalued attribute: | An attribute that can contain more than one value at a time. |
| Multivalued dependency: | A general case of a functional dependency where a determinant determines a small group of values (as opposed to a single value) for two unrelated attributes. |
| Multiversion concurrency control: | A concurrency control method in which data retrievals and modifications are marked with the time they occur. Modifications are allowed if no other transaction holds an earlier timestamp on the data. |
| Mutually exclusive relationship: | A relationship between entities such that an instance of an entity can be related to an instance of either a second or third entity, but not both. |
| Natural identifiers: | Entity identifiers that are unique by nature, such as invoice numbers. |
| Navigational data model: | A data model where relationships between entities are represented by physical data structures (for example, pointers or indexes) that provide the only paths for data access. |
| Nonrepeatable read: | A problem with uncontrolled concurrent use of a database that occurs when a transaction reads data for the second time and determines that the data are not the same as they were from the first read. |
| Normal form: | A set of theoretical rules to which a relation must conform. |
| Normalization: | The process of designing relations to adhere to increasingly stringent sets of rules to avoid problems with poor database design. |
| Null: | A database value, distinct from a blank or zero, meaning “unknown.” |
| Object-oriented analysis: | A method for viewing the interaction of data and manipulations of data that is based on the object-oriented programming paradigm. |
| One-to-many relationship: | A relationship between two entities in a database such that one instance of an entity can be related to many instances of a second entity and the second entity can be related to only one instance of the first. |
| One-to-one relationship: | A relationship between two entities in a database such that each instance of an entity is related to no more than one instance of the other entity. |
| Optimistic locking: | A concurrency control method that allows all modifications but then rolls back transactions if other transactions have modified the data. |
| Page: | The size of the block of data that a computer (and therefore a database) transfers between disk and main memory at one time. |
| Performance tuning: | Making changes to the design of a database to enhance database performance. |
| Phantom read: | A problem with uncontrolled concurrent use of a database that occurs when a transaction reads data for the second time and determines that new rows have been inserted by another transaction. |
| Physical schema: | The underlying physical storage of a database, managed by the DBMS. |
| Precision: | The number of digits to the right of a decimal point in a number. |
| Predicate: | A statement of logical criteria against which data are evaluated during a query. |
| Primary key: | A column or combination of columns whose value uniquely identifies each row in a relation. |
| Process (in a DFD): | Something that is done to data. |
| Product: | The relational algebra operation that combines two tables by forming all possible combination of rows; the Cartesian product of two tables. |
| Project: | The relational algebra operation that creates a projection of a relation. |
| Projection: | A subset of a relation created by copying selected columns and all rows in those columns. |
| Prototyping: | A form of system development where developers prepare models of a system that are not fully functional. User feedback is used to modify the prototype or to develop a final system. |
| Query optimizer: | A portion of a DBMS that determines the most efficient sequence of relational algebra operations to use to satisfy a query. |
| Read lock: | Control over a portion of the database given to one or more transactions that prevents other transactions from modifying the data while the locks are in place. |
| Reblocking: | In an ISAM file, rewriting the file to leave physical space on each track occupied by the file to allow the addition of records in key sequence order. |
| Record: | In a file processing system, a collection of data that describes one instance of an entity. |
| Recovery: | The process of restoring a database from a damaged or inconsistent state so it becomes operational again. |
| Referential integrity: | A constraint on a relation that states that every non-null foreign key value must match an existing primary key value. |
| Relation: | The definition of a two-dimensional table with columns and rows. There is no more than one value at the intersection of each column and row (no repeating groups). |
| Relational algebra: | The set of theoretical operations used to manipulate data in a relation. |
| Relational data model: | A paradigm for describing the structure of a database in which entities are represented as tables, and relationships between the entities are represented by matching data. |
| Relationship data: | Data that apply to the relationship between two entities rather than to the entities themselves. |
| Repeating group: | A multivalued attribute that must be removed before the data in the group can be stored in a relational database. |
| Requirements document: | A document prepared as the output of a systems analysis that describes the information requirements of a new or modified information system. |
| Restrict: | The more recent term for the relational algebra operation that chooses rows from a table based on evaluating data against logical criteria (a predicate). |
| Roll back (a transaction): | Undo the changes made by a transaction, restoring the database to the state it was in before the transaction began. |
| Schema: | The overall logical plan of a database. |
| Script kiddies: | Hackers who use prewritten software to break into computer systems. |
| Select: | The original relational algebra term for restrict; the SQL command to retrieve data from a database. |
| Serializable: | A condition in which interleaved transactions produce the same result that they would have produced if they had run in a series. |
| Service-oriented architecture (SOA): | A method for organizing a company's entire information system functions so all information components are viewed as services that are provided to the organization. |
| Set: | In a CODASYL database, a two-level hierarchy representing one or more one-to-many relationships. |
| Shared lock: | Control over a portion of the database given to one or more transactions that prevents other transactions from modifying the data while the locks are in place. |
| Simple network data model: | A legacy data model where all relationships are one-to-many or one-to-one; a navigational data model where relationships are represented with physical data structures such as pointers. |
| Single-valued attribute: | An attribute that contains only one value at any given time. |
| Social engineering: | A nontechnological method for gaining unauthorized access to a computer system by tricking people into revealing access information. |
| Sorting: | Physically reordering the rows in a table based on the values in one or more columns. |
| Spiral methodology: | A more formal form of prototyping that uses a gradual process in which each cycle further refines the system, bringing it closer to the desired end point. |
| SQL injection attack: | An attack against a database system launched through an application program containing embedded SQL. |
| Structured design life cycle: | The classic model for developing an information system. It involves a sequence of activities that defines and develops a new or modified system. It works best in environments where information needs are well known. |
| Systems analysis: | Conducting a needs assessment to determine what a new or modified information system should do. |
| System set: | In a CODASYL database, a special set with only one owner occurrence that is used to collect all occurrences of a single entity. |
| Table: | A term used synonymously with relation in the relational data model. |
| Three-schema architecture: | A view of a database environment in which the logical schema provides an interface between the physical schema and user views of the database. |
| Three-valued logic: | A set of logical truth tables that include the values true, false, and unknown. |
| Throwaway prototyping: | A type of prototyping in which the prototype software is demonstrated and evaluated and then discarded. The production system is developed from scratch based on feedback to the prototype. |
| Timestamping: | A concurrency control method in which data retrievals and modifications are marked with the time they occur. Modifications are allowed if no other transaction holds an earlier timestamp on the data. |
| Transaction: | A unit of work presented to a database. |
| Transitive dependency: | A set of functional dependencies where an attribute that is a candidate key for its relation determines a second attribute, and the second attribute determines a third, producing a functional dependency between the first and third as well. |
| Tree: | In the hierarchical data mode, a single entity hierarchy. |
| Tuple: | The formal term for a row in a relations. |
| Two-phase locking: | A concurrency control method that begins by giving transactions shared/read locks on data and then upgrades the locks to exclusive/write locks only when the transaction is ready to modify data. |
| Unified modeling language (UML): | A style of ER diagramming. |
| Unit of recovery: | A transaction,, called so because a transaction either succeeds or fails as a whole. |
| Update anomaly: | A problem that occurs when duplicated data become inconsistent when not all occurrences of the same value are modified at the same time. |
| Vertical partitioning: | Storing a relation as two or more tables that are projections of the original relation to improve database performance. |
| View: | A virtual table that is constructed by executing a named query that is stored as part of a database. |
| Virtual private network (VPN): | A method that provides remote access to local area networks that uses the Internet and encrypts transmissions for security. |
| Virtual table: | A table whose data exist only in main memory rather than being stored physically in the database. |
| Waterfall method: | An alternative name for the traditional structured systems development life cycle based on the idea that one step falls into another. |
| Weak entity: | An entity whose instances cannot exist in a database unless a related instance of another entity is present and related to it. |
| Well-formed (XML document): | An XML document that conforms to the syntax rules for a correct document. |
| White hat hackers: | Hackers who break into computer systems and then report vulnerabilities to the software owner or developer. Their motives are usually to help make systems more secure. |
| Write lock: | A lock that gives the transaction holding the lock the exclusive right to read and write a portion of the database. |
| XML schema: | A document without data that specifies the structure of an XML document. |
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.