Glossary
| Abstract class | A class from which no objects are created. |
| Abstract data type | In an object-oriented environment, a user-defined data type; a class. |
| Accessor method | A function that returns the values of private data stored about an object. |
| Aggregate function | A SQL function—for example, AVG and SUM—that computes a variety of measures based on values in one or more numeric columns. |
| Aggregation | In an object-oriented environment, a class that manages objects created from another class. |
| Array | In a SQL database, an ordered collection of elements of the same data type stored in a single column and row of a table. |
| Assertion | A constraint that is not attached to a table but is instead a distinct database object. It can therefore be used to enforce rules that apply to multiple tables or to verify that tables are not empty. |
| Attribute (relational database) | A column in a relation. |
| Attribute (XML element) | A data value that describes an XML element and is part of the element's tag rather than appearing in a separate element nested under the parent element. |
| Base class | A class at the “general” end of an inheritance relationship; a parent class. |
| Base table | A relation whose contents are physically and permanently stored in a database. |
| Before-image file | A file that contains images of every action taken by a transaction and is used to undo actions when a transaction is rolled back. |
| Case sensitive | Aware of the difference between upper- and lower-case letters. |
| Catalog | A group of schemas, usually composed of all schemas handled by a single DBMS. |
| Class | A declaration of data and methods that describe a single entity and that will be used as a template to create objects. |
| Cluster | A group of catalogs. Cluster definition is specific to a given DBMS. |
| Commit (a transaction) | End a transaction, making any changes that it made permanent. A committed transaction is never rolled back. |
| Common table expression (CTE) | A virtual table created by a SQL query that is used as the data source for another query. Unlike a view, the definition of a CTE is not stored in the database and must be used immediately after it is created. |
| Composition | A relationship between two classes where objects created from one class are part of objects created from the other. |
| Concrete class | A class from which objects are created. |
| Concatenated foreign key | A foreign key made up of two or more columns that references a concatenated primary key. |
| Concatenated primary key | A primary key made up of the combination of two or more columns. |
| Concatenation | Combining two strings by placing one at the end of the other. |
| Concurrent execution | The simultaneous handling of multiple transactions by a single database. |
| Connect (to a database) | Establish a user session with a database. |
| Constraint (on a relation) | A rule to which data stored in a relation must adhere. |
| Container class | In an object-oriented environment, a class that manages groups of objects created from another class. |
| Control class | A class that controls the operational flow of an object-oriented program. |
| Correlated subquery | A subquery that a DBMS cannot process completely before turning to the outer query. The DBMS must execute the subquery repeatedly for every row in the outer query. |
| Correlation name | An alias for a table used in a SQL query. |
| Cursor | A pointer to a row in the result table generated when an embedded SQL SELECT returns multiple rows. |
| Constructor | In an object-oriented environment, a method that is executed automatically every time an object is created from a class. |
| Data dictionary | In the broadest sense, documentation of a logical structure of a database. In relational database terms, a collection of tables that store data about the database. |
| Data dictionary driven | A property of a relational database where all access to data begins with a check of the data dictionary to determine whether the requested database elements are present in the database and whether the user has the necessary access rights to perform the requested action. |
| Database | A place to store data long with information about the relationships between the data. |
| Database management system (DBMS) | Software that manipulates a database, isolating the user from the physical file storage structures. |
| Declaration (in an XML document) | A statement at the beginning of an XML document that identifies the version XML being use and optionally a character encoding scheme. |
| Derived class | A class at the “specific” end of an inheritance relationship; a child class. |
| Destructor | In an object-oriented environment, a method that is run each time an object is destroyed (removed from main memory). |
| Difference | A relational algebra operation that returns the rows found in one table but not in another. |
| Dirty read | The problem that arises when a transaction reads the same data more than once, including data modified by concurrent transactions that are later rolled back. |
| Disconnect (from a database) | Terminate a user session with a database. |
| Divide | A relational algebra operation that searches for multiple rows in a table. |
| Domain | An expression of the set of values from which the values stored in a column of a relation are taken. |
| Drop | Delete an element of database structure from a database. |
| Dynamic embedded SQL | Embedded SQL in which the entire SQL statement cannot be assembled prior to running the program. The SQL statement is therefore completed and processed during the program run. |
| Dynamic parameter | A value given to an embedded SQL statement at runtime rather than when the program in which the statement is contained is compiled. |
| Embedded SQL | SQL statements placed within a host language, allowing SQL to be executed by application programs. |
| Entity | Something about which we store data in a database environment, such as customer, an inventory item, or a sale. |
| Entity class | In an object-oriented environment, a class that is used to create objects that manipulate data. |
| Entity-relationship diagram (ERD) | A graphic method for depicting the relationships in a database environment. |
| Equi-join | A join that combines two tables based on matching (equivalent) data in rows in the two tables. |
| Escape character | A character, usually , that removes the special meaning of whatever follows in a literal string. |
| Exclusive lock | A lock on a database element that prevents other transactions from updating or viewing the database element while the lock is held. |
| Extensible markup language (XML) | A way of representing data and data relationships in text files, typically for data exchange between software of different types. |
| Field | A piece of data contained within a column of the ROW data type. |
| Foreign key | A column or combination of columns that is the same as the primary key of some table in the database. |
| Frame (in a windowing query) | A portion of a windowing query's window that “slides” to present to the DBMS the rows that share the same value of the partitioning criteria. |
| Function | A small program that performs one task and returns a single value. It may be built into the SQL language or written by a user, database administrator, or application programmer. |
| Get method | A function that returns the values of private data stored about an object. |
| Grant | Give access rights to database elements to users. The user that creates a database element has all rights to that element. Other users have no access unless they are specifically granted access rights. |
| Granularity (of a lock) | The size of the database element on which a lock is placed (usually a table or a row within a table). |
| Grouping query | A query that groups rows of data based on common values in one or more columns and that optionally computes summary values from each group. |
| Hierarchy | A structure for data relationships where all relationships are one-to-many and no child entity may have more than one parent entity. |
| Host language | A programming language in which SQL statements are embedded. |
| Identifier chain | The fully qualified name of an element in a SQL database, including the catalog, schema, table, and column of the element. |
| Indeterminate cursor | A cursor in which the effects of updates by the same transaction on the result table are left up to each DBMS. |
| Index | A data structure that provides a fast-access path to one or more columns in a relation. |
| Indicator variable | A variable that accompanies an embedded SQL dynamic parameter to indicate the presence of nulls in the parameter. |
| Inheritance | A general to specific relationship between classes in an object-oriented environment. |
| Inner join | A join that excludes rows for which there is no match between the tables being joined. |
| Input parameter | A value sent by an embedded SQL statement to the DBMS. |
| Insensitive cursor | A cursor for which the contents of the result table to which it points are fixed. |
| Instance (of a relation) | A relation containing one or more rows of data. |
| Interactive SQL | Individual SQL statements entered from the keyboard and processed immediately. |
| Interface class | In an object-oriented environment, a class that handles input and output operations. |
| Interleaved execution | A sequence of executing concurrent transactions in which the actions of two or more transactions alternate. |
| Intersect | A relational algebra operation that returns all rows common to two tables. |
| Isolation level | The degree to which a transaction can view data modified by other transactions running concurrently. |
| Join | A relational algebra operation that combines two tables making new rows that are a combination of one row from each of the two source tables. |
| Locking | The processing of giving a transaction exclusive rights to view and/or update a database element to prevent problems that arise with interleaved transaction execution. |
| Lost update | An error condition that occurs when the interleaved execution of a transaction wipes out an update of another transaction. |
| Markup language | A set of special codes placed inside a text document to identify the elements of the document and optionally to give instructions to software using the document. |
| Message | Requests for data manipulation sent from one object to another. |
| Method (class) | A program module that acts on objects created from a class in an object-oriented program. |
| Method (SQL) | A program module that is part of a user-defined data type that is used to create objects. |
| Module | A group of SQL routines. |
| Multiset | In a SQL database, an unordered collection of elements of the same data type that is stored in a single column and row. |
| Mutator method | A function that modifies the values of private data stored about an object. |
| Natural equi-join | An equi-join. |
| Nonprocedural | A process that specifies “what” but not “how,” leaving the manner in which the result is obtained up to the DBMS. |
| Nonrepeatable read | The difference in result tables that occurs when a nonserialized transaction reads the same data twice and retrieves different values but the same rows as the result of the actions of other interleaved transactions. |
| Null | A value, distinct from 0 or a blank, that means “unknown.” |
| Object | An instance of a self-contained element used by an object-oriented program, containing data that describe the specific element and links to program modules that operate on the element. |
| Object-oriented | A programming and database environment in which elements in the environment are conceptualized as entities and data and programs are stored together. |
| Outer join | A join that preserves all rows from both source tables. Where a new row cannot be formed by combining rows, the outer join places nulls in empty columns. |
| Output parameter | A value returned by an embedded SQL statement to the host language program. |
| Overloading | In an object-oriented environment, two methods of the same class that have the same name but different signatures (input parameters and data types). |
| Partition (in a windowing query) | A set of rows for which an aggregate function will compute a summary value. |
| Persistent stored module (PSM) | A SQL program written using the SQL programming language. |
| Phantom read | The difference in result tables that occurs when a nonserialized transaction reads the same data twice and different rows are retrieved as a result of the actions of other interleaves transactions. |
| Polymorphism | The redefinition of the body of a superclass method inherited by a subclass. The polymorphic method retains the same signature. |
| Precedence | The order in which a DBMS evaluates operators in a predicate when multiple operators are present. |
| Precision | In a floating-point number, the number of digits to the right of the decimal point. |
| Precompiler | A program processor that examines a source code file for SQL statements and translates them into calls to routines in external program libraries. The result is another source code file that can be compiled by a normal programming language compiler. |
| Predicate | A logical expression used to qualify the rows that are affected by a data manipulation request. |
| Primary key | One or more columns whose values uniquely identify every row in a relation. |
| Procedural | A process that is expressed in a step-by-step manner. It specifies “how” as well as “what.” |
| Procedure | A SQL routine that is stored in a database and executed with the SQL CALL statement. It does not return a value. |
| Product | A relational algebra operation that forms all possible combinations of rows from two source tables. |
| Project | A relational algebra operation that takes a vertical subset of a table. In other words, it extracts complete columns. |
| Prolog (of an XML document) | A statement at the beginning of an XML document that identifies the version of XML being used and optionally a character encoding scheme. |
| Query optimizer | A part of a DBMS that examines a nonprocedural data manipulation request and makes a determination of the most efficient way to process that request. |
| Read lock | A lock on a database element that prevents other transactions from updating the database element while the lock is held. |
| Recursive query | A query that queries itself. |
| Referential integrity | A constraint on a relation that states that every nonnull foreign key value must reference an existing primary key value. |
| Relation | The defintion of the structure of a two-dimensional table with columns and rows. |
| Relational algebra | A set of procedural operations used to manipulate relations. |
| Relational calculus | A set of nonprocedural operations used to manipulate relations. |
| Restrict | A relational algebra operation that takes a horizontal subset of the rows in a table, usually choosing the rows that meet the logical criteria specified in a predicate. |
| Revoke | Remove previously granted access rights from a user. |
| Roll back (a transaction) | End a transaction, undoing any changes made by the transaction and restoring the database to the state it was in before the transaction began. |
| Root (of an XML hierarchy) | The top node in a hierarchy, providing a single point of access to the hierarchy. |
| Routine | The smallest unit of a SQL PSM. Typically it performs a single action, such as updating a total or inserting a row in a table. |
| Schema (relational database) | In database design theory, the overall logical design of a database. In a SQL DBMS, a group of tables and supporting elements such as views and indexes. |
| Schema (XML) | A special type of XML document that contains definitions of document structure used to validate XML documents that contain data. |
| Signature (of a function) | The name and parameters of a function. |
| Scope (of a temporary table) | The visibility of a temporary table. Local temporary tables can be seen only by the program module that created them. Global temporary tables can be seen by the entire database session. |
| Scrollable cursor | A cursor that can move to the first, last, or prior row in a table rather than just to the next row. |
| Serial execution | A sequence of executing concurrent transactions in which one transaction runs from start to finish before a second transaction begins. |
| Serializable | A property of interleaved transaction execution such that the result of the interleaved execution is the same as the result of serial execution. |
| Session | A block of time during which a user interacts with a database. |
| Set function | A SQL function—for example, AVG and SUM—that computes a variety of measures based on values in one or more numeric columns. |
| Set method | A function that modifies the values of private data stored about an object. |
| Shared lock | A lock on a database element that prevents other transactions from updating the database element while the lock is held. |
| Static embedded SQL | Embedded SQL in which the entire SQL statement can be specified when the program is written, allowing the statement to be precompiled before the program is executed. |
| Stored procedure | A SQL program module that is invoked by an application program using the SQL CALL command. Stored procedures are stored in the database they manipulate. |
| Subclass | A class at the “specific” end of an inheritance relationship; a child class. |
| Subquery | A complete SELECT statement that is part of another SELECT. |
| Substring | A portion of a string. |
| Superclass | A class at the “general” end of an inheritance relationship; a parent class. |
| Tag | The markup device in an XML file. XML tags exist in pairs, with an opening tag before the element being identified and a closing tag after it. |
| Temporary table | A relation whose contents are not stored in the database but that exists only during the database session in which it was created. |
| Θ-join (theta-join) | A join that combines two tables on some condition, which may be equality or something else such as greater than or less than. |
| Three-valued logic | A system of logic in which logical expressions can be evaluated to true, false, or maybe. It is the result of the presence of nulls in relations. |
| Transaction | A unit of work presented to a database. The transaction may be committed, in which case any changes it made to the database are permanent or it may be rolled back, in which case any changes it made to the database are rolled back. |
| Tree structure | A structure for data relationships where all relationships are one-to-many and no child entity may have more than one parent entity. |
| Trigger | A SQL program module that is executed when a specific data modification activity occurs. Triggers are stored in the database they manipulate. |
| Truncate (a table) | Remove all rows from a table, leaving the structure of the table in the database's data dictionary. |
| Tuple | A row in a relation. |
| Two-phase locking | A locking scheme in which a transaction is given a shared lock on a database element when it retrieves a value. The shared lock is upgraded to an exclusive lock when the transaction attempts to modify the value. |
| Typecast | Change the data type of a value for output or use in a SQL program. |
| Typed table | A table created as a class using a user-defined data type to define the structure of the objects to be stored in the table. Each row contains one object. |
| Uncorrelated subquery | A subquery that a DBMS can process completely before processing the query in which the subquery is contained. |
| Union | A relational algebra operation that combines two tables by merging their rows into the same structure. |
| Union compatible | A property of two tables where all columns in both tables are drawn from the same logical domains. |
| Updatability | A property of a view that indicates whether it can be used to perform updates that can then be propagated to the base table from which it was derived. |
| User-defined data type (UDT) | In a SQL database, a declaration of a structured data type that can be used as the domain of a column or as an object. |
| View | A stored SQL query from which a virtual table is created for use each time the name of the view is used. |
| Virtual class | A class from which no objects are created. |
| Virtual table | A table that exists only in main memory. It may be created by the end user as a temporary table or it may be created by a DBMS to hold the results of a query. |
| Wait state | A hold placed by a DBMS on the execution of a transaction because the transaction is unable to obtain a needed lock on a database element, usually because the element is locked by another transaction. The transaction must wait until the lock can be placed. |
| Well-formed XML document | An XML document that meets all the XML syntax rules including having only one root element, paired tags, case sensitive tags, proper tag nesting, and quoted attribute values. |
| Window | A set of rows for which an aggregate function will compute a summary value. |
| Windowing | A SQL technique for computing aggregate measures for groups of rows that also displays the individual rows in each group. |
| Windowing function | A function that computes an aggregate measure about a partition in a windowing query. |
| Write lock | A lock on a database element that prevents other transactions from updating or viewing the database element while the lock is held. |
| XML | A way of representing data and data relationships in text files, typically for data exchange between software of different types. |
| XML schema | A special type of XML document that contains definitions of document structure used to validate XML documents that contain data. |
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.